#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_srt.c,v 1.32 2021/06/16 00:21:19 riastradh Exp $");
#ifdef _KERNEL_OPT
#include "opt_inet.h"
#endif
#if !defined(INET) && !defined(INET6)
#error "srt without INET/INET6?"
#endif
#ifndef SRT_MAXUNIT
#define SRT_MAXUNIT 255
#endif
#include <sys/types.h>
#include <sys/resource.h>
#include <netinet/in.h>
#include <sys/param.h>
#include <netinet/in_systm.h>
#include <sys/conf.h>
#include <sys/mbuf.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/module.h>
#include <sys/device.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
#include <netinet6/in6_var.h>
#include <netinet6/ip6_var.h>
#include <netinet6/nd6.h>
#include <netinet6/scope6_var.h>
#include <net/if_types.h>
#include "if_srt.h"
struct srt_softc {
struct ifnet intf;
int unit;
int nrt;
struct srt_rt **rts;
unsigned int flags;
#define SSF_UCHG (SSF_MTULOCK)
unsigned int kflags;
#define SKF_CDEVOPEN 0x00000001
};
#include "ioconf.h"
static struct srt_softc *softcv[SRT_MAXUNIT+1];
static unsigned int global_flags;
static u_int srt_count;
#ifdef _MODULE
devmajor_t srt_bmajor = -1, srt_cmajor = -1;
#endif
static int srt_open(dev_t, int, int, struct lwp *);
static int srt_close(dev_t, int, int, struct lwp *);
static int srt_ioctl(dev_t, u_long, void *, int, struct lwp *);
const struct cdevsw srt_cdevsw = {
.d_open = srt_open,
.d_close = srt_close,
.d_read = nullread,
.d_write = nullwrite,
.d_ioctl = srt_ioctl,
.d_stop = nullstop,
.d_tty = notty,
.d_poll = nullpoll,
.d_mmap = nommap,
.d_kqfilter = nullkqfilter,
.d_discard = nodiscard,
.d_flag = D_OTHER
};
static unsigned int ipv4_masks[33] = {
0x00000000,
0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff
};
static void
update_mtu(struct srt_softc *sc)
{
int mtu;
int i;
struct srt_rt *r;
if (sc->flags & SSF_MTULOCK)
return;
mtu = 65535;
for (i = sc->nrt-1; i>=0; i--) {
r = sc->rts[i];
if (r->u.dstifp->if_mtu < mtu)
mtu = r->u.dstifp->if_mtu;
}
sc->intf.if_mtu = mtu;
}
static struct srt_rt *
find_rt(struct srt_softc *sc, int af, ...)
{
int i;
struct srt_rt *r;
struct in_addr ia;
struct in6_addr ia6;
va_list ap;
ia.s_addr = 0; ia6.s6_addr[0] = 0;
va_start(ap,af);
switch (af) {
case AF_INET:
ia = va_arg(ap,struct in_addr);
break;
case AF_INET6:
ia6 = va_arg(ap,struct in6_addr);
break;
default:
panic("if_srt find_rt: impossible address family");
break;
}
va_end(ap);
for (i=0; i < sc->nrt; i++) {
r = sc->rts[i];
if (r->af != af)
continue;
switch (af) {
case AF_INET:
if ((ia.s_addr & htonl(ipv4_masks[r->srcmask])) ==
r->srcmatch.v4.s_addr)
return r;
break;
case AF_INET6:
if ((r->srcmask >= 8) &&
memcmp(&ia6,&r->srcmatch.v6,r->srcmask / 8) != 0)
continue;
if ((r->srcmask % 8) &&
((ia6.s6_addr[r->srcmask / 8] ^
r->srcmatch.v6.s6_addr[r->srcmask / 8]) &
0xff & (0xff00 >> (r->srcmask % 8))))
continue;
return r;
default:
panic("if_srt find_rt: impossible address family 2");
break;
}
}
return 0;
}
static int
srt_if_ioctl(struct ifnet *ifp, u_long cmd, void *data)
{
struct ifaddr *ifa;
int s;
int err;
err = 0;
s = splnet();
switch (cmd) {
case SIOCINITIFADDR:
ifa = (void *) data;
switch (ifa->ifa_addr->sa_family) {
#ifdef INET
case AF_INET:
break;
#endif
#ifdef INET6
case AF_INET6:
break;
#endif
default:
err = EAFNOSUPPORT;
break;
}
break;
default:
if ((err = ifioctl_common(ifp, cmd, data)) == ENETRESET)
err = 0;
break;
}
splx(s);
return err;
}
static int
srt_if_output(
struct ifnet *ifp,
struct mbuf *m,
const struct sockaddr *to,
const struct rtentry *rtp)
{
struct srt_softc *sc;
struct srt_rt *r;
sc = ifp->if_softc;
if (! (ifp->if_flags & IFF_UP)) {
m_freem(m);
return ENETDOWN;
}
switch (to->sa_family) {
#ifdef INET
case AF_INET: {
struct ip *ip;
ip = mtod(m,struct ip *);
r = find_rt(sc,AF_INET,ip->ip_src);
break;
}
#endif
#ifdef INET6
case AF_INET6: {
struct ip6_hdr *ip;
ip = mtod(m,struct ip6_hdr *);
r = find_rt(sc,AF_INET6,ip->ip6_src);
break;
}
#endif
default:
IF_DROP(&ifp->if_snd);
m_freem(m);
return EAFNOSUPPORT;
}
if_statinc(ifp, if_opackets);
if (! r) {
if_statinc(ifp, if_oerrors);
m_freem(m);
return 0;
}
if (! (m->m_flags & M_PKTHDR)) {
printf("srt_if_output no PKTHDR\n");
m_freem(m);
return 0;
}
if_statadd(ifp, if_obytes, m->m_pkthdr.len);
if (! (r->u.dstifp->if_flags & IFF_UP)) {
m_freem(m);
return 0;
}
if (to->sa_family == AF_INET6)
return ip6_if_output(r->u.dstifp, r->u.dstifp, m, &r->dst.sin6, 0);
return if_output_lock(r->u.dstifp, r->u.dstifp, m, &r->dst.sa, 0);
}
static int
srt_clone_create(struct if_clone *cl, int unit)
{
struct srt_softc *sc;
if (unit < 0 || unit > SRT_MAXUNIT)
return ENXIO;
if (softcv[unit])
return EBUSY;
sc = malloc(sizeof(struct srt_softc), M_DEVBUF, M_WAITOK | M_ZERO);
sc->unit = unit;
sc->nrt = 0;
sc->rts = 0;
sc->flags = 0;
sc->kflags = 0;
if_initname(&sc->intf,cl->ifc_name,unit);
sc->intf.if_softc = sc;
sc->intf.if_mtu = 65535;
sc->intf.if_flags = IFF_POINTOPOINT;
sc->intf.if_type = IFT_OTHER;
sc->intf.if_ioctl = &srt_if_ioctl;
sc->intf.if_output = &srt_if_output;
sc->intf.if_dlt = DLT_RAW;
if_attach(&sc->intf);
if_alloc_sadl(&sc->intf);
#ifdef BPFILTER_NOW_AVAILABLE
bpf_attach(&sc->intf, 0, 0);
#endif
softcv[unit] = sc;
atomic_inc_uint(&srt_count);
return 0;
}
static int
srt_clone_destroy(struct ifnet *ifp)
{
struct srt_softc *sc;
sc = ifp->if_softc;
if ((ifp->if_flags & IFF_UP) || (sc->kflags & SKF_CDEVOPEN))
return EBUSY;
#ifdef BPFILTER_NOW_AVAILABLE
bpf_detach(ifp);
#endif
if_detach(ifp);
if (sc->unit < 0 || sc->unit > SRT_MAXUNIT) {
panic("srt_clone_destroy: impossible unit %d\n",sc->unit);
}
if (softcv[sc->unit] != sc) {
panic("srt_clone_destroy: bad backpointer ([%d]=%p not %p)\n",
sc->unit, (void *)softcv[sc->unit], (void *)sc);
}
softcv[sc->unit] = 0;
free(sc, M_DEVBUF);
atomic_inc_uint(&srt_count);
return 0;
}
struct if_clone srt_clone =
IF_CLONE_INITIALIZER("srt", &srt_clone_create, &srt_clone_destroy);
void
srtattach(int n)
{
}
static void
srtinit(void)
{
int i;
for (i = SRT_MAXUNIT; i >= 0; i--)
softcv[i] = 0;
global_flags = 0;
if_clone_attach(&srt_clone);
#ifdef _MODULE
devsw_attach("srt", NULL, &srt_bmajor, &srt_cdevsw, &srt_cmajor);
#endif
}
static int
srtdetach(void)
{
int error = 0;
int i;
if_clone_detach(&srt_clone);
#ifdef _MODULE
devsw_detach(NULL, &srt_cdevsw);
if (error != 0) {
if_clone_attach(&srt_clone);
return error;
}
#endif
for (i = SRT_MAXUNIT; i >= 0; i--)
if(softcv[i]) {
error = EBUSY;
#ifdef _MODULE
devsw_attach("srt", NULL, &srt_bmajor,
&srt_cdevsw, &srt_cmajor);
#endif
if_clone_attach(&srt_clone);
break;
}
return error;
}
static int
srt_open(dev_t dev, int flag, int mode, struct lwp *l)
{
int unit;
struct srt_softc *sc;
unit = minor(dev);
if (unit < 0 || unit > SRT_MAXUNIT)
return ENXIO;
sc = softcv[unit];
if (sc == NULL) {
(void)srt_clone_create(&srt_clone, minor(dev));
sc = softcv[unit];
}
if (! sc)
return ENXIO;
sc->kflags |= SKF_CDEVOPEN;
return 0;
}
static int
srt_close(dev_t dev, int flag, int mode, struct lwp *l)
{
int unit;
struct srt_softc *sc;
unit = minor(dev);
if (unit < 0 || unit > SRT_MAXUNIT)
return ENXIO;
sc = softcv[unit];
if (! sc)
return ENXIO;
sc->kflags &= ~SKF_CDEVOPEN;
return 0;
}
static int
srt_ioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
unsigned int f, i, n, o;
struct srt_softc *sc;
struct srt_rt *dr;
struct srt_rt *scr;
struct ifnet *ifp;
char nbuf[IFNAMSIZ];
sc = softcv[minor(dev)];
if (! sc)
panic("srt_ioctl: softc disappeared");
switch (cmd) {
case SRT_GETNRT:
if (! (flag & FREAD))
return EBADF;
*(unsigned int *)data = sc->nrt;
return 0;
case SRT_GETRT:
if (! (flag & FREAD))
return EBADF;
dr = (struct srt_rt *) data;
if (dr->inx >= sc->nrt)
return EDOM;
scr = sc->rts[dr->inx];
dr->af = scr->af;
dr->srcmatch = scr->srcmatch;
dr->srcmask = scr->srcmask;
strlcpy(&dr->u.dstifn[0], &scr->u.dstifp->if_xname[0],
IFNAMSIZ);
memcpy(&dr->dst, &scr->dst, scr->dst.sa.sa_len);
return 0;
case SRT_SETRT:
if (! (flag & FWRITE))
return EBADF;
dr = (struct srt_rt *) data;
if (dr->inx > sc->nrt)
return EDOM;
strlcpy(&nbuf[0], &dr->u.dstifn[0], IFNAMSIZ);
nbuf[IFNAMSIZ-1] = '\0';
if (dr->dst.sa.sa_family != dr->af)
return EIO;
switch (dr->af) {
#ifdef INET
case AF_INET:
if (dr->dst.sa.sa_len != sizeof(dr->dst.sin))
return EIO;
if (dr->srcmask > 32)
return EIO;
break;
#endif
#ifdef INET6
case AF_INET6:
if (dr->dst.sa.sa_len != sizeof(dr->dst.sin6))
return EIO;
if (dr->srcmask > 128)
return EIO;
break;
#endif
default:
return EAFNOSUPPORT;
}
ifp = ifunit(&nbuf[0]);
if (ifp == 0)
return ENXIO;
if (dr->inx == sc->nrt) {
struct srt_rt **tmp;
tmp = malloc((sc->nrt+1)*sizeof(*tmp), M_DEVBUF,
M_WAITOK);
if (tmp == 0)
return ENOBUFS;
tmp[sc->nrt] = 0;
if (sc->nrt > 0) {
memcpy(tmp, sc->rts, sc->nrt*sizeof(*tmp));
free(sc->rts, M_DEVBUF);
}
sc->rts = tmp;
sc->nrt ++;
}
scr = sc->rts[dr->inx];
if (scr == 0) {
scr = malloc(sizeof(struct srt_rt), M_DEVBUF,M_WAITOK);
if (scr == 0)
return ENOBUFS;
scr->inx = dr->inx;
scr->af = AF_UNSPEC;
sc->rts[dr->inx] = scr;
}
scr->af = dr->af;
scr->srcmatch = dr->srcmatch;
scr->srcmask = dr->srcmask;
scr->u.dstifp = ifp;
memcpy(&scr->dst,&dr->dst,dr->dst.sa.sa_len);
if (dr->af == AF_INET6)
in6_setzoneid(&scr->dst.sin6.sin6_addr, ifp->if_index);
update_mtu(sc);
return 0;
case SRT_DELRT:
if (! (flag & FWRITE))
return EBADF;
i = *(unsigned int *)data;
if (i >= sc->nrt)
return EDOM;
scr = sc->rts[i];
sc->rts[i] = 0;
free(scr, M_DEVBUF);
sc->nrt--;
if (i < sc->nrt) {
memcpy(sc->rts+i, sc->rts+i+1,
(sc->nrt-i) * sizeof(*sc->rts));
}
if (sc->nrt == 0) {
free(sc->rts, M_DEVBUF);
sc->rts = 0;
sc->intf.if_flags &= ~IFF_UP;
}
update_mtu(sc);
return 0;
case SRT_SFLAGS:
if (! (flag & FWRITE))
return EBADF;
f = *(unsigned int *)data & SSF_UCHG;
global_flags = (global_flags & ~SSF_UCHG) | (f & SSF_GLOBAL);
sc->flags = (sc->flags & ~SSF_UCHG) | (f & ~SSF_GLOBAL);
return 0;
case SRT_GFLAGS:
if (! (flag & FREAD))
return EBADF;
*(unsigned int *)data = sc->flags | global_flags;
return 0;
case SRT_SGFLAGS:
if ((flag & (FWRITE | FREAD)) != (FWRITE | FREAD))
return EBADF;
o = sc->flags | global_flags;
n = *(unsigned int *)data & SSF_UCHG;
global_flags = (global_flags & ~SSF_UCHG) | (n & SSF_GLOBAL);
sc->flags = (sc->flags & ~SSF_UCHG) | (n & ~SSF_GLOBAL);
*(unsigned int *)data = o;
return 0;
case SRT_DEBUG:
return 0;
break;
}
return ENOTTY;
}
#include "if_module.h"
IF_MODULE(MODULE_CLASS_DRIVER, srt, NULL)
