1995-02-26 12:18:08 +00:00
|
|
|
/* $NetBSD: if_tun.c,v 1.14 1994/06/29 06:36:25 cgd Exp $ */
|
|
|
|
|
2005-01-07 01:45:51 +00:00
|
|
|
/*-
|
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"
|
2003-03-08 17:32:21 +00:00
|
|
|
#include "opt_inet6.h"
|
1998-01-08 23:42:31 +00:00
|
|
|
|
1995-02-26 12:18:08 +00:00
|
|
|
#include <sys/param.h>
|
2006-11-06 13:42:10 +00:00
|
|
|
#include <sys/priv.h>
|
1995-02-26 12:18:08 +00:00
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/systm.h>
|
2009-06-17 15:01:01 +00:00
|
|
|
#include <sys/jail.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>
|
2004-12-22 17:39:21 +00:00
|
|
|
#include <sys/fcntl.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>
|
2004-12-22 17:39:21 +00:00
|
|
|
#include <sys/selinfo.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>
|
1999-08-15 09:54:57 +00:00
|
|
|
#include <sys/malloc.h>
|
2003-03-04 23:19:55 +00:00
|
|
|
#include <sys/random.h>
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
#include <net/if.h>
|
2013-10-26 17:58:36 +00:00
|
|
|
#include <net/if_var.h>
|
2007-02-04 16:32:46 +00:00
|
|
|
#include <net/if_clone.h>
|
2000-07-17 23:21:42 +00:00
|
|
|
#include <net/if_types.h>
|
2003-03-04 23:19:55 +00:00
|
|
|
#include <net/netisr.h>
|
1995-01-31 06:15:49 +00:00
|
|
|
#include <net/route.h>
|
2009-08-01 19:26:27 +00:00
|
|
|
#include <net/vnet.h>
|
1995-01-31 06:15:49 +00:00
|
|
|
#ifdef INET
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#endif
|
|
|
|
#include <net/bpf.h>
|
|
|
|
#include <net/if_tun.h>
|
|
|
|
|
2004-02-21 20:29:52 +00:00
|
|
|
#include <sys/queue.h>
|
2008-12-22 01:56:56 +00:00
|
|
|
#include <sys/condvar.h>
|
2004-02-21 20:29:52 +00:00
|
|
|
|
2006-10-22 11:52:19 +00:00
|
|
|
#include <security/mac/mac_framework.h>
|
|
|
|
|
2004-03-29 22:16:39 +00:00
|
|
|
/*
|
|
|
|
* tun_list is protected by global tunmtx. Other mutable fields are
|
|
|
|
* protected by tun->tun_mtx, or by their owning subsystem. tun_dev is
|
|
|
|
* static for the duration of a tunnel interface.
|
|
|
|
*/
|
2004-02-21 20:29:52 +00:00
|
|
|
struct tun_softc {
|
|
|
|
TAILQ_ENTRY(tun_softc) tun_list;
|
2004-06-16 09:47:26 +00:00
|
|
|
struct cdev *tun_dev;
|
2004-02-21 20:29:52 +00:00
|
|
|
u_short tun_flags; /* misc flags */
|
|
|
|
#define TUN_OPEN 0x0001
|
|
|
|
#define TUN_INITED 0x0002
|
|
|
|
#define TUN_RCOLL 0x0004
|
|
|
|
#define TUN_IASET 0x0008
|
|
|
|
#define TUN_DSTADDR 0x0010
|
|
|
|
#define TUN_LMODE 0x0020
|
|
|
|
#define TUN_RWAIT 0x0040
|
|
|
|
#define TUN_ASYNC 0x0080
|
|
|
|
#define TUN_IFHEAD 0x0100
|
|
|
|
|
|
|
|
#define TUN_READY (TUN_OPEN | TUN_INITED)
|
|
|
|
|
2004-03-17 01:12:09 +00:00
|
|
|
/*
|
|
|
|
* XXXRW: tun_pid is used to exclusively lock /dev/tun. Is this
|
|
|
|
* actually needed? Can we just return EBUSY if already open?
|
|
|
|
* Problem is that this involved inherent races when a tun device
|
|
|
|
* is handed off from one process to another, as opposed to just
|
|
|
|
* being slightly stale informationally.
|
|
|
|
*/
|
|
|
|
pid_t tun_pid; /* owning pid */
|
2005-06-10 16:49:24 +00:00
|
|
|
struct ifnet *tun_ifp; /* the interface */
|
2004-02-21 20:29:52 +00:00
|
|
|
struct sigio *tun_sigio; /* information for async I/O */
|
|
|
|
struct selinfo tun_rsel; /* read select */
|
2004-03-29 22:16:39 +00:00
|
|
|
struct mtx tun_mtx; /* protect mutable softc fields */
|
2008-12-22 01:56:56 +00:00
|
|
|
struct cv tun_cv; /* protect against ref'd dev destroy */
|
2004-02-21 20:29:52 +00:00
|
|
|
};
|
2005-06-10 16:49:24 +00:00
|
|
|
#define TUN2IFP(sc) ((sc)->tun_ifp)
|
2004-02-21 20:29:52 +00:00
|
|
|
|
2003-10-31 02:48:12 +00:00
|
|
|
#define TUNDEBUG if (tundebug) if_printf
|
2001-06-01 15:51:10 +00:00
|
|
|
|
2004-03-29 18:42:51 +00:00
|
|
|
/*
|
|
|
|
* All mutable global variables in if_tun are locked using tunmtx, with
|
|
|
|
* the exception of tundebug, which is used unlocked, and tunclones,
|
|
|
|
* which is static after setup.
|
|
|
|
*/
|
|
|
|
static struct mtx tunmtx;
|
2012-10-16 13:37:54 +00:00
|
|
|
static const char tunname[] = "tun";
|
|
|
|
static MALLOC_DEFINE(M_TUN, tunname, "Tunnel Interface");
|
1995-12-09 20:47:15 +00:00
|
|
|
static int tundebug = 0;
|
2007-02-04 16:32:46 +00:00
|
|
|
static int tundclone = 1;
|
2004-02-21 20:29:52 +00:00
|
|
|
static struct clonedevs *tunclones;
|
|
|
|
static TAILQ_HEAD(,tun_softc) tunhead = TAILQ_HEAD_INITIALIZER(tunhead);
|
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
|
|
|
|
2007-02-04 16:32:46 +00:00
|
|
|
SYSCTL_DECL(_net_link);
|
2011-11-07 15:43:11 +00:00
|
|
|
static SYSCTL_NODE(_net_link, OID_AUTO, tun, CTLFLAG_RW, 0,
|
2007-02-04 16:32:46 +00:00
|
|
|
"IP tunnel software network interface.");
|
2014-06-28 03:56:17 +00:00
|
|
|
SYSCTL_INT(_net_link_tun, OID_AUTO, devfs_cloning, CTLFLAG_RWTUN, &tundclone, 0,
|
2007-02-04 16:32:46 +00:00
|
|
|
"Enable legacy devfs interface creation.");
|
|
|
|
|
2005-08-08 19:55:32 +00:00
|
|
|
static void tunclone(void *arg, struct ucred *cred, char *name,
|
|
|
|
int namelen, struct cdev **dev);
|
2007-02-04 16:32:46 +00:00
|
|
|
static void tuncreate(const char *name, struct cdev *dev);
|
2001-06-01 15:51:10 +00:00
|
|
|
static int tunifioctl(struct ifnet *, u_long, caddr_t);
|
2011-06-03 13:47:05 +00:00
|
|
|
static void tuninit(struct ifnet *);
|
2001-06-01 15:51:10 +00:00
|
|
|
static int tunmodevent(module_t, int, void *);
|
2013-04-26 12:50:32 +00:00
|
|
|
static int tunoutput(struct ifnet *, struct mbuf *,
|
|
|
|
const struct sockaddr *, struct route *ro);
|
2001-06-01 15:51:10 +00:00
|
|
|
static void tunstart(struct ifnet *);
|
|
|
|
|
2007-02-04 16:32:46 +00:00
|
|
|
static int tun_clone_create(struct if_clone *, int, caddr_t);
|
|
|
|
static void tun_clone_destroy(struct ifnet *);
|
2012-10-16 13:37:54 +00:00
|
|
|
static struct if_clone *tun_cloner;
|
2007-02-04 16:32:46 +00:00
|
|
|
|
2001-06-01 15:51:10 +00:00
|
|
|
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;
|
2006-08-08 19:22:25 +00:00
|
|
|
static d_kqfilter_t tunkqfilter;
|
|
|
|
|
|
|
|
static int tunkqread(struct knote *, long);
|
|
|
|
static int tunkqwrite(struct knote *, long);
|
|
|
|
static void tunkqdetach(struct knote *);
|
|
|
|
|
|
|
|
static struct filterops tun_read_filterops = {
|
|
|
|
.f_isfd = 1,
|
|
|
|
.f_attach = NULL,
|
|
|
|
.f_detach = tunkqdetach,
|
|
|
|
.f_event = tunkqread,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct filterops tun_write_filterops = {
|
|
|
|
.f_isfd = 1,
|
|
|
|
.f_attach = NULL,
|
|
|
|
.f_detach = tunkqdetach,
|
|
|
|
.f_event = tunkqwrite,
|
|
|
|
};
|
1995-12-08 11:19:42 +00:00
|
|
|
|
|
|
|
static struct cdevsw tun_cdevsw = {
|
2004-02-21 21:10:55 +00:00
|
|
|
.d_version = D_VERSION,
|
2011-10-18 08:09:44 +00:00
|
|
|
.d_flags = D_NEEDMINOR,
|
2003-03-03 12:15:54 +00:00
|
|
|
.d_open = tunopen,
|
|
|
|
.d_close = tunclose,
|
|
|
|
.d_read = tunread,
|
|
|
|
.d_write = tunwrite,
|
|
|
|
.d_ioctl = tunioctl,
|
|
|
|
.d_poll = tunpoll,
|
2006-08-08 19:22:25 +00:00
|
|
|
.d_kqfilter = tunkqfilter,
|
2012-10-16 13:37:54 +00:00
|
|
|
.d_name = tunname,
|
1995-11-06 00:36:19 +00:00
|
|
|
};
|
1995-04-10 20:35:45 +00:00
|
|
|
|
2007-02-04 16:32:46 +00:00
|
|
|
static int
|
|
|
|
tun_clone_create(struct if_clone *ifc, int unit, caddr_t params)
|
|
|
|
{
|
|
|
|
struct cdev *dev;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* find any existing device, or allocate new unit number */
|
|
|
|
i = clone_create(&tunclones, &tun_cdevsw, &unit, &dev, 0);
|
|
|
|
if (i) {
|
|
|
|
/* No preexisting struct cdev *, create one */
|
2008-09-26 14:19:52 +00:00
|
|
|
dev = make_dev(&tun_cdevsw, unit,
|
2012-10-16 13:37:54 +00:00
|
|
|
UID_UUCP, GID_DIALER, 0600, "%s%d", tunname, unit);
|
2007-02-04 16:32:46 +00:00
|
|
|
}
|
2012-10-16 13:37:54 +00:00
|
|
|
tuncreate(tunname, dev);
|
2007-02-04 16:32:46 +00:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2000-08-20 21:34:39 +00:00
|
|
|
static void
|
2005-08-08 19:55:32 +00:00
|
|
|
tunclone(void *arg, struct ucred *cred, char *name, int namelen,
|
|
|
|
struct cdev **dev)
|
2000-08-20 21:34:39 +00:00
|
|
|
{
|
2007-02-04 16:32:46 +00:00
|
|
|
char devname[SPECNAMELEN + 1];
|
|
|
|
int u, i, append_unit;
|
2000-08-20 21:34:39 +00:00
|
|
|
|
2004-06-17 17:16:53 +00:00
|
|
|
if (*dev != NULL)
|
2000-08-20 21:34:39 +00:00
|
|
|
return;
|
2001-06-01 15:51:10 +00:00
|
|
|
|
2007-02-04 16:32:46 +00:00
|
|
|
/*
|
|
|
|
* If tun cloning is enabled, only the superuser can create an
|
|
|
|
* interface.
|
|
|
|
*/
|
|
|
|
if (!tundclone || priv_check_cred(cred, PRIV_NET_IFCREATE, 0) != 0)
|
|
|
|
return;
|
|
|
|
|
2012-10-16 13:37:54 +00:00
|
|
|
if (strcmp(name, tunname) == 0) {
|
2004-02-21 20:29:52 +00:00
|
|
|
u = -1;
|
2012-10-16 13:37:54 +00:00
|
|
|
} else if (dev_stdclone(name, NULL, tunname, &u) != 1)
|
2001-06-01 15:51:10 +00:00
|
|
|
return; /* Don't recognise the name */
|
2004-02-21 20:29:52 +00:00
|
|
|
if (u != -1 && u > IF_MAXUNIT)
|
|
|
|
return; /* Unit number too high */
|
|
|
|
|
2007-02-04 16:32:46 +00:00
|
|
|
if (u == -1)
|
|
|
|
append_unit = 1;
|
|
|
|
else
|
|
|
|
append_unit = 0;
|
|
|
|
|
2009-06-15 19:01:53 +00:00
|
|
|
CURVNET_SET(CRED_TO_VNET(cred));
|
2004-02-21 20:29:52 +00:00
|
|
|
/* find any existing device, or allocate new unit number */
|
|
|
|
i = clone_create(&tunclones, &tun_cdevsw, &u, dev, 0);
|
|
|
|
if (i) {
|
2007-02-04 16:32:46 +00:00
|
|
|
if (append_unit) {
|
2011-05-06 20:46:29 +00:00
|
|
|
namelen = snprintf(devname, sizeof(devname), "%s%d",
|
|
|
|
name, u);
|
2007-02-04 16:32:46 +00:00
|
|
|
name = devname;
|
|
|
|
}
|
2004-06-16 09:47:26 +00:00
|
|
|
/* No preexisting struct cdev *, create one */
|
2010-02-28 16:25:49 +00:00
|
|
|
*dev = make_dev_credf(MAKEDEV_REF, &tun_cdevsw, u, cred,
|
2007-02-04 16:32:46 +00:00
|
|
|
UID_UUCP, GID_DIALER, 0600, "%s", name);
|
2001-06-01 15:51:10 +00:00
|
|
|
}
|
2007-02-04 16:32:46 +00:00
|
|
|
|
|
|
|
if_clone_create(name, namelen, NULL);
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_RESTORE();
|
2000-08-20 21:34:39 +00:00
|
|
|
}
|
|
|
|
|
2004-03-29 18:42:51 +00:00
|
|
|
static void
|
|
|
|
tun_destroy(struct tun_softc *tp)
|
|
|
|
{
|
2004-06-16 09:47:26 +00:00
|
|
|
struct cdev *dev;
|
2004-03-29 18:42:51 +00:00
|
|
|
|
2008-12-22 01:56:56 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2008-12-25 22:32:32 +00:00
|
|
|
if ((tp->tun_flags & TUN_OPEN) != 0)
|
2008-12-22 01:56:56 +00:00
|
|
|
cv_wait_unlock(&tp->tun_cv, &tp->tun_mtx);
|
2008-12-25 02:14:25 +00:00
|
|
|
else
|
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2008-12-25 22:32:32 +00:00
|
|
|
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_SET(TUN2IFP(tp)->if_vnet);
|
2004-03-29 18:42:51 +00:00
|
|
|
dev = tp->tun_dev;
|
2005-06-10 16:49:24 +00:00
|
|
|
bpfdetach(TUN2IFP(tp));
|
|
|
|
if_detach(TUN2IFP(tp));
|
|
|
|
if_free(TUN2IFP(tp));
|
2004-03-29 18:42:51 +00:00
|
|
|
destroy_dev(dev);
|
Fix a deficiency in the selinfo interface:
If a selinfo object is recorded (via selrecord()) and then it is
quickly destroyed, with the waiters missing the opportunity to awake,
at the next iteration they will find the selinfo object destroyed,
causing a PF#.
That happens because the selinfo interface has no way to drain the
waiters before to destroy the registered selinfo object. Also this
race is quite rare to get in practice, because it would require a
selrecord(), a poll request by another thread and a quick destruction
of the selrecord()'ed selinfo object.
Fix this by adding the seldrain() routine which should be called
before to destroy the selinfo objects (in order to avoid such case),
and fix the present cases where it might have already been called.
Sometimes, the context is safe enough to prevent this type of race,
like it happens in device drivers which installs selinfo objects on
poll callbacks. There, the destruction of the selinfo object happens
at driver detach time, when all the filedescriptors should be already
closed, thus there cannot be a race.
For this case, mfi(4) device driver can be set as an example, as it
implements a full correct logic for preventing this from happening.
Sponsored by: Sandvine Incorporated
Reported by: rstone
Tested by: pluknet
Reviewed by: jhb, kib
Approved by: re (bz)
MFC after: 3 weeks
2011-08-25 15:51:54 +00:00
|
|
|
seldrain(&tp->tun_rsel);
|
2013-10-02 20:44:36 +00:00
|
|
|
knlist_clear(&tp->tun_rsel.si_note, 0);
|
2006-08-08 19:22:25 +00:00
|
|
|
knlist_destroy(&tp->tun_rsel.si_note);
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_destroy(&tp->tun_mtx);
|
2008-12-22 01:56:56 +00:00
|
|
|
cv_destroy(&tp->tun_cv);
|
2004-03-29 18:42:51 +00:00
|
|
|
free(tp, M_TUN);
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_RESTORE();
|
2004-03-29 18:42:51 +00:00
|
|
|
}
|
|
|
|
|
2007-02-04 16:32:46 +00:00
|
|
|
static void
|
|
|
|
tun_clone_destroy(struct ifnet *ifp)
|
|
|
|
{
|
|
|
|
struct tun_softc *tp = ifp->if_softc;
|
|
|
|
|
|
|
|
mtx_lock(&tunmtx);
|
|
|
|
TAILQ_REMOVE(&tunhead, tp, tun_list);
|
|
|
|
mtx_unlock(&tunmtx);
|
|
|
|
tun_destroy(tp);
|
|
|
|
}
|
|
|
|
|
2001-01-31 07:58:58 +00:00
|
|
|
static int
|
2003-03-02 15:56:49 +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;
|
|
|
|
|
2003-03-02 15:56:49 +00:00
|
|
|
switch (type) {
|
|
|
|
case MOD_LOAD:
|
2004-03-29 18:42:51 +00:00
|
|
|
mtx_init(&tunmtx, "tunmtx", NULL, MTX_DEF);
|
2004-03-11 12:58:55 +00:00
|
|
|
clone_setup(&tunclones);
|
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);
|
2012-10-16 13:37:54 +00:00
|
|
|
tun_cloner = if_clone_simple(tunname, tun_clone_create,
|
|
|
|
tun_clone_destroy, 0);
|
2003-03-02 15:56:49 +00:00
|
|
|
break;
|
|
|
|
case MOD_UNLOAD:
|
2012-10-16 13:37:54 +00:00
|
|
|
if_clone_detach(tun_cloner);
|
2001-06-01 15:51:10 +00:00
|
|
|
EVENTHANDLER_DEREGISTER(dev_clone, tag);
|
2010-02-28 16:25:49 +00:00
|
|
|
drain_dev_clone_events();
|
2001-06-01 15:51:10 +00:00
|
|
|
|
2004-03-29 18:42:51 +00:00
|
|
|
mtx_lock(&tunmtx);
|
|
|
|
while ((tp = TAILQ_FIRST(&tunhead)) != NULL) {
|
2004-02-21 20:29:52 +00:00
|
|
|
TAILQ_REMOVE(&tunhead, tp, tun_list);
|
2004-03-29 18:42:51 +00:00
|
|
|
mtx_unlock(&tunmtx);
|
|
|
|
tun_destroy(tp);
|
|
|
|
mtx_lock(&tunmtx);
|
2001-04-03 01:22:15 +00:00
|
|
|
}
|
2004-03-29 18:42:51 +00:00
|
|
|
mtx_unlock(&tunmtx);
|
2004-02-21 20:29:52 +00:00
|
|
|
clone_cleanup(&tunclones);
|
2004-03-29 18:42:51 +00:00
|
|
|
mtx_destroy(&tunmtx);
|
2001-04-03 01:22:15 +00:00
|
|
|
break;
|
2004-07-15 08:26:07 +00:00
|
|
|
default:
|
|
|
|
return EOPNOTSUPP;
|
2003-03-02 15:56:49 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2001-01-31 07:58:58 +00:00
|
|
|
|
2003-03-02 15:56:49 +00:00
|
|
|
static moduledata_t tun_mod = {
|
|
|
|
"if_tun",
|
|
|
|
tunmodevent,
|
2012-10-10 08:36:38 +00:00
|
|
|
0
|
2003-03-02 15:56:49 +00:00
|
|
|
};
|
2001-01-31 07:58:58 +00:00
|
|
|
|
|
|
|
DECLARE_MODULE(if_tun, tun_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
|
2013-08-07 01:32:08 +00:00
|
|
|
MODULE_VERSION(if_tun, 1);
|
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;
|
2004-07-02 12:16:02 +00:00
|
|
|
struct mbuf *m;
|
|
|
|
|
2006-08-08 19:22:25 +00:00
|
|
|
TUNDEBUG(ifp,"%s starting\n", ifp->if_xname);
|
2004-07-02 12:16:02 +00:00
|
|
|
if (ALTQ_IS_ENABLED(&ifp->if_snd)) {
|
|
|
|
IFQ_LOCK(&ifp->if_snd);
|
|
|
|
IFQ_POLL_NOLOCK(&ifp->if_snd, m);
|
|
|
|
if (m == NULL) {
|
|
|
|
IFQ_UNLOCK(&ifp->if_snd);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
IFQ_UNLOCK(&ifp->if_snd);
|
|
|
|
}
|
2000-12-05 16:21:00 +00:00
|
|
|
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2000-12-05 16:21:00 +00:00
|
|
|
if (tp->tun_flags & TUN_RWAIT) {
|
|
|
|
tp->tun_flags &= ~TUN_RWAIT;
|
2003-03-02 16:54:40 +00:00
|
|
|
wakeup(tp);
|
2000-12-05 16:21:00 +00:00
|
|
|
}
|
2010-09-22 21:02:43 +00:00
|
|
|
selwakeuppri(&tp->tun_rsel, PZERO + 1);
|
|
|
|
KNOTE_LOCKED(&tp->tun_rsel.si_note, 0);
|
2004-03-29 22:16:39 +00:00
|
|
|
if (tp->tun_flags & TUN_ASYNC && tp->tun_sigio) {
|
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2002-05-01 20:44:46 +00:00
|
|
|
pgsigio(&tp->tun_sigio, SIGIO, 0);
|
2004-03-29 22:16:39 +00:00
|
|
|
} else
|
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2000-12-05 16:21:00 +00:00
|
|
|
}
|
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
/* XXX: should return an error code so it can fail. */
|
1999-08-15 09:54:57 +00:00
|
|
|
static void
|
2007-02-04 16:32:46 +00:00
|
|
|
tuncreate(const char *name, struct cdev *dev)
|
1999-08-15 09:54:57 +00:00
|
|
|
{
|
|
|
|
struct tun_softc *sc;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
2008-10-23 15:53:51 +00:00
|
|
|
sc = malloc(sizeof(*sc), M_TUN, M_WAITOK | M_ZERO);
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_init(&sc->tun_mtx, "tun_mtx", NULL, MTX_DEF);
|
2008-12-22 01:56:56 +00:00
|
|
|
cv_init(&sc->tun_cv, "tun_condvar");
|
1999-08-15 09:54:57 +00:00
|
|
|
sc->tun_flags = TUN_INITED;
|
2004-02-21 20:29:52 +00:00
|
|
|
sc->tun_dev = dev;
|
2004-03-29 18:42:51 +00:00
|
|
|
mtx_lock(&tunmtx);
|
2004-02-21 20:29:52 +00:00
|
|
|
TAILQ_INSERT_TAIL(&tunhead, sc, tun_list);
|
2004-03-29 18:42:51 +00:00
|
|
|
mtx_unlock(&tunmtx);
|
1999-08-15 09:54:57 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->tun_ifp = if_alloc(IFT_PPP);
|
|
|
|
if (ifp == NULL)
|
|
|
|
panic("%s%d: failed to if_alloc() interface.\n",
|
2007-02-04 16:32:46 +00:00
|
|
|
name, dev2unit(dev));
|
|
|
|
if_initname(ifp, name, dev2unit(dev));
|
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;
|
|
|
|
ifp->if_softc = sc;
|
2004-07-02 12:16:02 +00:00
|
|
|
IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
|
|
|
|
ifp->if_snd.ifq_drv_maxlen = 0;
|
|
|
|
IFQ_SET_READY(&ifp->if_snd);
|
2010-09-22 21:02:43 +00:00
|
|
|
knlist_init_mtx(&sc->tun_rsel.si_note, &sc->tun_mtx);
|
2010-03-16 17:59:12 +00:00
|
|
|
ifp->if_capabilities |= IFCAP_LINKSTATE;
|
|
|
|
ifp->if_capenable |= IFCAP_LINKSTATE;
|
2004-07-02 12:16:02 +00:00
|
|
|
|
1999-08-15 09:54:57 +00:00
|
|
|
if_attach(ifp);
|
2005-06-26 18:11:11 +00:00
|
|
|
bpfattach(ifp, DLT_NULL, sizeof(u_int32_t));
|
1999-08-15 09:54:57 +00:00
|
|
|
dev->si_drv1 = sc;
|
2006-08-08 19:22:25 +00:00
|
|
|
TUNDEBUG(ifp, "interface %s is created, minor = %#x\n",
|
2008-09-27 08:51:18 +00:00
|
|
|
ifp->if_xname, dev2unit(dev));
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
2001-06-01 15:51:10 +00:00
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
tunopen(struct cdev *dev, int flag, int mode, struct thread *td)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct tun_softc *tp;
|
2001-06-18 09:21:59 +00:00
|
|
|
|
2004-03-29 22:16:39 +00:00
|
|
|
/*
|
|
|
|
* XXXRW: Non-atomic test and set of dev->si_drv1 requires
|
|
|
|
* synchronization.
|
|
|
|
*/
|
1999-08-15 09:54:57 +00:00
|
|
|
tp = dev->si_drv1;
|
|
|
|
if (!tp) {
|
2012-10-16 13:37:54 +00:00
|
|
|
tuncreate(tunname, dev);
|
1999-08-15 09:54:57 +00:00
|
|
|
tp = dev->si_drv1;
|
|
|
|
}
|
2004-02-21 20:29:52 +00:00
|
|
|
|
2004-03-29 22:16:39 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2004-02-21 20:29:52 +00:00
|
|
|
return (EBUSY);
|
2004-03-29 22:16:39 +00:00
|
|
|
}
|
2004-03-17 01:12:09 +00:00
|
|
|
tp->tun_pid = td->td_proc->p_pid;
|
2004-02-21 20:29:52 +00:00
|
|
|
|
1995-01-31 06:15:49 +00:00
|
|
|
tp->tun_flags |= TUN_OPEN;
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = TUN2IFP(tp);
|
2008-12-12 01:36:50 +00:00
|
|
|
if_link_state_change(ifp, LINK_STATE_UP);
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG(ifp, "open\n");
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
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
|
2004-06-16 09:47:26 +00:00
|
|
|
tunclose(struct cdev *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;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
1999-08-15 09:54:57 +00:00
|
|
|
tp = dev->si_drv1;
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = TUN2IFP(tp);
|
1999-08-15 09:54:57 +00:00
|
|
|
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
1995-01-31 06:15:49 +00:00
|
|
|
tp->tun_flags &= ~TUN_OPEN;
|
2004-03-17 01:12:09 +00:00
|
|
|
tp->tun_pid = 0;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* junk all pending output
|
|
|
|
*/
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_SET(ifp->if_vnet);
|
2004-07-02 12:16:02 +00:00
|
|
|
IFQ_PURGE(&ifp->if_snd);
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
if (ifp->if_flags & IFF_UP) {
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
1995-01-31 06:15:49 +00:00
|
|
|
if_down(ifp);
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
1999-05-27 13:18:28 +00:00
|
|
|
|
2007-02-05 11:15:52 +00:00
|
|
|
/* Delete all addresses and routes which reference this interface. */
|
2005-08-09 10:20:02 +00:00
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
|
2003-03-02 15:56:49 +00:00
|
|
|
struct ifaddr *ifa;
|
1999-05-27 13:18:28 +00:00
|
|
|
|
2010-09-22 21:02:43 +00:00
|
|
|
ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
|
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2007-02-05 11:15:52 +00:00
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
|
|
|
|
/* deal w/IPv4 PtP destination; unlocked read */
|
|
|
|
if (ifa->ifa_addr->sa_family == AF_INET) {
|
1999-05-27 13:18:28 +00:00
|
|
|
rtinit(ifa, (int)RTM_DELETE,
|
|
|
|
tp->tun_flags & TUN_DSTADDR ? RTF_HOST : 0);
|
2007-02-05 11:15:52 +00:00
|
|
|
} else {
|
|
|
|
rtinit(ifa, (int)RTM_DELETE, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if_purgeaddrs(ifp);
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
1999-05-27 13:18:28 +00:00
|
|
|
}
|
2008-12-12 01:36:50 +00:00
|
|
|
if_link_state_change(ifp, LINK_STATE_DOWN);
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_RESTORE();
|
1999-05-27 13:18:28 +00:00
|
|
|
|
2002-05-06 19:31:28 +00:00
|
|
|
funsetown(&tp->tun_sigio);
|
2003-11-09 09:17:26 +00:00
|
|
|
selwakeuppri(&tp->tun_rsel, PZERO + 1);
|
2010-09-22 21:02:43 +00:00
|
|
|
KNOTE_LOCKED(&tp->tun_rsel.si_note, 0);
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG (ifp, "closed\n");
|
2008-12-22 01:56:56 +00:00
|
|
|
|
|
|
|
cv_broadcast(&tp->tun_cv);
|
|
|
|
mtx_unlock(&tp->tun_mtx);
|
1995-01-31 06:15:49 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2011-06-03 13:47:05 +00:00
|
|
|
static void
|
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;
|
2010-10-01 15:14:14 +00:00
|
|
|
#ifdef INET
|
2003-03-02 15:56:49 +00:00
|
|
|
struct ifaddr *ifa;
|
2008-11-05 11:39:46 +00:00
|
|
|
#endif
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG(ifp, "tuninit\n");
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2005-08-09 10:20:02 +00:00
|
|
|
ifp->if_flags |= IFF_UP;
|
|
|
|
ifp->if_drv_flags |= IFF_DRV_RUNNING;
|
1998-04-06 11:43:12 +00:00
|
|
|
getmicrotime(&ifp->if_lastchange);
|
1995-01-31 06:15:49 +00:00
|
|
|
|
1998-01-08 23:42:31 +00:00
|
|
|
#ifdef INET
|
2009-06-26 00:45:20 +00:00
|
|
|
if_addr_rlock(ifp);
|
2006-06-29 19:22:05 +00:00
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
|
|
|
|
if (ifa->ifa_addr->sa_family == AF_INET) {
|
|
|
|
struct sockaddr_in *si;
|
|
|
|
|
|
|
|
si = (struct sockaddr_in *)ifa->ifa_addr;
|
|
|
|
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;
|
2000-11-02 16:30:26 +00:00
|
|
|
}
|
1998-01-08 23:42:31 +00:00
|
|
|
}
|
2009-06-26 00:45:20 +00:00
|
|
|
if_addr_runlock(ifp);
|
2006-06-29 19:22:05 +00:00
|
|
|
#endif
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
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;
|
2010-09-22 21:02:43 +00:00
|
|
|
int error = 0;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
switch(cmd) {
|
1999-06-19 18:42:31 +00:00
|
|
|
case SIOCGIFSTATUS:
|
|
|
|
ifs = (struct ifstat *)data;
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2004-03-17 01:12:09 +00:00
|
|
|
if (tp->tun_pid)
|
2014-01-07 15:59:33 +00:00
|
|
|
snprintf(ifs->ascii, sizeof(ifs->ascii),
|
2004-03-17 01:12:09 +00:00
|
|
|
"\tOpened by PID %d\n", tp->tun_pid);
|
2014-01-07 15:59:33 +00:00
|
|
|
else
|
|
|
|
ifs->ascii[0] = '\0';
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2000-11-02 16:30:26 +00:00
|
|
|
break;
|
1995-01-31 06:15:49 +00:00
|
|
|
case SIOCSIFADDR:
|
2011-06-03 13:47:05 +00:00
|
|
|
tuninit(ifp);
|
|
|
|
TUNDEBUG(ifp, "address set\n");
|
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;
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG(ifp, "mtu set\n");
|
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;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* tunoutput - queue packets from higher level ready to put out.
|
|
|
|
*/
|
2002-10-20 20:53:42 +00:00
|
|
|
static int
|
2013-04-26 12:50:32 +00:00
|
|
|
tunoutput(struct ifnet *ifp, struct mbuf *m0, const struct sockaddr *dst,
|
2011-05-06 20:46:29 +00:00
|
|
|
struct route *ro)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-08-15 09:54:57 +00:00
|
|
|
struct tun_softc *tp = ifp->if_softc;
|
2004-03-29 22:16:39 +00:00
|
|
|
u_short cached_tun_flags;
|
2002-07-31 16:23:42 +00:00
|
|
|
int error;
|
2005-06-26 18:11:11 +00:00
|
|
|
u_int32_t af;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG (ifp, "tunoutput\n");
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2002-07-31 16:23:42 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_ifnet_check_transmit(ifp, m0);
|
2002-07-31 16:23:42 +00:00
|
|
|
if (error) {
|
|
|
|
m_freem(m0);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-03-29 22:16:39 +00:00
|
|
|
/* 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) {
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG (ifp, "not ready 0%o\n", tp->tun_flags);
|
1995-01-31 06:15:49 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2005-06-26 18:11:11 +00:00
|
|
|
/* BPF writes need to be handled specially. */
|
2013-04-26 12:50:32 +00:00
|
|
|
if (dst->sa_family == AF_UNSPEC)
|
2005-06-26 18:11:11 +00:00
|
|
|
bcopy(dst->sa_data, &af, sizeof(af));
|
2013-04-26 12:50:32 +00:00
|
|
|
else
|
2005-06-26 18:11:11 +00:00
|
|
|
af = dst->sa_family;
|
2013-04-26 12:50:32 +00:00
|
|
|
|
|
|
|
if (bpf_peers_present(ifp->if_bpf))
|
2003-12-28 03:56:00 +00:00
|
|
|
bpf_mtap2(ifp->if_bpf, &af, sizeof(af), m0);
|
1999-03-24 21:20:12 +00:00
|
|
|
|
|
|
|
/* prepend sockaddr? this may abort if the mbuf allocation fails */
|
2004-03-29 22:16:39 +00:00
|
|
|
if (cached_tun_flags & TUN_LMODE) {
|
1999-03-24 21:20:12 +00:00
|
|
|
/* allocate space for sockaddr */
|
2012-12-05 08:04:20 +00:00
|
|
|
M_PREPEND(m0, dst->sa_len, M_NOWAIT);
|
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) {
|
2014-09-19 10:39:58 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
|
|
|
|
if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
|
1999-03-24 21:20:12 +00:00
|
|
|
return (ENOBUFS);
|
|
|
|
} else {
|
|
|
|
bcopy(dst, m0->m_data, dst->sa_len);
|
|
|
|
}
|
|
|
|
}
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2004-03-29 22:16:39 +00:00
|
|
|
if (cached_tun_flags & TUN_IFHEAD) {
|
2000-01-23 01:47:12 +00:00
|
|
|
/* Prepend the address family */
|
2012-12-05 08:04:20 +00:00
|
|
|
M_PREPEND(m0, 4, M_NOWAIT);
|
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) {
|
2014-09-19 10:39:58 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
|
|
|
|
if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
|
2002-02-26 03:00:19 +00:00
|
|
|
return (ENOBUFS);
|
2000-01-23 01:47:12 +00:00
|
|
|
} else
|
2013-04-26 12:50:32 +00:00
|
|
|
*(u_int32_t *)m0->m_data = htonl(af);
|
2000-01-23 01:47:12 +00:00
|
|
|
} else {
|
|
|
|
#ifdef INET
|
2013-04-26 12:50:32 +00:00
|
|
|
if (af != 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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-22 07:35:45 +00:00
|
|
|
error = (ifp->if_transmit)(ifp, m0);
|
2011-05-06 20:37:07 +00:00
|
|
|
if (error)
|
2002-02-26 03:00:19 +00:00
|
|
|
return (ENOBUFS);
|
2014-09-19 10:39:58 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
|
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
|
2011-05-06 20:46:29 +00:00
|
|
|
tunioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag,
|
|
|
|
struct thread *td)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
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;
|
2003-03-02 15:56:49 +00:00
|
|
|
struct tuninfo *tunp;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
|
|
|
switch (cmd) {
|
2003-03-02 15:56:49 +00:00
|
|
|
case TUNSIFINFO:
|
|
|
|
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);
|
2006-11-06 13:42:10 +00:00
|
|
|
if (TUN2IFP(tp)->if_mtu != tunp->mtu) {
|
|
|
|
error = priv_check(td, PRIV_NET_SETIFMTU);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2005-06-10 16:49:24 +00:00
|
|
|
TUN2IFP(tp)->if_mtu = tunp->mtu;
|
|
|
|
TUN2IFP(tp)->if_type = tunp->type;
|
|
|
|
TUN2IFP(tp)->if_baudrate = tunp->baudrate;
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2003-03-02 15:56:49 +00:00
|
|
|
break;
|
|
|
|
case TUNGIFINFO:
|
|
|
|
tunp = (struct tuninfo *)data;
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2005-06-10 16:49:24 +00:00
|
|
|
tunp->mtu = TUN2IFP(tp)->if_mtu;
|
|
|
|
tunp->type = TUN2IFP(tp)->if_type;
|
|
|
|
tunp->baudrate = TUN2IFP(tp)->if_baudrate;
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2003-03-02 15:56:49 +00:00
|
|
|
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:
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
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;
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
1999-03-24 21:20:12 +00:00
|
|
|
break;
|
2000-01-23 01:47:12 +00:00
|
|
|
case TUNSIFHEAD:
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2000-01-23 01:47:12 +00:00
|
|
|
if (*(int *)data) {
|
|
|
|
tp->tun_flags |= TUN_IFHEAD;
|
|
|
|
tp->tun_flags &= ~TUN_LMODE;
|
2003-03-02 15:56:49 +00:00
|
|
|
} else
|
2000-01-23 01:47:12 +00:00
|
|
|
tp->tun_flags &= ~TUN_IFHEAD;
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2000-01-23 01:47:12 +00:00
|
|
|
break;
|
|
|
|
case TUNGIFHEAD:
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2000-01-23 01:47:12 +00:00
|
|
|
*(int *)data = (tp->tun_flags & TUN_IFHEAD) ? 1 : 0;
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2000-01-23 01:47:12 +00:00
|
|
|
break;
|
1999-03-24 21:20:12 +00:00
|
|
|
case TUNSIFMODE:
|
|
|
|
/* deny this if UP */
|
2005-06-10 16:49:24 +00:00
|
|
|
if (TUN2IFP(tp)->if_flags & IFF_UP)
|
1999-03-24 21:20:12 +00:00
|
|
|
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:
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2005-06-10 16:49:24 +00:00
|
|
|
TUN2IFP(tp)->if_flags &=
|
2001-08-25 09:12:57 +00:00
|
|
|
~(IFF_BROADCAST|IFF_POINTOPOINT|IFF_MULTICAST);
|
2005-06-10 16:49:24 +00:00
|
|
|
TUN2IFP(tp)->if_flags |= *(int *)data;
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
1999-03-24 21:20:12 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return(EINVAL);
|
|
|
|
}
|
|
|
|
break;
|
2000-01-21 00:31:43 +00:00
|
|
|
case TUNSIFPID:
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
2004-03-17 01:12:09 +00:00
|
|
|
tp->tun_pid = curthread->td_proc->p_pid;
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2000-01-21 00:31:43 +00:00
|
|
|
break;
|
1995-01-31 06:15:49 +00:00
|
|
|
case FIONBIO:
|
|
|
|
break;
|
|
|
|
case FIOASYNC:
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
1995-01-31 06:15:49 +00:00
|
|
|
if (*(int *)data)
|
|
|
|
tp->tun_flags |= TUN_ASYNC;
|
|
|
|
else
|
|
|
|
tp->tun_flags &= ~TUN_ASYNC;
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
1995-01-31 06:15:49 +00:00
|
|
|
break;
|
|
|
|
case FIONREAD:
|
2005-06-10 16:49:24 +00:00
|
|
|
if (!IFQ_IS_EMPTY(&TUN2IFP(tp)->if_snd)) {
|
2004-07-02 12:16:02 +00:00
|
|
|
struct mbuf *mb;
|
2005-06-10 16:49:24 +00:00
|
|
|
IFQ_LOCK(&TUN2IFP(tp)->if_snd);
|
|
|
|
IFQ_POLL_NOLOCK(&TUN2IFP(tp)->if_snd, mb);
|
2010-09-22 21:02:43 +00:00
|
|
|
for (*(int *)data = 0; mb != NULL; mb = mb->m_next)
|
1995-12-11 13:24:58 +00:00
|
|
|
*(int *)data += mb->m_len;
|
2005-06-10 16:49:24 +00:00
|
|
|
IFQ_UNLOCK(&TUN2IFP(tp)->if_snd);
|
1995-12-11 13:24:58 +00:00
|
|
|
} else
|
1995-01-31 06:15:49 +00:00
|
|
|
*(int *)data = 0;
|
|
|
|
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
|
2004-06-16 09:47:26 +00:00
|
|
|
tunread(struct cdev *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;
|
2005-06-10 16:49:24 +00:00
|
|
|
struct ifnet *ifp = TUN2IFP(tp);
|
2002-02-05 02:00:56 +00:00
|
|
|
struct mbuf *m;
|
2010-09-22 21:02:43 +00:00
|
|
|
int error=0, len;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG (ifp, "read\n");
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_lock(&tp->tun_mtx);
|
1995-01-31 06:15:49 +00:00
|
|
|
if ((tp->tun_flags & TUN_READY) != TUN_READY) {
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG (ifp, "not ready 0%o\n", 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;
|
|
|
|
|
|
|
|
do {
|
2004-07-02 12:16:02 +00:00
|
|
|
IFQ_DEQUEUE(&ifp->if_snd, m);
|
2002-02-05 02:00:56 +00:00
|
|
|
if (m == NULL) {
|
2004-12-22 17:39:21 +00:00
|
|
|
if (flag & O_NONBLOCK) {
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2002-02-26 03:00:19 +00:00
|
|
|
return (EWOULDBLOCK);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
tp->tun_flags |= TUN_RWAIT;
|
2010-09-22 21:02:43 +00:00
|
|
|
error = mtx_sleep(tp, &tp->tun_mtx, PCATCH | (PZERO + 1),
|
|
|
|
"tunread", 0);
|
|
|
|
if (error != 0) {
|
|
|
|
mtx_unlock(&tp->tun_mtx);
|
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);
|
2010-09-22 21:02:43 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
1995-01-31 06:15:49 +00:00
|
|
|
|
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)
|
2003-03-02 15:50:23 +00:00
|
|
|
error = uiomove(mtod(m, void *), len, uio);
|
2002-02-05 02:00:56 +00:00
|
|
|
m = m_free(m);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
2002-02-05 02:00:56 +00:00
|
|
|
if (m) {
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG(ifp, "Dropping mbuf\n");
|
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
|
2004-06-16 09:47:26 +00:00
|
|
|
tunwrite(struct cdev *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;
|
2005-06-10 16:49:24 +00:00
|
|
|
struct ifnet *ifp = TUN2IFP(tp);
|
2004-10-31 17:39:46 +00:00
|
|
|
struct mbuf *m;
|
2000-10-15 18:49:17 +00:00
|
|
|
uint32_t family;
|
2003-03-04 23:19:55 +00:00
|
|
|
int isr;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG(ifp, "tunwrite\n");
|
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
|
|
|
/* 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) {
|
2009-06-25 18:46:30 +00:00
|
|
|
TUNDEBUG(ifp, "len=%zd!\n", uio->uio_resid);
|
2002-02-26 03:00:19 +00:00
|
|
|
return (EIO);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
2012-12-05 08:04:20 +00:00
|
|
|
if ((m = m_uiotombuf(uio, M_NOWAIT, 0, 0, M_PKTHDR)) == NULL) {
|
2014-09-19 10:39:58 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
|
2011-06-03 13:47:05 +00:00
|
|
|
return (ENOBUFS);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
|
|
|
|
2004-10-31 17:39:46 +00:00
|
|
|
m->m_pkthdr.rcvif = ifp;
|
2002-07-31 16:23:42 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
mac_ifnet_create_mbuf(ifp, m);
|
2002-07-31 16:23:42 +00:00
|
|
|
#endif
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2004-03-29 22:16:39 +00:00
|
|
|
/* Could be unlocked read? */
|
|
|
|
mtx_lock(&tp->tun_mtx);
|
2000-01-23 01:47:12 +00:00
|
|
|
if (tp->tun_flags & TUN_IFHEAD) {
|
2004-03-29 22:16:39 +00:00
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2004-10-31 17:39:46 +00:00
|
|
|
if (m->m_len < sizeof(family) &&
|
|
|
|
(m = m_pullup(m, sizeof(family))) == NULL)
|
2002-02-26 03:00:19 +00:00
|
|
|
return (ENOBUFS);
|
2004-10-31 17:39:46 +00:00
|
|
|
family = ntohl(*mtod(m, u_int32_t *));
|
|
|
|
m_adj(m, sizeof(family));
|
2004-03-29 22:16:39 +00:00
|
|
|
} else {
|
|
|
|
mtx_unlock(&tp->tun_mtx);
|
2000-01-23 01:47:12 +00:00
|
|
|
family = AF_INET;
|
2004-03-29 22:16:39 +00:00
|
|
|
}
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2004-10-31 17:39:46 +00:00
|
|
|
BPF_MTAP2(ifp, &family, sizeof(family), m);
|
2003-12-28 03:56:00 +00:00
|
|
|
|
2003-03-04 23:19:55 +00:00
|
|
|
switch (family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
|
|
|
isr = NETISR_IP;
|
|
|
|
break;
|
2003-03-08 17:32:21 +00:00
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
|
|
|
isr = NETISR_IPV6;
|
|
|
|
break;
|
2003-03-04 23:19:55 +00:00
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
m_freem(m);
|
|
|
|
return (EAFNOSUPPORT);
|
|
|
|
}
|
|
|
|
if (harvest.point_to_point)
|
2013-11-02 15:13:02 +00:00
|
|
|
random_harvest(&(m->m_data), 12, 2, RANDOM_NET_TUN);
|
2014-09-19 10:39:58 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len);
|
|
|
|
if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_SET(ifp->if_vnet);
|
2011-07-03 16:08:38 +00:00
|
|
|
M_SETFIB(m, ifp->if_fib);
|
2004-10-31 17:39:46 +00:00
|
|
|
netisr_dispatch(isr, m);
|
Step 1.5 of importing the network stack virtualization infrastructure
from the vimage project, as per plan established at devsummit 08/08:
http://wiki.freebsd.org/Image/Notes200808DevSummit
Introduce INIT_VNET_*() initializer macros, VNET_FOREACH() iterator
macros, and CURVNET_SET() context setting macros, all currently
resolving to NOPs.
Prepare for virtualization of selected SYSCTL objects by introducing a
family of SYSCTL_V_*() macros, currently resolving to their global
counterparts, i.e. SYSCTL_V_INT() == SYSCTL_INT().
Move selected #defines from sys/sys/vimage.h to newly introduced header
files specific to virtualized subsystems (sys/net/vnet.h,
sys/netinet/vinet.h etc.).
All the changes are verified to have zero functional impact at this
point in time by doing MD5 comparision between pre- and post-change
object files(*).
(*) netipsec/keysock.c did not validate depending on compile time options.
Implemented by: julian, bz, brooks, zec
Reviewed by: julian, bz, brooks, kris, rwatson, ...
Approved by: julian (mentor)
Obtained from: //depot/projects/vimage-commit2/...
X-MFC after: never
Sponsored by: NLnet Foundation, The FreeBSD Foundation
2008-10-02 15:37:58 +00:00
|
|
|
CURVNET_RESTORE();
|
2003-03-04 23:19:55 +00:00
|
|
|
return (0);
|
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
|
2004-06-16 09:47:26 +00:00
|
|
|
tunpoll(struct cdev *dev, int events, struct thread *td)
|
1995-01-31 06:15:49 +00:00
|
|
|
{
|
1999-08-15 09:54:57 +00:00
|
|
|
struct tun_softc *tp = dev->si_drv1;
|
2005-06-10 16:49:24 +00:00
|
|
|
struct ifnet *ifp = TUN2IFP(tp);
|
1997-09-14 03:09:01 +00:00
|
|
|
int revents = 0;
|
2004-07-02 12:16:02 +00:00
|
|
|
struct mbuf *m;
|
1995-01-31 06:15:49 +00:00
|
|
|
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG(ifp, "tunpoll\n");
|
1995-02-26 12:18:08 +00:00
|
|
|
|
1999-05-06 18:13:11 +00:00
|
|
|
if (events & (POLLIN | POLLRDNORM)) {
|
2004-07-02 12:16:02 +00:00
|
|
|
IFQ_LOCK(&ifp->if_snd);
|
|
|
|
IFQ_POLL_NOLOCK(&ifp->if_snd, m);
|
|
|
|
if (m != NULL) {
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG(ifp, "tunpoll q=%d\n", ifp->if_snd.ifq_len);
|
1997-09-14 03:09:01 +00:00
|
|
|
revents |= events & (POLLIN | POLLRDNORM);
|
|
|
|
} else {
|
2003-10-31 02:48:12 +00:00
|
|
|
TUNDEBUG(ifp, "tunpoll waiting\n");
|
2001-09-21 22:46:54 +00:00
|
|
|
selrecord(td, &tp->tun_rsel);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
2004-07-02 12:16:02 +00:00
|
|
|
IFQ_UNLOCK(&ifp->if_snd);
|
1999-05-06 18:13:11 +00:00
|
|
|
}
|
1997-09-14 03:09:01 +00:00
|
|
|
if (events & (POLLOUT | POLLWRNORM))
|
|
|
|
revents |= events & (POLLOUT | POLLWRNORM);
|
|
|
|
|
|
|
|
return (revents);
|
1995-01-31 06:15:49 +00:00
|
|
|
}
|
2006-08-08 19:22:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* tunkqfilter - support for the kevent() system call.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
tunkqfilter(struct cdev *dev, struct knote *kn)
|
|
|
|
{
|
|
|
|
struct tun_softc *tp = dev->si_drv1;
|
|
|
|
struct ifnet *ifp = TUN2IFP(tp);
|
|
|
|
|
|
|
|
switch(kn->kn_filter) {
|
|
|
|
case EVFILT_READ:
|
|
|
|
TUNDEBUG(ifp, "%s kqfilter: EVFILT_READ, minor = %#x\n",
|
2008-09-27 08:51:18 +00:00
|
|
|
ifp->if_xname, dev2unit(dev));
|
2006-08-08 19:22:25 +00:00
|
|
|
kn->kn_fop = &tun_read_filterops;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EVFILT_WRITE:
|
|
|
|
TUNDEBUG(ifp, "%s kqfilter: EVFILT_WRITE, minor = %#x\n",
|
2008-09-27 08:51:18 +00:00
|
|
|
ifp->if_xname, dev2unit(dev));
|
2006-08-08 19:22:25 +00:00
|
|
|
kn->kn_fop = &tun_write_filterops;
|
|
|
|
break;
|
2011-05-06 20:46:29 +00:00
|
|
|
|
2006-08-08 19:22:25 +00:00
|
|
|
default:
|
|
|
|
TUNDEBUG(ifp, "%s kqfilter: invalid filter, minor = %#x\n",
|
2008-09-27 08:51:18 +00:00
|
|
|
ifp->if_xname, dev2unit(dev));
|
2006-08-08 19:22:25 +00:00
|
|
|
return(EINVAL);
|
|
|
|
}
|
|
|
|
|
2010-09-22 21:02:43 +00:00
|
|
|
kn->kn_hook = tp;
|
2006-08-08 19:22:25 +00:00
|
|
|
knlist_add(&tp->tun_rsel.si_note, kn, 0);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return true of there is data in the interface queue.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
tunkqread(struct knote *kn, long hint)
|
|
|
|
{
|
2010-09-22 21:02:43 +00:00
|
|
|
int ret;
|
|
|
|
struct tun_softc *tp = kn->kn_hook;
|
|
|
|
struct cdev *dev = tp->tun_dev;
|
2006-08-08 19:22:25 +00:00
|
|
|
struct ifnet *ifp = TUN2IFP(tp);
|
|
|
|
|
|
|
|
if ((kn->kn_data = ifp->if_snd.ifq_len) > 0) {
|
|
|
|
TUNDEBUG(ifp,
|
|
|
|
"%s have data in the queue. Len = %d, minor = %#x\n",
|
2008-09-27 08:51:18 +00:00
|
|
|
ifp->if_xname, ifp->if_snd.ifq_len, dev2unit(dev));
|
2006-08-08 19:22:25 +00:00
|
|
|
ret = 1;
|
|
|
|
} else {
|
|
|
|
TUNDEBUG(ifp,
|
|
|
|
"%s waiting for data, minor = %#x\n", ifp->if_xname,
|
2008-09-27 08:51:18 +00:00
|
|
|
dev2unit(dev));
|
2006-08-08 19:22:25 +00:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Always can write, always return MTU in kn->data.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
tunkqwrite(struct knote *kn, long hint)
|
|
|
|
{
|
2010-09-22 21:02:43 +00:00
|
|
|
struct tun_softc *tp = kn->kn_hook;
|
2006-08-08 19:22:25 +00:00
|
|
|
struct ifnet *ifp = TUN2IFP(tp);
|
|
|
|
|
|
|
|
kn->kn_data = ifp->if_mtu;
|
|
|
|
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tunkqdetach(struct knote *kn)
|
|
|
|
{
|
2010-09-22 21:02:43 +00:00
|
|
|
struct tun_softc *tp = kn->kn_hook;
|
2006-08-08 19:22:25 +00:00
|
|
|
|
|
|
|
knlist_remove(&tp->tun_rsel.si_note, kn, 0);
|
|
|
|
}
|