1995-02-26 12:18:08 +00:00
|
|
|
/* $NetBSD: if_tun.c,v 1.14 1994/06/29 06:36:25 cgd Exp $ */
|
|
|
|
|
1995-01-31 06:15:49 +00:00
|
|
|
/*
|
|
|
|
* 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
|
1998-04-17 22:37:19 +00:00
|
|
|
* user process to have its wicked way with. This driver has it's
|
1995-01-31 06:15:49 +00:00
|
|
|
* roots in a similar driver written by Phil Cockcroft (formerly) at
|
1997-09-14 03:09:01 +00:00
|
|
|
* UCL. This driver is based much more on read/write/poll mode of
|
1995-01-31 06:15:49 +00:00
|
|
|
* operation though.
|
1999-09-25 12:06:01 +00:00
|
|
|
*
|
|
|
|
* $FreeBSD$
|
1995-01-31 06:15:49 +00:00
|
|
|
*/
|
|
|
|
|
1998-01-08 23:42:31 +00:00
|
|
|
#include "opt_inet.h"
|
2002-07-31 16:23:42 +00:00
|
|
|
#include "opt_mac.h"
|
1998-01-08 23:42:31 +00:00
|
|
|
|
1995-02-26 12:18:08 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/systm.h>
|
2002-07-31 16:23:42 +00:00
|
|
|
#include <sys/mac.h>
|
1995-02-26 12:18:08 +00:00
|
|
|
#include <sys/mbuf.h>
|
2001-01-31 07:58:58 +00:00
|
|
|
#include <sys/module.h>
|
1995-02-26 12:18:08 +00:00
|
|
|
#include <sys/socket.h>
|
1997-03-24 12:12:36 +00:00
|
|
|
#include <sys/filio.h>
|
|
|
|
#include <sys/sockio.h>
|
|
|
|
#include <sys/ttycom.h>
|
1997-09-14 03:09:01 +00:00
|
|
|
#include <sys/poll.h>
|
1995-03-16 18:17:34 +00:00
|
|
|
#include <sys/signalvar.h>
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
#include <sys/filedesc.h>
|
1995-02-26 12:18:08 +00:00
|
|
|
#include <sys/kernel.h>
|
1995-12-09 20:47:15 +00:00
|
|
|
#include <sys/sysctl.h>
|
1995-04-10 20:35:45 +00:00
|
|
|
#include <sys/conf.h>
|
1997-11-18 16:36:15 +00:00
|
|
|
#include <sys/uio.h>
|
|
|
|
#include <sys/vnode.h>
|
1999-08-15 09:54:57 +00:00
|
|
|
#include <sys/malloc.h>
|
2001-06-01 15:51:10 +00:00
|
|
|
#include <machine/bus.h> /* XXX Shouldn't really be required ! */
|
|
|
|
#include <sys/rman.h>
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
#include <net/if.h>
|
2000-07-17 23:21:42 +00:00
|
|
|
#include <net/if_types.h>
|
1995-01-31 06:15:49 +00:00
|
|
|
#include <net/route.h>
|
2000-01-24 20:39:02 +00:00
|
|
|
#include <net/intrq.h>
|
1995-01-31 06:15:49 +00:00
|
|
|
#ifdef INET
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#endif
|
|
|
|
#include <net/bpf.h>
|
1998-01-11 17:52:29 +00:00
|
|
|
#include <net/if_tunvar.h>
|
1995-01-31 06:15:49 +00:00
|
|
|
#include <net/if_tun.h>
|
|
|
|
|
|
|
|
#define TUNDEBUG if (tundebug) printf
|
2001-06-01 15:51:10 +00:00
|
|
|
#define TUNNAME "tun"
|
|
|
|
#define TUN_MAXUNIT 0x7fff /* ifp->if_unit is only 15 bits */
|
|
|
|
|
|
|
|
static MALLOC_DEFINE(M_TUN, TUNNAME, "Tunnel Interface");
|
1995-12-09 20:47:15 +00:00
|
|
|
static int tundebug = 0;
|
2001-04-03 01:22:15 +00:00
|
|
|
static struct tun_softc *tunhead = NULL;
|
2002-10-20 20:53:42 +00:00
|
|
|
static struct rman tununits;
|
2001-06-01 15:51:10 +00:00
|
|
|
static udev_t tunbasedev = NOUDEV;
|
1996-02-09 09:23:56 +00:00
|
|
|
SYSCTL_INT(_debug, OID_AUTO, if_tun_debug, CTLFLAG_RW, &tundebug, 0, "");
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2001-06-01 15:51:10 +00:00
|
|
|
static void tunclone(void *arg, char *name, int namelen, dev_t *dev);
|
|
|
|
static void tuncreate(dev_t dev);
|
|
|
|
static int tunifioctl(struct ifnet *, u_long, caddr_t);
|
|
|
|
static int tuninit(struct ifnet *);
|
|
|
|
static int tunmodevent(module_t, int, void *);
|
|
|
|
static int tunoutput(struct ifnet *, struct mbuf *, struct sockaddr *,
|
|
|
|
struct rtentry *rt);
|
|
|
|
static void tunstart(struct ifnet *);
|
|
|
|
|
|
|
|
static d_open_t tunopen;
|
|
|
|
static d_close_t tunclose;
|
|
|
|
static d_read_t tunread;
|
|
|
|
static d_write_t tunwrite;
|
|
|
|
static d_ioctl_t tunioctl;
|
|
|
|
static d_poll_t tunpoll;
|
1995-12-08 11:19:42 +00:00
|
|
|
|
|
|
|
#define CDEV_MAJOR 52
|
|
|
|
static struct cdevsw tun_cdevsw = {
|
1999-05-30 16:53:49 +00:00
|
|
|
/* open */ tunopen,
|
|
|
|
/* close */ tunclose,
|
|
|
|
/* read */ tunread,
|
|
|
|
/* write */ tunwrite,
|
|
|
|
/* ioctl */ tunioctl,
|
|
|
|
/* poll */ tunpoll,
|
|
|
|
/* mmap */ nommap,
|
|
|
|
/* strategy */ nostrategy,
|
2001-06-01 15:51:10 +00:00
|
|
|
/* name */ TUNNAME,
|
1999-05-30 16:53:49 +00:00
|
|
|
/* maj */ CDEV_MAJOR,
|
|
|
|
/* dump */ nodump,
|
|
|
|
/* psize */ nopsize,
|
|
|
|
/* flags */ 0,
|
1995-11-06 00:36:19 +00:00
|
|
|
};
|
1995-04-10 20:35:45 +00:00
|
|
|
|
2000-08-20 21:34:39 +00:00
|
|
|
static void
|
2001-06-01 15:51:10 +00:00
|
|
|
tunclone(void *arg, char *name, int namelen, dev_t *dev)
|
2000-08-20 21:34:39 +00:00
|
|
|
{
|
2001-06-01 15:51:10 +00:00
|
|
|
struct resource *r;
|
|
|
|
int err;
|
2000-08-20 21:34:39 +00:00
|
|
|
int u;
|
|
|
|
|
|
|
|
if (*dev != NODEV)
|
|
|
|
return;
|
2001-06-01 15:51:10 +00:00
|
|
|
|
|
|
|
if (strcmp(name, TUNNAME) == 0) {
|
2002-10-20 20:53:42 +00:00
|
|
|
r = rman_reserve_resource(&tununits, 0, TUN_MAXUNIT, 1,
|
2001-06-01 15:51:10 +00:00
|
|
|
RF_ALLOCATED | RF_ACTIVE, NULL);
|
|
|
|
u = rman_get_start(r);
|
|
|
|
err = rman_release_resource(r);
|
|
|
|
KASSERT(err == 0, ("Unexpected failure releasing resource"));
|
|
|
|
*dev = makedev(CDEV_MAJOR, unit2minor(u));
|
|
|
|
if ((*dev)->si_flags & SI_NAMED)
|
|
|
|
return; /* Already make_dev()d */
|
|
|
|
} else if (dev_stdclone(name, NULL, TUNNAME, &u) != 1)
|
|
|
|
return; /* Don't recognise the name */
|
|
|
|
|
2001-02-02 03:32:25 +00:00
|
|
|
*dev = make_dev(&tun_cdevsw, unit2minor(u),
|
2001-02-03 00:31:39 +00:00
|
|
|
UID_ROOT, GID_WHEEL, 0600, "tun%d", u);
|
2001-06-01 15:51:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* All devices depend on tunbasedev so that we can simply
|
|
|
|
* destroy_dev() this device at module unload time to get
|
|
|
|
* rid of all our make_dev()d resources.
|
|
|
|
*/
|
|
|
|
if (tunbasedev == NOUDEV)
|
|
|
|
tunbasedev = (*dev)->si_udev;
|
|
|
|
else {
|
|
|
|
(*dev)->si_flags |= SI_CHEAPCLONE;
|
|
|
|
dev_depends(udev2dev(tunbasedev, 0), *dev);
|
|
|
|
}
|
2000-08-20 21:34:39 +00:00
|
|
|
}
|
|
|
|
|
2001-01-31 07:58:58 +00:00
|
|
|
static int
|
2001-06-01 15:51:10 +00:00
|
|
|
tunmodevent(module_t mod, int type, void *data)
|
2001-04-03 01:22:15 +00:00
|
|
|
{
|
|
|
|
static eventhandler_tag tag;
|
|
|
|
struct tun_softc *tp;
|
|
|
|
dev_t dev;
|
|
|
|
int err;
|
|
|
|
|
2001-01-31 07:58:58 +00:00
|
|
|
switch (type) {
|
|
|
|
case MOD_LOAD:
|
2001-06-01 15:51:10 +00:00
|
|
|
tag = EVENTHANDLER_REGISTER(dev_clone, tunclone, 0, 1000);
|
2001-04-03 01:22:15 +00:00
|
|
|
if (tag == NULL)
|
|
|
|
return (ENOMEM);
|
2002-10-20 20:53:42 +00:00
|
|
|
tununits.rm_type = RMAN_ARRAY;
|
|
|
|
tununits.rm_descr = "open if_tun units";
|
|
|
|
err = rman_init(&tununits);
|
2001-04-03 01:22:15 +00:00
|
|
|
if (err != 0) {
|
2001-06-01 15:51:10 +00:00
|
|
|
cdevsw_remove(&tun_cdevsw);
|
|
|
|
EVENTHANDLER_DEREGISTER(dev_clone, tag);
|
|
|
|
return (err);
|
|
|
|
}
|
2002-10-20 20:53:42 +00:00
|
|
|
err = rman_manage_region(&tununits, 0, TUN_MAXUNIT);
|
2001-06-01 15:51:10 +00:00
|
|
|
if (err != 0) {
|
|
|
|
printf("%s: tununits: rman_manage_region: Failed %d\n",
|
|
|
|
TUNNAME, err);
|
2002-10-20 20:53:42 +00:00
|
|
|
rman_fini(&tununits);
|
2001-06-01 15:51:10 +00:00
|
|
|
cdevsw_remove(&tun_cdevsw);
|
2001-04-03 01:22:15 +00:00
|
|
|
EVENTHANDLER_DEREGISTER(dev_clone, tag);
|
|
|
|
return (err);
|
|
|
|
}
|
2001-01-31 07:58:58 +00:00
|
|
|
break;
|
|
|
|
case MOD_UNLOAD:
|
2002-10-20 20:53:42 +00:00
|
|
|
err = rman_fini(&tununits);
|
2001-06-01 15:51:10 +00:00
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
|
|
|
EVENTHANDLER_DEREGISTER(dev_clone, tag);
|
|
|
|
|
2001-04-03 01:22:15 +00:00
|
|
|
while (tunhead != NULL) {
|
2001-06-01 15:51:10 +00:00
|
|
|
KASSERT((tunhead->tun_flags & TUN_OPEN) == 0,
|
|
|
|
("tununits is out of sync - unit %d",
|
|
|
|
tunhead->tun_if.if_unit));
|
2001-04-03 01:22:15 +00:00
|
|
|
tp = tunhead;
|
|
|
|
dev = makedev(tun_cdevsw.d_maj,
|
|
|
|
unit2minor(tp->tun_if.if_unit));
|
|
|
|
KASSERT(dev->si_drv1 == tp, ("Bad makedev result"));
|
|
|
|
tunhead = tp->next;
|
|
|
|
bpfdetach(&tp->tun_if);
|
|
|
|
if_detach(&tp->tun_if);
|
2001-04-17 09:59:34 +00:00
|
|
|
KASSERT(dev->si_flags & SI_NAMED, ("Missing make_dev"));
|
2002-04-04 06:03:17 +00:00
|
|
|
free(tp, M_TUN);
|
2001-04-03 01:22:15 +00:00
|
|
|
}
|
2001-06-01 15:51:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Destroying tunbasedev results in all of our make_dev()s
|
|
|
|
* conveniently going away.
|
|
|
|
*/
|
|
|
|
if (tunbasedev != NOUDEV)
|
|
|
|
destroy_dev(udev2dev(tunbasedev, 0));
|
|
|
|
|
2001-04-03 01:22:15 +00:00
|
|
|
break;
|
2001-01-31 07:58:58 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static moduledata_t tun_mod = {
|
|
|
|
"if_tun",
|
2001-06-01 15:51:10 +00:00
|
|
|
tunmodevent,
|
2001-01-31 07:58:58 +00:00
|
|
|
0
|
|
|
|
};
|
|
|
|
|
|
|
|
DECLARE_MODULE(if_tun, tun_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
|
1999-08-15 09:54:57 +00:00
|
|
|
|
2000-12-05 16:21:00 +00:00
|
|
|
static void
|
2001-06-01 15:51:10 +00:00
|
|
|
tunstart(struct ifnet *ifp)
|
2000-12-05 16:21:00 +00:00
|
|
|
{
|
|
|
|
struct tun_softc *tp = ifp->if_softc;
|
|
|
|
|
|
|
|
if (tp->tun_flags & TUN_RWAIT) {
|
|
|
|
tp->tun_flags &= ~TUN_RWAIT;
|
|
|
|
wakeup((caddr_t)tp);
|
|
|
|
}
|
|
|
|
if (tp->tun_flags & TUN_ASYNC && tp->tun_sigio)
|
2002-05-01 20:44:46 +00:00
|
|
|
pgsigio(&tp->tun_sigio, SIGIO, 0);
|
2000-12-05 16:21:00 +00:00
|
|
|
selwakeup(&tp->tun_rsel);
|
|
|
|
}
|
|
|
|
|
1999-08-15 09:54:57 +00:00
|
|
|
static void
|
2001-06-01 15:51:10 +00:00
|
|
|
tuncreate(dev_t dev)
|
1999-08-15 09:54:57 +00:00
|
|
|
{
|
|
|
|
struct tun_softc *sc;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
2001-04-17 09:59:34 +00:00
|
|
|
if (!(dev->si_flags & SI_NAMED))
|
2001-04-03 01:22:15 +00:00
|
|
|
dev = make_dev(&tun_cdevsw, minor(dev),
|
|
|
|
UID_UUCP, GID_DIALER, 0600, "tun%d", dev2unit(dev));
|
1999-08-15 09:54:57 +00:00
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
MALLOC(sc, struct tun_softc *, sizeof(*sc), M_TUN, M_WAITOK | M_ZERO);
|
1999-08-15 09:54:57 +00:00
|
|
|
sc->tun_flags = TUN_INITED;
|
2001-04-03 01:22:15 +00:00
|
|
|
sc->next = tunhead;
|
|
|
|
tunhead = sc;
|
1999-08-15 09:54:57 +00:00
|
|
|
|
|
|
|
ifp = &sc->tun_if;
|
2000-09-19 10:28:44 +00:00
|
|
|
ifp->if_unit = dev2unit(dev);
|
2001-06-01 15:51:10 +00:00
|
|
|
ifp->if_name = TUNNAME;
|
1999-08-15 09:54:57 +00:00
|
|
|
ifp->if_mtu = TUNMTU;
|
|
|
|
ifp->if_ioctl = tunifioctl;
|
|
|
|
ifp->if_output = tunoutput;
|
2000-12-05 16:21:00 +00:00
|
|
|
ifp->if_start = tunstart;
|
1999-08-15 09:54:57 +00:00
|
|
|
ifp->if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
|
2000-07-17 23:21:42 +00:00
|
|
|
ifp->if_type = IFT_PPP;
|
1999-08-15 09:54:57 +00:00
|
|
|
ifp->if_snd.ifq_maxlen = ifqmaxlen;
|
|
|
|
ifp->if_softc = sc;
|
|
|
|
if_attach(ifp);
|
|
|
|
bpfattach(ifp, DLT_NULL, sizeof(u_int));
|
|
|
|
dev->si_drv1 = sc;
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
2001-06-01 15:51:10 +00:00
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
tunopen(dev_t dev, int flag, int mode, struct thread *td)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
2001-06-01 15:51:10 +00:00
|
|
|
struct resource *r;
|
1995-01-31 06:15:49 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
struct tun_softc *tp;
|
2001-06-01 15:51:10 +00:00
|
|
|
int unit;
|
|
|
|
|
|
|
|
unit = dev2unit(dev);
|
|
|
|
if (unit > TUN_MAXUNIT)
|
|
|
|
return (ENXIO);
|
|
|
|
|
2002-10-20 20:53:42 +00:00
|
|
|
r = rman_reserve_resource(&tununits, unit, unit, 1,
|
2001-06-01 15:51:10 +00:00
|
|
|
RF_ALLOCATED | RF_ACTIVE, NULL);
|
|
|
|
if (r == NULL)
|
|
|
|
return (EBUSY);
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2001-06-18 09:21:59 +00:00
|
|
|
dev->si_flags &= ~SI_CHEAPCLONE;
|
|
|
|
|
1999-08-15 09:54:57 +00:00
|
|
|
tp = dev->si_drv1;
|
|
|
|
if (!tp) {
|
|
|
|
tuncreate(dev);
|
|
|
|
tp = dev->si_drv1;
|
|
|
|
}
|
2001-06-01 15:51:10 +00:00
|
|
|
KASSERT(!(tp->tun_flags & TUN_OPEN), ("Resource & flags out-of-sync"));
|
|
|
|
tp->r_unit = r;
|
2001-09-12 08:38:13 +00:00
|
|
|
tp->tun_pid = td->td_proc->p_pid;
|
1995-01-31 06:15:49 +00:00
|
|
|
ifp = &tp->tun_if;
|
|
|
|
tp->tun_flags |= TUN_OPEN;
|
|
|
|
TUNDEBUG("%s%d: open\n", ifp->if_name, ifp->if_unit);
|
2001-06-01 15:51:10 +00:00
|
|
|
|
1995-01-31 06:15:49 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* tunclose - close the device - mark i/f down & delete
|
|
|
|
* routing info
|
|
|
|
*/
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
tunclose(dev_t dev, int foo, int bar, struct thread *td)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-08-15 09:54:57 +00:00
|
|
|
struct tun_softc *tp;
|
2001-06-01 15:51:10 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
int s;
|
|
|
|
int err;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
1999-08-15 09:54:57 +00:00
|
|
|
tp = dev->si_drv1;
|
|
|
|
ifp = &tp->tun_if;
|
|
|
|
|
2001-06-20 10:06:28 +00:00
|
|
|
KASSERT(tp->r_unit, ("Unit %d not marked open", ifp->if_unit));
|
1995-01-31 06:15:49 +00:00
|
|
|
tp->tun_flags &= ~TUN_OPEN;
|
1999-06-19 18:42:31 +00:00
|
|
|
tp->tun_pid = 0;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* junk all pending output
|
|
|
|
*/
|
Lock down the network interface queues. The queue mutex must be obtained
before adding/removing packets from the queue. Also, the if_obytes and
if_omcasts fields should only be manipulated under protection of the mutex.
IF_ENQUEUE, IF_PREPEND, and IF_DEQUEUE perform all necessary locking on
the queue. An IF_LOCK macro is provided, as well as the old (mutex-less)
versions of the macros in the form _IF_ENQUEUE, _IF_QFULL, for code which
needs them, but their use is discouraged.
Two new macros are introduced: IF_DRAIN() to drain a queue, and IF_HANDOFF,
which takes care of locking/enqueue, and also statistics updating/start
if necessary.
2000-11-25 07:35:38 +00:00
|
|
|
IF_DRAIN(&ifp->if_snd);
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
if (ifp->if_flags & IFF_UP) {
|
|
|
|
s = splimp();
|
|
|
|
if_down(ifp);
|
|
|
|
splx(s);
|
|
|
|
}
|
1999-05-27 13:18:28 +00:00
|
|
|
|
|
|
|
if (ifp->if_flags & IFF_RUNNING) {
|
|
|
|
register struct ifaddr *ifa;
|
|
|
|
|
|
|
|
s = splimp();
|
|
|
|
/* find internet addresses and delete routes */
|
2001-02-04 16:08:18 +00:00
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
|
1999-05-27 13:18:28 +00:00
|
|
|
if (ifa->ifa_addr->sa_family == AF_INET)
|
|
|
|
rtinit(ifa, (int)RTM_DELETE,
|
|
|
|
tp->tun_flags & TUN_DSTADDR ? RTF_HOST : 0);
|
|
|
|
ifp->if_flags &= ~IFF_RUNNING;
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
2002-05-06 19:31:28 +00:00
|
|
|
funsetown(&tp->tun_sigio);
|
1995-02-26 12:18:08 +00:00
|
|
|
selwakeup(&tp->tun_rsel);
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1995-01-31 06:15:49 +00:00
|
|
|
TUNDEBUG ("%s%d: closed\n", ifp->if_name, ifp->if_unit);
|
2001-06-20 10:06:28 +00:00
|
|
|
err = rman_release_resource(tp->r_unit);
|
|
|
|
KASSERT(err == 0, ("Unit %d failed to release", ifp->if_unit));
|
|
|
|
|
1995-01-31 06:15:49 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2001-06-01 15:51:10 +00:00
|
|
|
tuninit(struct ifnet *ifp)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-08-15 09:54:57 +00:00
|
|
|
struct tun_softc *tp = ifp->if_softc;
|
1995-01-31 06:15:49 +00:00
|
|
|
register struct ifaddr *ifa;
|
2000-11-02 16:30:26 +00:00
|
|
|
int error = 0;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
TUNDEBUG("%s%d: tuninit\n", ifp->if_name, ifp->if_unit);
|
|
|
|
|
|
|
|
ifp->if_flags |= IFF_UP | IFF_RUNNING;
|
1998-04-06 11:43:12 +00:00
|
|
|
getmicrotime(&ifp->if_lastchange);
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2001-02-03 11:46:35 +00:00
|
|
|
for (ifa = TAILQ_FIRST(&ifp->if_addrhead); ifa;
|
|
|
|
ifa = TAILQ_NEXT(ifa, ifa_link)) {
|
2000-11-02 16:30:26 +00:00
|
|
|
if (ifa->ifa_addr == NULL)
|
|
|
|
error = EFAULT;
|
|
|
|
/* XXX: Should maybe return straight off? */
|
|
|
|
else {
|
1998-01-08 23:42:31 +00:00
|
|
|
#ifdef INET
|
2000-11-02 16:30:26 +00:00
|
|
|
if (ifa->ifa_addr->sa_family == AF_INET) {
|
|
|
|
struct sockaddr_in *si;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2000-11-02 16:30:26 +00:00
|
|
|
si = (struct sockaddr_in *)ifa->ifa_addr;
|
|
|
|
if (si->sin_addr.s_addr)
|
|
|
|
tp->tun_flags |= TUN_IASET;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2000-11-02 16:30:26 +00:00
|
|
|
si = (struct sockaddr_in *)ifa->ifa_dstaddr;
|
|
|
|
if (si && si->sin_addr.s_addr)
|
|
|
|
tp->tun_flags |= TUN_DSTADDR;
|
|
|
|
}
|
1998-01-08 23:42:31 +00:00
|
|
|
#endif
|
2000-11-02 16:30:26 +00:00
|
|
|
}
|
1998-01-08 23:42:31 +00:00
|
|
|
}
|
2000-11-02 16:30:26 +00:00
|
|
|
return (error);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process an ioctl request.
|
|
|
|
*/
|
2002-10-20 20:53:42 +00:00
|
|
|
static int
|
2001-06-01 15:51:10 +00:00
|
|
|
tunifioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-06-19 18:42:31 +00:00
|
|
|
struct ifreq *ifr = (struct ifreq *)data;
|
1999-08-15 09:54:57 +00:00
|
|
|
struct tun_softc *tp = ifp->if_softc;
|
1999-06-19 18:42:31 +00:00
|
|
|
struct ifstat *ifs;
|
1995-01-31 06:15:49 +00:00
|
|
|
int error = 0, s;
|
|
|
|
|
|
|
|
s = splimp();
|
|
|
|
switch(cmd) {
|
1999-06-19 18:42:31 +00:00
|
|
|
case SIOCGIFSTATUS:
|
|
|
|
ifs = (struct ifstat *)data;
|
|
|
|
if (tp->tun_pid)
|
|
|
|
sprintf(ifs->ascii + strlen(ifs->ascii),
|
|
|
|
"\tOpened by PID %d\n", tp->tun_pid);
|
2000-11-02 16:30:26 +00:00
|
|
|
break;
|
1995-01-31 06:15:49 +00:00
|
|
|
case SIOCSIFADDR:
|
2000-11-02 16:30:26 +00:00
|
|
|
error = tuninit(ifp);
|
|
|
|
TUNDEBUG("%s%d: address set, error=%d\n",
|
|
|
|
ifp->if_name, ifp->if_unit, error);
|
1995-01-31 06:15:49 +00:00
|
|
|
break;
|
|
|
|
case SIOCSIFDSTADDR:
|
2000-11-02 16:30:26 +00:00
|
|
|
error = tuninit(ifp);
|
|
|
|
TUNDEBUG("%s%d: destination address set, error=%d\n",
|
|
|
|
ifp->if_name, ifp->if_unit, error);
|
1995-01-31 06:15:49 +00:00
|
|
|
break;
|
1996-12-16 19:23:34 +00:00
|
|
|
case SIOCSIFMTU:
|
1999-08-06 16:52:04 +00:00
|
|
|
ifp->if_mtu = ifr->ifr_mtu;
|
2001-02-03 00:31:39 +00:00
|
|
|
TUNDEBUG("%s%d: mtu set\n", ifp->if_name, ifp->if_unit);
|
1996-12-16 19:23:34 +00:00
|
|
|
break;
|
2001-04-02 21:49:18 +00:00
|
|
|
case SIOCSIFFLAGS:
|
1995-09-25 16:57:54 +00:00
|
|
|
case SIOCADDMULTI:
|
|
|
|
case SIOCDELMULTI:
|
|
|
|
break;
|
1995-01-31 06:15:49 +00:00
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* tunoutput - queue packets from higher level ready to put out.
|
|
|
|
*/
|
2002-10-20 20:53:42 +00:00
|
|
|
static int
|
2001-06-01 15:51:10 +00:00
|
|
|
tunoutput(
|
|
|
|
struct ifnet *ifp,
|
|
|
|
struct mbuf *m0,
|
|
|
|
struct sockaddr *dst,
|
|
|
|
struct rtentry *rt)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-08-15 09:54:57 +00:00
|
|
|
struct tun_softc *tp = ifp->if_softc;
|
2002-07-31 16:23:42 +00:00
|
|
|
#ifdef MAC
|
|
|
|
int error;
|
|
|
|
#endif
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
TUNDEBUG ("%s%d: tunoutput\n", ifp->if_name, ifp->if_unit);
|
|
|
|
|
2002-07-31 16:23:42 +00:00
|
|
|
#ifdef MAC
|
|
|
|
error = mac_check_ifnet_transmit(ifp, m0);
|
|
|
|
if (error) {
|
|
|
|
m_freem(m0);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1995-01-31 06:15:49 +00:00
|
|
|
if ((tp->tun_flags & TUN_READY) != TUN_READY) {
|
|
|
|
TUNDEBUG ("%s%d: not ready 0%o\n", ifp->if_name,
|
|
|
|
ifp->if_unit, tp->tun_flags);
|
|
|
|
m_freem (m0);
|
2002-02-26 03:00:19 +00:00
|
|
|
return (EHOSTDOWN);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
2002-10-25 17:31:03 +00:00
|
|
|
if ((ifp->if_flags & IFF_UP) != IFF_UP) {
|
2002-10-23 15:16:37 +00:00
|
|
|
m_freem (m0);
|
|
|
|
return (EHOSTDOWN);
|
|
|
|
}
|
|
|
|
|
1995-09-25 16:57:54 +00:00
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
|
1996-02-06 18:51:28 +00:00
|
|
|
if (ifp->if_bpf) {
|
1995-01-31 06:15:49 +00:00
|
|
|
/*
|
|
|
|
* We need to prepend the address family as
|
|
|
|
* a four byte field. Cons up a dummy header
|
|
|
|
* to pacify bpf. This is safe because bpf
|
|
|
|
* will only read from the mbuf (i.e., it won't
|
|
|
|
* try to free it or keep a pointer to it).
|
|
|
|
*/
|
|
|
|
struct mbuf m;
|
2000-10-15 18:49:17 +00:00
|
|
|
uint32_t af = dst->sa_family;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
m.m_next = m0;
|
|
|
|
m.m_len = 4;
|
|
|
|
m.m_data = (char *)⁡
|
|
|
|
|
2002-11-15 00:00:15 +00:00
|
|
|
BPF_MTAP(ifp, &m);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
1999-03-24 21:20:12 +00:00
|
|
|
|
|
|
|
/* prepend sockaddr? this may abort if the mbuf allocation fails */
|
|
|
|
if (tp->tun_flags & TUN_LMODE) {
|
|
|
|
/* allocate space for sockaddr */
|
2003-02-19 05:47:46 +00:00
|
|
|
M_PREPEND(m0, dst->sa_len, M_DONTWAIT);
|
1999-03-24 21:20:12 +00:00
|
|
|
|
|
|
|
/* if allocation failed drop packet */
|
Lock down the network interface queues. The queue mutex must be obtained
before adding/removing packets from the queue. Also, the if_obytes and
if_omcasts fields should only be manipulated under protection of the mutex.
IF_ENQUEUE, IF_PREPEND, and IF_DEQUEUE perform all necessary locking on
the queue. An IF_LOCK macro is provided, as well as the old (mutex-less)
versions of the macros in the form _IF_ENQUEUE, _IF_QFULL, for code which
needs them, but their use is discouraged.
Two new macros are introduced: IF_DRAIN() to drain a queue, and IF_HANDOFF,
which takes care of locking/enqueue, and also statistics updating/start
if necessary.
2000-11-25 07:35:38 +00:00
|
|
|
if (m0 == NULL) {
|
|
|
|
ifp->if_iqdrops++;
|
1999-03-24 21:20:12 +00:00
|
|
|
ifp->if_oerrors++;
|
|
|
|
return (ENOBUFS);
|
|
|
|
} else {
|
|
|
|
bcopy(dst, m0->m_data, dst->sa_len);
|
|
|
|
}
|
|
|
|
}
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2000-01-23 01:47:12 +00:00
|
|
|
if (tp->tun_flags & TUN_IFHEAD) {
|
|
|
|
/* Prepend the address family */
|
2003-02-19 05:47:46 +00:00
|
|
|
M_PREPEND(m0, 4, M_DONTWAIT);
|
2000-01-23 01:47:12 +00:00
|
|
|
|
|
|
|
/* if allocation failed drop packet */
|
Lock down the network interface queues. The queue mutex must be obtained
before adding/removing packets from the queue. Also, the if_obytes and
if_omcasts fields should only be manipulated under protection of the mutex.
IF_ENQUEUE, IF_PREPEND, and IF_DEQUEUE perform all necessary locking on
the queue. An IF_LOCK macro is provided, as well as the old (mutex-less)
versions of the macros in the form _IF_ENQUEUE, _IF_QFULL, for code which
needs them, but their use is discouraged.
Two new macros are introduced: IF_DRAIN() to drain a queue, and IF_HANDOFF,
which takes care of locking/enqueue, and also statistics updating/start
if necessary.
2000-11-25 07:35:38 +00:00
|
|
|
if (m0 == NULL) {
|
|
|
|
ifp->if_iqdrops++;
|
2000-01-23 01:47:12 +00:00
|
|
|
ifp->if_oerrors++;
|
2002-02-26 03:00:19 +00:00
|
|
|
return (ENOBUFS);
|
2000-01-23 01:47:12 +00:00
|
|
|
} else
|
|
|
|
*(u_int32_t *)m0->m_data = htonl(dst->sa_family);
|
|
|
|
} else {
|
|
|
|
#ifdef INET
|
|
|
|
if (dst->sa_family != AF_INET)
|
1995-01-31 06:15:49 +00:00
|
|
|
#endif
|
2000-01-23 01:47:12 +00:00
|
|
|
{
|
|
|
|
m_freem(m0);
|
2002-02-26 03:00:19 +00:00
|
|
|
return (EAFNOSUPPORT);
|
2000-01-23 01:47:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-12-05 16:21:00 +00:00
|
|
|
if (! IF_HANDOFF(&ifp->if_snd, m0, ifp)) {
|
2000-01-23 01:47:12 +00:00
|
|
|
ifp->if_collisions++;
|
2002-02-26 03:00:19 +00:00
|
|
|
return (ENOBUFS);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
2000-01-23 01:47:12 +00:00
|
|
|
ifp->if_opackets++;
|
2002-02-26 03:00:19 +00:00
|
|
|
return (0);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the cdevsw interface is now pretty minimal.
|
|
|
|
*/
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
tunioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-08-15 09:54:57 +00:00
|
|
|
int s;
|
2001-02-03 00:31:39 +00:00
|
|
|
int error;
|
1999-08-15 09:54:57 +00:00
|
|
|
struct tun_softc *tp = dev->si_drv1;
|
1995-02-26 12:18:08 +00:00
|
|
|
struct tuninfo *tunp;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
switch (cmd) {
|
1995-02-26 12:18:08 +00:00
|
|
|
case TUNSIFINFO:
|
2000-01-23 01:47:12 +00:00
|
|
|
tunp = (struct tuninfo *)data;
|
1999-08-06 16:52:04 +00:00
|
|
|
if (tunp->mtu < IF_MINMTU)
|
1999-08-06 13:53:03 +00:00
|
|
|
return (EINVAL);
|
2001-09-12 08:38:13 +00:00
|
|
|
if (tp->tun_if.if_mtu != tunp->mtu
|
2002-04-01 21:31:13 +00:00
|
|
|
&& (error = suser(td)) != 0)
|
2001-02-03 00:31:39 +00:00
|
|
|
return (error);
|
1995-02-26 12:18:08 +00:00
|
|
|
tp->tun_if.if_mtu = tunp->mtu;
|
|
|
|
tp->tun_if.if_type = tunp->type;
|
|
|
|
tp->tun_if.if_baudrate = tunp->baudrate;
|
|
|
|
break;
|
|
|
|
case TUNGIFINFO:
|
|
|
|
tunp = (struct tuninfo *)data;
|
|
|
|
tunp->mtu = tp->tun_if.if_mtu;
|
|
|
|
tunp->type = tp->tun_if.if_type;
|
|
|
|
tunp->baudrate = tp->tun_if.if_baudrate;
|
|
|
|
break;
|
1995-01-31 06:15:49 +00:00
|
|
|
case TUNSDEBUG:
|
|
|
|
tundebug = *(int *)data;
|
|
|
|
break;
|
|
|
|
case TUNGDEBUG:
|
|
|
|
*(int *)data = tundebug;
|
|
|
|
break;
|
1999-03-24 21:20:12 +00:00
|
|
|
case TUNSLMODE:
|
2000-01-23 01:47:12 +00:00
|
|
|
if (*(int *)data) {
|
1999-03-24 21:20:12 +00:00
|
|
|
tp->tun_flags |= TUN_LMODE;
|
2000-01-23 01:47:12 +00:00
|
|
|
tp->tun_flags &= ~TUN_IFHEAD;
|
|
|
|
} else
|
1999-03-24 21:20:12 +00:00
|
|
|
tp->tun_flags &= ~TUN_LMODE;
|
|
|
|
break;
|
2000-01-23 01:47:12 +00:00
|
|
|
case TUNSIFHEAD:
|
|
|
|
if (*(int *)data) {
|
|
|
|
tp->tun_flags |= TUN_IFHEAD;
|
|
|
|
tp->tun_flags &= ~TUN_LMODE;
|
|
|
|
} else
|
|
|
|
tp->tun_flags &= ~TUN_IFHEAD;
|
|
|
|
break;
|
|
|
|
case TUNGIFHEAD:
|
|
|
|
*(int *)data = (tp->tun_flags & TUN_IFHEAD) ? 1 : 0;
|
|
|
|
break;
|
1999-03-24 21:20:12 +00:00
|
|
|
case TUNSIFMODE:
|
|
|
|
/* deny this if UP */
|
|
|
|
if (tp->tun_if.if_flags & IFF_UP)
|
|
|
|
return(EBUSY);
|
|
|
|
|
2001-08-25 09:12:57 +00:00
|
|
|
switch (*(int *)data & ~IFF_MULTICAST) {
|
1999-03-24 21:20:12 +00:00
|
|
|
case IFF_POINTOPOINT:
|
|
|
|
case IFF_BROADCAST:
|
2001-08-25 09:12:57 +00:00
|
|
|
tp->tun_if.if_flags &=
|
|
|
|
~(IFF_BROADCAST|IFF_POINTOPOINT|IFF_MULTICAST);
|
|
|
|
tp->tun_if.if_flags |= *(int *)data;
|
1999-03-24 21:20:12 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return(EINVAL);
|
|
|
|
}
|
|
|
|
break;
|
2000-01-21 00:31:43 +00:00
|
|
|
case TUNSIFPID:
|
2001-09-12 08:38:13 +00:00
|
|
|
tp->tun_pid = curthread->td_proc->p_pid;
|
2000-01-21 00:31:43 +00:00
|
|
|
break;
|
1995-01-31 06:15:49 +00:00
|
|
|
case FIONBIO:
|
|
|
|
break;
|
|
|
|
case FIOASYNC:
|
|
|
|
if (*(int *)data)
|
|
|
|
tp->tun_flags |= TUN_ASYNC;
|
|
|
|
else
|
|
|
|
tp->tun_flags &= ~TUN_ASYNC;
|
|
|
|
break;
|
|
|
|
case FIONREAD:
|
|
|
|
s = splimp();
|
1995-12-11 13:24:58 +00:00
|
|
|
if (tp->tun_if.if_snd.ifq_head) {
|
|
|
|
struct mbuf *mb = tp->tun_if.if_snd.ifq_head;
|
|
|
|
for( *(int *)data = 0; mb != 0; mb = mb->m_next)
|
|
|
|
*(int *)data += mb->m_len;
|
|
|
|
} else
|
1995-01-31 06:15:49 +00:00
|
|
|
*(int *)data = 0;
|
|
|
|
splx(s);
|
|
|
|
break;
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
case FIOSETOWN:
|
|
|
|
return (fsetown(*(int *)data, &tp->tun_sigio));
|
|
|
|
|
|
|
|
case FIOGETOWN:
|
2002-10-03 02:13:00 +00:00
|
|
|
*(int *)data = fgetown(&tp->tun_sigio);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
/* This is deprecated, FIOSETOWN should be used instead. */
|
1995-01-31 06:15:49 +00:00
|
|
|
case TIOCSPGRP:
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
return (fsetown(-(*(int *)data), &tp->tun_sigio));
|
|
|
|
|
|
|
|
/* This is deprecated, FIOGETOWN should be used instead. */
|
1995-01-31 06:15:49 +00:00
|
|
|
case TIOCGPGRP:
|
2002-10-03 02:13:00 +00:00
|
|
|
*(int *)data = -fgetown(&tp->tun_sigio);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
return (0);
|
|
|
|
|
1995-01-31 06:15:49 +00:00
|
|
|
default:
|
|
|
|
return (ENOTTY);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The cdevsw read interface - reads a packet at a time, or at
|
|
|
|
* least as much of a packet as can be read.
|
|
|
|
*/
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2001-06-01 15:51:10 +00:00
|
|
|
tunread(dev_t dev, struct uio *uio, int flag)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-08-15 09:54:57 +00:00
|
|
|
struct tun_softc *tp = dev->si_drv1;
|
1995-01-31 06:15:49 +00:00
|
|
|
struct ifnet *ifp = &tp->tun_if;
|
2002-02-05 02:00:56 +00:00
|
|
|
struct mbuf *m;
|
1995-01-31 06:15:49 +00:00
|
|
|
int error=0, len, s;
|
|
|
|
|
|
|
|
TUNDEBUG ("%s%d: read\n", ifp->if_name, ifp->if_unit);
|
|
|
|
if ((tp->tun_flags & TUN_READY) != TUN_READY) {
|
|
|
|
TUNDEBUG ("%s%d: not ready 0%o\n", ifp->if_name,
|
|
|
|
ifp->if_unit, tp->tun_flags);
|
2002-02-26 03:00:19 +00:00
|
|
|
return (EHOSTDOWN);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tp->tun_flags &= ~TUN_RWAIT;
|
|
|
|
|
|
|
|
s = splimp();
|
|
|
|
do {
|
2002-02-05 02:00:56 +00:00
|
|
|
IF_DEQUEUE(&ifp->if_snd, m);
|
|
|
|
if (m == NULL) {
|
1997-11-18 16:36:15 +00:00
|
|
|
if (flag & IO_NDELAY) {
|
1995-01-31 06:15:49 +00:00
|
|
|
splx(s);
|
2002-02-26 03:00:19 +00:00
|
|
|
return (EWOULDBLOCK);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
tp->tun_flags |= TUN_RWAIT;
|
1999-01-27 22:42:27 +00:00
|
|
|
if((error = tsleep((caddr_t)tp, PCATCH | (PZERO + 1),
|
|
|
|
"tunread", 0)) != 0) {
|
1996-12-02 21:07:33 +00:00
|
|
|
splx(s);
|
2002-02-26 03:00:19 +00:00
|
|
|
return (error);
|
1996-12-02 21:07:33 +00:00
|
|
|
}
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
2002-02-05 02:00:56 +00:00
|
|
|
} while (m == NULL);
|
1995-01-31 06:15:49 +00:00
|
|
|
splx(s);
|
|
|
|
|
2002-02-05 02:00:56 +00:00
|
|
|
while (m && uio->uio_resid > 0 && error == 0) {
|
|
|
|
len = min(uio->uio_resid, m->m_len);
|
2001-08-03 16:51:53 +00:00
|
|
|
if (len != 0)
|
2002-02-05 02:00:56 +00:00
|
|
|
error = uiomove(mtod(m, caddr_t), len, uio);
|
|
|
|
m = m_free(m);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
2002-02-05 02:00:56 +00:00
|
|
|
if (m) {
|
2001-08-03 16:51:53 +00:00
|
|
|
TUNDEBUG("%s%d: Dropping mbuf\n", ifp->if_name, ifp->if_unit);
|
2002-02-05 02:00:56 +00:00
|
|
|
m_freem(m);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
2002-02-26 03:00:19 +00:00
|
|
|
return (error);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the cdevsw write interface - an atomic write is a packet - or else!
|
|
|
|
*/
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2001-06-01 15:51:10 +00:00
|
|
|
tunwrite(dev_t dev, struct uio *uio, int flag)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-08-15 09:54:57 +00:00
|
|
|
struct tun_softc *tp = dev->si_drv1;
|
|
|
|
struct ifnet *ifp = &tp->tun_if;
|
1995-01-31 06:15:49 +00:00
|
|
|
struct mbuf *top, **mp, *m;
|
2000-01-27 23:37:39 +00:00
|
|
|
int error=0, tlen, mlen;
|
2000-10-15 18:49:17 +00:00
|
|
|
uint32_t family;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
TUNDEBUG("%s%d: tunwrite\n", ifp->if_name, ifp->if_unit);
|
|
|
|
|
2002-10-25 17:31:03 +00:00
|
|
|
if ((ifp->if_flags & IFF_UP) != IFF_UP)
|
2002-10-23 15:16:37 +00:00
|
|
|
/* ignore silently */
|
|
|
|
return (0);
|
|
|
|
|
1999-07-26 12:11:10 +00:00
|
|
|
if (uio->uio_resid == 0)
|
2002-02-26 03:00:19 +00:00
|
|
|
return (0);
|
1999-07-26 12:11:10 +00:00
|
|
|
|
|
|
|
if (uio->uio_resid < 0 || uio->uio_resid > TUNMRU) {
|
1995-01-31 06:15:49 +00:00
|
|
|
TUNDEBUG("%s%d: len=%d!\n", ifp->if_name, ifp->if_unit,
|
|
|
|
uio->uio_resid);
|
2002-02-26 03:00:19 +00:00
|
|
|
return (EIO);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
tlen = uio->uio_resid;
|
|
|
|
|
|
|
|
/* get a header mbuf */
|
2003-02-19 05:47:46 +00:00
|
|
|
MGETHDR(m, M_DONTWAIT, MT_DATA);
|
1995-01-31 06:15:49 +00:00
|
|
|
if (m == NULL)
|
2002-02-26 03:00:19 +00:00
|
|
|
return (ENOBUFS);
|
1995-01-31 06:15:49 +00:00
|
|
|
mlen = MHLEN;
|
|
|
|
|
|
|
|
top = 0;
|
|
|
|
mp = ⊤
|
|
|
|
while (error == 0 && uio->uio_resid > 0) {
|
1995-02-26 12:18:08 +00:00
|
|
|
m->m_len = min(mlen, uio->uio_resid);
|
1995-01-31 06:15:49 +00:00
|
|
|
error = uiomove(mtod (m, caddr_t), m->m_len, uio);
|
|
|
|
*mp = m;
|
|
|
|
mp = &m->m_next;
|
|
|
|
if (uio->uio_resid > 0) {
|
2003-02-19 05:47:46 +00:00
|
|
|
MGET (m, M_DONTWAIT, MT_DATA);
|
1995-01-31 06:15:49 +00:00
|
|
|
if (m == 0) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mlen = MLEN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error) {
|
|
|
|
if (top)
|
|
|
|
m_freem (top);
|
2000-02-16 04:04:36 +00:00
|
|
|
ifp->if_ierrors++;
|
2002-02-26 03:00:19 +00:00
|
|
|
return (error);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
top->m_pkthdr.len = tlen;
|
|
|
|
top->m_pkthdr.rcvif = ifp;
|
2002-07-31 16:23:42 +00:00
|
|
|
#ifdef MAC
|
|
|
|
mac_create_mbuf_from_ifnet(ifp, top);
|
|
|
|
#endif
|
1995-01-31 06:15:49 +00:00
|
|
|
|
1996-02-06 18:51:28 +00:00
|
|
|
if (ifp->if_bpf) {
|
2000-10-15 18:49:17 +00:00
|
|
|
if (tp->tun_flags & TUN_IFHEAD) {
|
2000-01-23 01:47:12 +00:00
|
|
|
/*
|
|
|
|
* Conveniently, we already have a 4-byte address
|
|
|
|
* family prepended to our packet !
|
2000-10-15 18:49:17 +00:00
|
|
|
* Inconveniently, it's in the wrong byte order !
|
2000-01-23 01:47:12 +00:00
|
|
|
*/
|
2000-10-15 18:49:17 +00:00
|
|
|
if ((top = m_pullup(top, sizeof(family))) == NULL)
|
2002-02-26 03:00:19 +00:00
|
|
|
return (ENOBUFS);
|
2000-10-15 18:49:17 +00:00
|
|
|
*mtod(top, u_int32_t *) =
|
|
|
|
ntohl(*mtod(top, u_int32_t *));
|
2002-11-15 00:00:15 +00:00
|
|
|
BPF_MTAP(ifp, top);
|
2000-10-15 18:49:17 +00:00
|
|
|
*mtod(top, u_int32_t *) =
|
|
|
|
htonl(*mtod(top, u_int32_t *));
|
|
|
|
} else {
|
2000-01-23 01:47:12 +00:00
|
|
|
/*
|
|
|
|
* We need to prepend the address family as
|
|
|
|
* a four byte field. Cons up a dummy header
|
|
|
|
* to pacify bpf. This is safe because bpf
|
|
|
|
* will only read from the mbuf (i.e., it won't
|
|
|
|
* try to free it or keep a pointer to it).
|
|
|
|
*/
|
|
|
|
struct mbuf m;
|
2000-10-15 18:49:17 +00:00
|
|
|
uint32_t af = AF_INET;
|
2000-01-23 01:47:12 +00:00
|
|
|
|
|
|
|
m.m_next = top;
|
|
|
|
m.m_len = 4;
|
|
|
|
m.m_data = (char *)⁡
|
|
|
|
|
2002-11-15 00:00:15 +00:00
|
|
|
BPF_MTAP(ifp, &m);
|
2000-01-23 01:47:12 +00:00
|
|
|
}
|
|
|
|
}
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2000-01-23 01:47:12 +00:00
|
|
|
if (tp->tun_flags & TUN_IFHEAD) {
|
|
|
|
if (top->m_len < sizeof(family) &&
|
|
|
|
(top = m_pullup(top, sizeof(family))) == NULL)
|
2002-02-26 03:00:19 +00:00
|
|
|
return (ENOBUFS);
|
2000-01-23 01:47:12 +00:00
|
|
|
family = ntohl(*mtod(top, u_int32_t *));
|
|
|
|
m_adj(top, sizeof(family));
|
|
|
|
} else
|
|
|
|
family = AF_INET;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2000-02-16 04:04:36 +00:00
|
|
|
ifp->if_ibytes += top->m_pkthdr.len;
|
|
|
|
ifp->if_ipackets++;
|
|
|
|
|
2002-02-26 03:00:19 +00:00
|
|
|
return (family_enqueue(family, top));
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-14 03:09:01 +00:00
|
|
|
* tunpoll - the poll interface, this is only useful on reads
|
1995-01-31 06:15:49 +00:00
|
|
|
* really. The write detect always returns true, write never blocks
|
|
|
|
* anyway, it either accepts the packet or drops it.
|
|
|
|
*/
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
tunpoll(dev_t dev, int events, struct thread *td)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-08-15 09:54:57 +00:00
|
|
|
int s;
|
|
|
|
struct tun_softc *tp = dev->si_drv1;
|
1995-01-31 06:15:49 +00:00
|
|
|
struct ifnet *ifp = &tp->tun_if;
|
1997-09-14 03:09:01 +00:00
|
|
|
int revents = 0;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
s = splimp();
|
1997-09-14 03:09:01 +00:00
|
|
|
TUNDEBUG("%s%d: tunpoll\n", ifp->if_name, ifp->if_unit);
|
1995-02-26 12:18:08 +00:00
|
|
|
|
1999-05-06 18:13:11 +00:00
|
|
|
if (events & (POLLIN | POLLRDNORM)) {
|
1995-01-31 06:15:49 +00:00
|
|
|
if (ifp->if_snd.ifq_len > 0) {
|
1997-09-14 03:09:01 +00:00
|
|
|
TUNDEBUG("%s%d: tunpoll q=%d\n", ifp->if_name,
|
1995-01-31 06:15:49 +00:00
|
|
|
ifp->if_unit, ifp->if_snd.ifq_len);
|
1997-09-14 03:09:01 +00:00
|
|
|
revents |= events & (POLLIN | POLLRDNORM);
|
|
|
|
} else {
|
|
|
|
TUNDEBUG("%s%d: tunpoll waiting\n", ifp->if_name,
|
|
|
|
ifp->if_unit);
|
2001-09-21 22:46:54 +00:00
|
|
|
selrecord(td, &tp->tun_rsel);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
1999-05-06 18:13:11 +00:00
|
|
|
}
|
1997-09-14 03:09:01 +00:00
|
|
|
if (events & (POLLOUT | POLLWRNORM))
|
|
|
|
revents |= events & (POLLOUT | POLLWRNORM);
|
|
|
|
|
1995-01-31 06:15:49 +00:00
|
|
|
splx(s);
|
1997-09-14 03:09:01 +00:00
|
|
|
return (revents);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|