ref: d8a8ac237a5c08ce5a6fe990c213ffc0292a18dc
dir: /sys/src/9/ip/ipifc.c/
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "../port/error.h"
#include "ip.h"
#include "ipv6.h"
#define DPRINT if(0)print
enum {
Maxmedia = 32,
Nself = Maxmedia*5,
NHASH = 1<<6,
NCACHE = 256,
QMAX = 192*1024-1,
};
Medium *media[Maxmedia] = { 0 };
/*
* cache of local addresses (addresses we answer to)
*/
struct Ipself
{
uchar a[IPaddrlen];
Ipself *next; /* next address in the hash table */
Iplink *link; /* binding twixt Ipself and Ipifc */
ulong expire;
uchar type; /* type of address */
};
struct Ipselftab
{
QLock;
int inited;
int acceptall; /* true if an interface has the null address */
Ipself *hash[NHASH]; /* hash chains */
};
/*
* Multicast addresses are chained onto a Chan so that
* we can remove them when the Chan is closed.
*/
typedef struct Ipmcast Ipmcast;
struct Ipmcast
{
Ipmcast *next;
uchar ma[IPaddrlen]; /* multicast address */
uchar ia[IPaddrlen]; /* interface address */
};
/* quick hash for ip addresses */
#define hashipa(a) ( ( ((a)[IPaddrlen-2]<<8) | (a)[IPaddrlen-1] )%NHASH )
static char tifc[] = "ifc ";
static void addselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, uchar *a, int type);
static void remselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, uchar *a);
static void ipifcregisteraddr(Fs*, Ipifc*, Iplifc*, uchar*);
static void ipifcregisterproxy(Fs*, Ipifc*, uchar*, int);
static char* ipifcremlifc(Ipifc*, Iplifc**);
static char Ebound[] = "interface already bound";
static char Eunbound[] = "interface not bound";
enum {
unknownv6, /* UGH */
unspecifiedv6,
linklocalv6,
globalv6,
};
static int
v6addrtype(uchar *addr)
{
if(isv4(addr) || ipcmp(addr, IPnoaddr) == 0)
return unknownv6;
else if(islinklocal(addr) || ipcmp(addr, v6loopback) == 0 ||
isv6mcast(addr) && (addr[1] & 0xF) <= Link_local_scop)
return linklocalv6;
else
return globalv6;
}
static int
comprefixlen(uchar *a, uchar *b, int n)
{
int i, c;
for(i = 0; i < n; i++){
if((c = a[i] ^ b[i]) == 0)
continue;
for(i <<= 3; (c & 0x80) == 0; i++)
c <<= 1;
return i;
}
return i << 3;
}
/*
* link in a new medium
*/
void
addipmedium(Medium *med)
{
int i;
for(i = 0; i < nelem(media)-1; i++)
if(media[i] == nil){
media[i] = med;
break;
}
}
/*
* find the medium with this name
*/
Medium*
ipfindmedium(char *name)
{
Medium **mp;
for(mp = media; *mp != nil; mp++)
if(strcmp((*mp)->name, name) == 0)
break;
return *mp;
}
/*
* attach a device (or pkt driver) to the interface.
* called with c locked
*/
static char*
ipifcbind(Conv *c, char **argv, int argc)
{
Ipifc *ifc;
Medium *m;
if(argc < 2)
return Ebadarg;
ifc = (Ipifc*)c->ptcl;
/* bind the device to the interface */
m = ipfindmedium(argv[1]);
if(m == nil)
return "unknown interface type";
wlock(ifc);
if(ifc->m != nil){
wunlock(ifc);
return Ebound;
}
if(waserror()){
wunlock(ifc);
nexterror();
}
/* do medium specific binding */
(*m->bind)(ifc, argc, argv);
/* set the bound device name */
if(argc > 2)
strncpy(ifc->dev, argv[2], sizeof(ifc->dev));
else
snprint(ifc->dev, sizeof ifc->dev, "%s%d", m->name, c->x);
ifc->dev[sizeof(ifc->dev)-1] = 0;
/* set up parameters */
ifc->m = m;
ifc->mintu = ifc->m->mintu;
ifc->maxtu = ifc->m->maxtu;
ifc->delay = 40;
ifc->speed = 0;
if(ifc->m->unbindonclose == 0)
ifc->conv->inuse++;
/* default router paramters */
ifc->rp = c->p->f->v6p->rp;
/* any ancillary structures (like routes) no longer pertain */
ifc->ifcid++;
/* reopen all the queues closed by a previous unbind */
qreopen(c->rq);
qreopen(c->eq);
qreopen(c->sq);
wunlock(ifc);
poperror();
return nil;
}
/*
* detach a device from an interface, close the interface
*/
static char*
ipifcunbind(Ipifc *ifc)
{
wlock(ifc);
if(ifc->m == nil){
wunlock(ifc);
return Eunbound;
}
/* disassociate logical interfaces (before zeroing ifc->arg) */
while(ifc->lifc != nil)
ipifcremlifc(ifc, &ifc->lifc);
/* disassociate device */
if(ifc->m->unbind != nil){
if(!waserror()){
(*ifc->m->unbind)(ifc);
poperror();
}
}
memset(ifc->dev, 0, sizeof(ifc->dev));
ifc->arg = nil;
ifc->reflect = 0;
ifc->reassemble = 0;
/* close queues to stop queuing of packets */
qclose(ifc->conv->rq);
qclose(ifc->conv->wq);
qclose(ifc->conv->sq);
/* dissociate routes */
ifc->ifcid++;
if(ifc->m->unbindonclose == 0)
ifc->conv->inuse--;
ifc->m = nil;
wunlock(ifc);
return nil;
}
char sfixedformat[] = "device %s maxtu %d sendra %d recvra %d mflag %d oflag %d"
" maxraint %d minraint %d linkmtu %d reachtime %d rxmitra %d ttl %d routerlt %d"
" pktin %lud pktout %lud errin %lud errout %lud speed %d delay %d\n";
char slineformat[] = " %-40I %-10M %-40I %-12lud %-12lud\n";
static int
ipifcstate(Conv *c, char *state, int n)
{
Ipifc *ifc;
Iplifc *lifc;
int m;
ifc = (Ipifc*)c->ptcl;
m = snprint(state, n, sfixedformat,
ifc->dev, ifc->maxtu, ifc->sendra6, ifc->recvra6,
ifc->rp.mflag, ifc->rp.oflag, ifc->rp.maxraint,
ifc->rp.minraint, ifc->rp.linkmtu, ifc->rp.reachtime,
ifc->rp.rxmitra, ifc->rp.ttl, ifc->rp.routerlt,
ifc->in, ifc->out, ifc->inerr, ifc->outerr,
ifc->speed, ifc->delay);
rlock(ifc);
for(lifc = ifc->lifc; lifc != nil && n > m; lifc = lifc->next)
m += snprint(state+m, n - m, slineformat, lifc->local,
lifc->mask, lifc->remote, lifc->validlt, lifc->preflt);
if(ifc->lifc == nil)
m += snprint(state+m, n - m, "\n");
runlock(ifc);
return m;
}
static int
ipifclocal(Conv *c, char *state, int n)
{
Ipifc *ifc;
Iplifc *lifc;
Iplink *link;
int m;
ifc = (Ipifc*)c->ptcl;
rlock(ifc);
m = 0;
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
m += snprint(state+m, n - m, "%-40.40I ->", lifc->local);
for(link = lifc->link; link != nil; link = link->lifclink)
m += snprint(state+m, n - m, " %-40.40I", link->self->a);
m += snprint(state+m, n - m, "\n");
}
runlock(ifc);
return m;
}
static int
ipifcinuse(Conv *c)
{
Ipifc *ifc;
ifc = (Ipifc*)c->ptcl;
return ifc->m != nil;
}
static void
ipifcadjustburst(Ipifc *ifc)
{
int burst;
burst = ((vlong)ifc->delay * ifc->speed) / 8000;
if(burst < ifc->maxtu)
burst = ifc->maxtu;
ifc->burst = burst;
}
static void
ipifcsetdelay(Ipifc *ifc, int delay)
{
if(delay < 0)
delay = 0;
else if(delay > 1000)
delay = 1000;
ifc->delay = delay;
ipifcadjustburst(ifc);
}
static void
ipifcsetspeed(Ipifc *ifc, int speed)
{
if(speed < 0)
speed = 0;
ifc->speed = speed;
ifc->load = 0;
ipifcadjustburst(ifc);
}
void
ipifcoput(Ipifc *ifc, Block *bp, int version, uchar *ip)
{
if(ifc->speed){
ulong now = MACHP(0)->ticks;
int dt = TK2MS(now - ifc->ticks);
ifc->ticks = now;
ifc->load -= ((vlong)dt * ifc->speed) / 8000;
if(ifc->load < 0 || dt < 0 || dt > 1000)
ifc->load = 0;
else if(ifc->load > ifc->burst){
freeblist(bp);
return;
}
}
bp = concatblock(bp);
ifc->load += BLEN(bp);
ifc->m->bwrite(ifc, bp, version, ip);
}
/*
* called when a process writes to an interface's 'data'
*/
static void
ipifckick(void *x)
{
Conv *c = x;
Block *bp;
Ipifc *ifc;
bp = qget(c->wq);
if(bp == nil)
return;
ifc = (Ipifc*)c->ptcl;
if(!canrlock(ifc)){
freeb(bp);
return;
}
if(waserror()){
runlock(ifc);
nexterror();
}
if(ifc->m != nil && ifc->m->pktin != nil)
(*ifc->m->pktin)(c->p->f, ifc, bp);
else
freeb(bp);
runlock(ifc);
poperror();
}
/*
* called when a new ipifc structure is created
*/
static void
ipifccreate(Conv *c)
{
Ipifc *ifc;
c->rq = qopen(QMAX, 0, 0, 0);
c->wq = qopen(QMAX, Qkick, ipifckick, c);
c->sq = qopen(QMAX, 0, 0, 0);
if(c->rq == nil || c->wq == nil || c->sq == nil)
error(Enomem);
ifc = (Ipifc*)c->ptcl;
ifc->conv = c;
ifc->m = nil;
ifc->reflect = 0;
ifc->reassemble = 0;
}
/*
* called after last close of ipifc data or ctl
*/
static void
ipifcclose(Conv *c)
{
Ipifc *ifc = (Ipifc*)c->ptcl;
Medium *m = ifc->m;
if(m != nil && m->unbindonclose)
ipifcunbind(ifc);
}
/*
* change an interface's mtu
*/
static char*
ipifcsetmtu(Ipifc *ifc, int mtu)
{
Medium *m = ifc->m;
if(m == nil)
return Eunbound;
if(mtu < m->mintu || mtu > m->maxtu)
return Ebadarg;
ifc->maxtu = mtu;
ipifcadjustburst(ifc);
return nil;
}
/*
* add an address to an interface.
*/
char*
ipifcadd(Ipifc *ifc, char **argv, int argc, int tentative, Iplifc *lifcp)
{
uchar ip[IPaddrlen], mask[IPaddrlen], rem[IPaddrlen];
uchar bcast[IPaddrlen], net[IPaddrlen];
Iplifc *lifc, **l;
int i, type, mtu;
Fs *f;
mtu = 0;
type = Rifc;
memset(ip, 0, IPaddrlen);
memset(mask, 0, IPaddrlen);
memset(rem, 0, IPaddrlen);
switch(argc){
case 6:
if(strcmp(argv[5], "proxy") == 0)
type |= Rproxy;
/* fall through */
case 5:
mtu = strtoul(argv[4], 0, 0);
/* fall through */
case 4:
if (parseipandmask(ip, mask, argv[1], argv[2]) == -1 || parseip(rem, argv[3]) == -1)
return Ebadip;
maskip(rem, mask, net);
break;
case 3:
if (parseipandmask(ip, mask, argv[1], argv[2]) == -1)
return Ebadip;
maskip(ip, mask, rem);
maskip(rem, mask, net);
break;
case 2:
if (parseip(ip, argv[1]) == -1)
return Ebadip;
memmove(mask, defmask(ip), IPaddrlen);
maskip(ip, mask, rem);
maskip(rem, mask, net);
break;
default:
return Ebadarg;
}
/* check for point-to-point interface */
if(ipcmp(ip, v6loopback) != 0) /* skip v6 loopback, it's a special address */
if(ipcmp(mask, IPallbits) == 0)
type |= Rptpt;
if(isv4(ip) || ipcmp(ip, IPnoaddr) == 0){
type |= Rv4;
tentative = 0;
}
wlock(ifc);
if(ifc->m == nil){
wunlock(ifc);
return Eunbound;
}
f = ifc->conv->p->f;
if(waserror()){
wunlock(ifc);
return up->errstr;
}
if(mtu > 0)
ipifcsetmtu(ifc, mtu);
/* ignore if this is already a local address for this ifc */
if((lifc = iplocalonifc(ifc, ip)) != nil){
if(lifcp != nil) {
if(!lifc->onlink && lifcp->onlink){
lifc->onlink = 1;
addroute(f, lifc->remote, lifc->mask, ip, IPallbits,
lifc->remote, lifc->type, ifc, tifc);
if(v6addrtype(ip) != linklocalv6)
addroute(f, lifc->remote, lifc->mask, ip, IPnoaddr,
lifc->remote, lifc->type, ifc, tifc);
}
lifc->autoflag = lifcp->autoflag;
lifc->validlt = lifcp->validlt;
lifc->preflt = lifcp->preflt;
lifc->origint = lifcp->origint;
}
if(lifc->tentative != tentative){
lifc->tentative = tentative;
goto done;
}
wunlock(ifc);
poperror();
return nil;
}
/* add the address to the list of logical ifc's for this ifc */
lifc = smalloc(sizeof(Iplifc));
ipmove(lifc->local, ip);
ipmove(lifc->mask, mask);
ipmove(lifc->remote, rem);
ipmove(lifc->net, net);
lifc->type = type;
lifc->tentative = tentative;
if(lifcp != nil) {
lifc->onlink = lifcp->onlink;
lifc->autoflag = lifcp->autoflag;
lifc->validlt = lifcp->validlt;
lifc->preflt = lifcp->preflt;
lifc->origint = lifcp->origint;
} else { /* default values */
lifc->onlink = lifc->autoflag = 1;
lifc->validlt = lifc->preflt = ~0UL;
lifc->origint = NOW / 1000;
}
lifc->next = nil;
for(l = &ifc->lifc; *l != nil; l = &(*l)->next)
;
*l = lifc;
/* add route for this logical interface */
if(lifc->onlink){
addroute(f, rem, mask, ip, IPallbits, rem, type, ifc, tifc);
if(v6addrtype(ip) != linklocalv6)
addroute(f, rem, mask, ip, IPnoaddr, rem, type, ifc, tifc);
}
addselfcache(f, ifc, lifc, ip, Runi);
/* register proxy */
if(type & Rptpt){
if(type & Rproxy)
ipifcregisterproxy(f, ifc, rem, 1);
goto done;
}
if(type & Rv4) {
/* add subnet directed broadcast address to the self cache */
for(i = 0; i < IPaddrlen; i++)
bcast[i] = (ip[i] & mask[i]) | ~mask[i];
addselfcache(f, ifc, lifc, bcast, Rbcast);
/* add subnet directed network address to the self cache */
for(i = 0; i < IPaddrlen; i++)
bcast[i] = (ip[i] & mask[i]) & mask[i];
addselfcache(f, ifc, lifc, bcast, Rbcast);
/* add network directed broadcast address to the self cache */
memmove(mask, defmask(ip), IPaddrlen);
for(i = 0; i < IPaddrlen; i++)
bcast[i] = (ip[i] & mask[i]) | ~mask[i];
addselfcache(f, ifc, lifc, bcast, Rbcast);
/* add network directed network address to the self cache */
memmove(mask, defmask(ip), IPaddrlen);
for(i = 0; i < IPaddrlen; i++)
bcast[i] = (ip[i] & mask[i]) & mask[i];
addselfcache(f, ifc, lifc, bcast, Rbcast);
addselfcache(f, ifc, lifc, IPv4bcast, Rbcast);
} else {
if(ipcmp(ip, v6loopback) == 0) {
/* add node-local mcast address */
addselfcache(f, ifc, lifc, v6allnodesN, Rmulti);
/* add route for all node multicast */
addroute(f, v6allnodesN, v6allnodesNmask,
ip, IPallbits,
v6allnodesN, Rmulti, ifc, tifc);
}
/* add all nodes multicast address */
addselfcache(f, ifc, lifc, v6allnodesL, Rmulti);
/* add route for all nodes multicast */
addroute(f, v6allnodesL, v6allnodesLmask,
ip, IPallbits,
v6allnodesL, Rmulti, ifc, tifc);
/* add solicited-node multicast address */
ipv62smcast(bcast, ip);
addselfcache(f, ifc, lifc, bcast, Rmulti);
}
done:
ipifcregisteraddr(f, ifc, lifc, ip);
wunlock(ifc);
poperror();
return nil;
}
/*
* remove a logical interface from an ifc
* called with ifc wlock'd
*/
static char*
ipifcremlifc(Ipifc *ifc, Iplifc **l)
{
Iplifc *lifc = *l;
Fs *f = ifc->conv->p->f;
if(lifc == nil)
return "address not on this interface";
*l = lifc->next;
/* disassociate any addresses */
while(lifc->link != nil)
remselfcache(f, ifc, lifc, lifc->link->self->a);
/* remove the route for this logical interface */
if(lifc->onlink){
remroute(f, lifc->remote, lifc->mask,
lifc->local, IPallbits,
lifc->remote, lifc->type, ifc, tifc);
if(v6addrtype(lifc->local) != linklocalv6)
remroute(f, lifc->remote, lifc->mask,
lifc->local, IPnoaddr,
lifc->remote, lifc->type, ifc, tifc);
}
/* unregister proxy */
if(lifc->type & Rptpt){
if(lifc->type & Rproxy)
ipifcregisterproxy(f, ifc, lifc->remote, 0);
goto done;
}
/* remove route for all nodes multicast */
if((lifc->type & Rv4) == 0){
if(ipcmp(lifc->local, v6loopback) == 0)
remroute(f, v6allnodesN, v6allnodesNmask,
lifc->local, IPallbits,
v6allnodesN, Rmulti, ifc, tifc);
remroute(f, v6allnodesL, v6allnodesLmask,
lifc->local, IPallbits,
v6allnodesL, Rmulti, ifc, tifc);
}
done:
free(lifc);
return nil;
}
/*
* remove an address from an interface.
*/
char*
ipifcrem(Ipifc *ifc, char **argv, int argc)
{
uchar ip[IPaddrlen], mask[IPaddrlen], rem[IPaddrlen];
Iplifc *lifc, **l;
char *err;
if(argc < 3)
return Ebadarg;
if(parseipandmask(ip, mask, argv[1], argv[2]) == -1)
return Ebadip;
if(argc < 4)
maskip(ip, mask, rem);
else if(parseip(rem, argv[3]) == -1)
return Ebadip;
/*
* find address on this interface and remove from chain.
* for pt to pt we actually specify the remote address as the
* addresss to remove.
*/
wlock(ifc);
l = &ifc->lifc;
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next) {
if(ipcmp(ip, lifc->local) == 0
&& ipcmp(mask, lifc->mask) == 0
&& ipcmp(rem, lifc->remote) == 0)
break;
l = &lifc->next;
}
err = ipifcremlifc(ifc, l);
wunlock(ifc);
return err;
}
/*
* associate an address with the interface. This wipes out any previous
* addresses. This is a macro that means, remove all the old interfaces
* and add a new one.
*/
static char*
ipifcconnect(Conv* c, char **argv, int argc)
{
Ipifc *ifc = (Ipifc*)c->ptcl;
char *err;
wlock(ifc);
while(ifc->lifc != nil)
ipifcremlifc(ifc, &ifc->lifc);
wunlock(ifc);
err = ipifcadd(ifc, argv, argc, 0, nil);
if(err != nil)
return err;
Fsconnected(c, nil);
return nil;
}
char*
ipifcra6(Ipifc *ifc, char **argv, int argc)
{
int i, argsleft;
uchar sendra, recvra;
Routerparams rp;
i = 1;
argsleft = argc - 1;
if((argsleft % 2) != 0)
return Ebadarg;
sendra = ifc->sendra6;
recvra = ifc->recvra6;
rp = ifc->rp;
while (argsleft > 1) {
if(strcmp(argv[i], "recvra") == 0)
recvra = atoi(argv[i+1]) != 0;
else if(strcmp(argv[i], "sendra") == 0)
sendra = atoi(argv[i+1]) != 0;
else if(strcmp(argv[i], "mflag") == 0)
rp.mflag = atoi(argv[i+1]) != 0;
else if(strcmp(argv[i], "oflag") == 0)
rp.oflag = atoi(argv[i+1]) != 0;
else if(strcmp(argv[i], "maxraint") == 0)
rp.maxraint = atoi(argv[i+1]);
else if(strcmp(argv[i], "minraint") == 0)
rp.minraint = atoi(argv[i+1]);
else if(strcmp(argv[i], "linkmtu") == 0)
rp.linkmtu = atoi(argv[i+1]);
else if(strcmp(argv[i], "reachtime") == 0)
rp.reachtime = atoi(argv[i+1]);
else if(strcmp(argv[i], "rxmitra") == 0)
rp.rxmitra = atoi(argv[i+1]);
else if(strcmp(argv[i], "ttl") == 0)
rp.ttl = atoi(argv[i+1]);
else if(strcmp(argv[i], "routerlt") == 0)
rp.routerlt = atoi(argv[i+1]);
else
return Ebadarg;
argsleft -= 2;
i += 2;
}
/* consistency check */
if(rp.maxraint < rp.minraint)
return Ebadarg;
ifc->rp = rp;
ifc->sendra6 = sendra;
ifc->recvra6 = recvra;
return nil;
}
/*
* non-standard control messages.
*/
static char*
ipifcctl(Conv* c, char **argv, int argc)
{
Ipifc *ifc = (Ipifc*)c->ptcl;
if(strcmp(argv[0], "add") == 0)
return ipifcadd(ifc, argv, argc, 0, nil);
else if(strcmp(argv[0], "try") == 0)
return ipifcadd(ifc, argv, argc, 1, nil);
else if(strcmp(argv[0], "remove") == 0)
return ipifcrem(ifc, argv, argc);
else if(strcmp(argv[0], "unbind") == 0)
return ipifcunbind(ifc);
else if(strcmp(argv[0], "mtu") == 0)
return ipifcsetmtu(ifc, argc>1? strtoul(argv[1], 0, 0): 0);
else if(strcmp(argv[0], "speed") == 0){
ipifcsetspeed(ifc, argc>1? atoi(argv[1]): 0);
return nil;
}
else if(strcmp(argv[0], "delay") == 0){
ipifcsetdelay(ifc, argc>1? atoi(argv[1]): 0);
return nil;
}
else if(strcmp(argv[0], "iprouting") == 0){
iprouting(c->p->f, argc>1? atoi(argv[1]): 1);
return nil;
}
else if(strcmp(argv[0], "reflect") == 0){
ifc->reflect = argc>1? atoi(argv[1]): 1;
return nil;
}
else if(strcmp(argv[0], "reassemble") == 0){
ifc->reassemble = argc>1? atoi(argv[1]): 1;
return nil;
}
else if(strcmp(argv[0], "add6") == 0)
return ipifcadd6(ifc, argv, argc);
else if(strcmp(argv[0], "remove6") == 0)
return ipifcremove6(ifc, argv, argc);
else if(strcmp(argv[0], "ra6") == 0)
return ipifcra6(ifc, argv, argc);
return "unsupported ctl";
}
int
ipifcstats(Proto *ipifc, char *buf, int len)
{
return ipstats(ipifc->f, buf, len);
}
void
ipifcinit(Fs *f)
{
Proto *ipifc;
ipifc = smalloc(sizeof(Proto));
ipifc->name = "ipifc";
ipifc->connect = ipifcconnect;
ipifc->announce = nil;
ipifc->bind = ipifcbind;
ipifc->state = ipifcstate;
ipifc->create = ipifccreate;
ipifc->close = ipifcclose;
ipifc->rcv = nil;
ipifc->ctl = ipifcctl;
ipifc->advise = nil;
ipifc->stats = ipifcstats;
ipifc->inuse = ipifcinuse;
ipifc->local = ipifclocal;
ipifc->ipproto = -1;
ipifc->nc = Maxmedia;
ipifc->ptclsize = sizeof(Ipifc);
f->ipifc = ipifc; /* hack for ipifcremroute, findipifc, ... */
f->self = smalloc(sizeof(Ipselftab)); /* hack for ipforme */
Fsproto(f, ipifc);
}
/*
* add to self routing cache
*/
static void
addselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, uchar *a, int type)
{
Iplink *lp;
Ipself *p;
int h;
type |= (lifc->type & Rv4);
qlock(f->self);
if(waserror()){
qunlock(f->self);
nexterror();
}
/* see if the address already exists */
h = hashipa(a);
for(p = f->self->hash[h]; p != nil; p = p->next)
if(ipcmp(a, p->a) == 0)
break;
/* allocate a local address and add to hash chain */
if(p == nil){
p = smalloc(sizeof(*p));
ipmove(p->a, a);
p->type = type;
p->next = f->self->hash[h];
f->self->hash[h] = p;
/* if the null address, accept all packets */
if(ipcmp(a, v4prefix) == 0 || ipcmp(a, IPnoaddr) == 0)
f->self->acceptall = 1;
}
/* look for a link for this lifc */
for(lp = p->link; lp != nil; lp = lp->selflink)
if(lp->lifc == lifc)
break;
/* allocate a lifc-to-local link and link to both */
if(lp == nil){
lp = smalloc(sizeof(*lp));
lp->ref = 1;
lp->lifc = lifc;
lp->self = p;
lp->selflink = p->link;
p->link = lp;
lp->lifclink = lifc->link;
lifc->link = lp;
/* add to routing table */
addroute(f, a, IPallbits,
lifc->local,
((type & (Rbcast|Rmulti)) != 0 || v6addrtype(a) == linklocalv6) ?
IPallbits : IPnoaddr,
a, type, ifc, tifc);
if((type & Rmulti) && ifc->m->addmulti != nil)
(*ifc->m->addmulti)(ifc, a, lifc->local);
} else
lp->ref++;
qunlock(f->self);
poperror();
}
/*
* These structures are unlinked from their chains while
* other threads may be using them. To avoid excessive locking,
* just put them aside for a while before freeing them.
* called with f->self locked
*/
static Iplink *freeiplink;
static Ipself *freeipself;
static void
iplinkfree(Iplink *p)
{
Iplink **l, *np;
ulong now = NOW;
l = &freeiplink;
for(np = *l; np != nil; np = *l){
if((long)(now - np->expire) >= 0){
*l = np->next;
free(np);
continue;
}
l = &np->next;
}
p->expire = now + 5000; /* give other threads 5 secs to get out */
p->next = nil;
*l = p;
}
static void
ipselffree(Ipself *p)
{
Ipself **l, *np;
ulong now = NOW;
l = &freeipself;
for(np = *l; np != nil; np = *l){
if((long)(now - np->expire) >= 0){
*l = np->next;
free(np);
continue;
}
l = &np->next;
}
p->expire = now + 5000; /* give other threads 5 secs to get out */
p->next = nil;
*l = p;
}
/*
* Decrement reference for this address on this link.
* Unlink from selftab if this is the last ref.
*/
static void
remselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, uchar *a)
{
Ipself *p, **l;
Iplink *link, **l_self, **l_lifc;
qlock(f->self);
/* find the unique selftab entry */
l = &f->self->hash[hashipa(a)];
for(p = *l; p != nil; p = *l){
if(ipcmp(p->a, a) == 0)
break;
l = &p->next;
}
if(p == nil)
goto out;
/*
* walk down links from an ifc looking for one
* that matches the selftab entry
*/
l_lifc = &lifc->link;
for(link = *l_lifc; link != nil; link = *l_lifc){
if(link->self == p)
break;
l_lifc = &link->lifclink;
}
if(link == nil)
goto out;
/*
* walk down the links from the selftab looking for
* the one we just found
*/
l_self = &p->link;
for(link = *l_self; link != nil; link = *l_self){
if(link == *l_lifc)
break;
l_self = &link->selflink;
}
if(link == nil)
panic("remselfcache");
if(--(link->ref) != 0)
goto out;
/* remove from routing table */
remroute(f, a, IPallbits,
lifc->local,
((p->type & (Rbcast|Rmulti)) != 0 || v6addrtype(a) == linklocalv6) ?
IPallbits : IPnoaddr,
a, p->type, ifc, tifc);
if((p->type & Rmulti) && ifc->m->remmulti != nil){
if(!waserror()){
(*ifc->m->remmulti)(ifc, a, lifc->local);
poperror();
}
}
/* ref == 0, remove from both chains and free the link */
*l_lifc = link->lifclink;
*l_self = link->selflink;
iplinkfree(link);
if(p->link != nil)
goto out;
/* if null address, forget */
if(ipcmp(a, v4prefix) == 0 || ipcmp(a, IPnoaddr) == 0)
f->self->acceptall = 0;
/* no more links, remove from hash and free */
*l = p->next;
ipselffree(p);
out:
qunlock(f->self);
}
long
ipselftabread(Fs *f, char *cp, ulong offset, int n)
{
int i, m, nifc, off;
Ipself *p;
Iplink *link;
char state[8];
m = 0;
off = offset;
for(i = 0; i < NHASH && m < n; i++){
for(p = f->self->hash[i]; p != nil && m < n; p = p->next){
nifc = 0;
for(link = p->link; link != nil; link = link->selflink)
nifc++;
routetype(p->type, state);
m += snprint(cp + m, n - m, "%-44.44I %2.2d %4.4s\n",
p->a, nifc, state);
if(off > 0){
off -= m;
m = 0;
}
}
}
return m;
}
/*
* returns
* 0 - no match
* Runi
* Rbcast
* Rmulti
*/
int
ipforme(Fs *f, uchar *addr)
{
Ipself *p;
for(p = f->self->hash[hashipa(addr)]; p != nil; p = p->next)
if(ipcmp(addr, p->a) == 0)
return p->type & (Runi|Rbcast|Rmulti);
/* hack to say accept anything */
if(f->self->acceptall)
return Runi;
return 0;
}
/*
* find the ifc on same net as the remote system. If none,
* return nil.
*/
Ipifc*
findipifc(Fs *f, uchar *local, uchar *remote, int type)
{
uchar gnet[IPaddrlen];
int spec, xspec;
Ipifc *ifc, *x;
Iplifc *lifc;
Conv **cp;
x = nil;
xspec = 0;
for(cp = f->ipifc->conv; *cp != nil; cp++){
ifc = (Ipifc*)(*cp)->ptcl;
rlock(ifc);
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
if(type & Runi){
if(ipcmp(remote, lifc->local) == 0){
Found:
runlock(ifc);
return ifc;
}
} else if(type & (Rbcast|Rmulti)) {
if(ipcmp(local, lifc->local) == 0)
goto Found;
}
maskip(remote, lifc->mask, gnet);
if(ipcmp(gnet, lifc->net) == 0){
spec = comprefixlen(remote, lifc->local, IPaddrlen);
if(spec > xspec){
x = ifc;
xspec = spec;
}
}
}
runlock(ifc);
}
return x;
}
Ipifc*
findipifcstr(Fs *f, char *s)
{
uchar ip[IPaddrlen];
Conv *c;
char *p;
long x;
x = strtol(s, &p, 10);
if(p > s && *p == '\0'){
if(x < 0)
return nil;
if(x < f->ipifc->nc && (c = f->ipifc->conv[x]) != nil && ipifcinuse(c))
return (Ipifc*)c->ptcl;
}
if(parseip(ip, s) != -1)
return findipifc(f, ip, ip, Runi);
return nil;
}
/*
* find "best" (global > link local > unspecified)
* local address; address must be current.
*/
static void
findprimaryipv6(Fs *f, uchar *local)
{
ulong now = NOW/1000;
int atype, atypel;
Iplifc *lifc;
Ipifc *ifc;
Conv **cp;
ipmove(local, v6Unspecified);
atype = unspecifiedv6;
for(cp = f->ipifc->conv; *cp != nil; cp++){
ifc = (Ipifc*)(*cp)->ptcl;
rlock(ifc);
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
atypel = v6addrtype(lifc->local);
if(atypel > atype)
if(lifc->preflt == ~0UL || lifc->preflt >= now-lifc->origint) {
ipmove(local, lifc->local);
atype = atypel;
if(atype == globalv6){
runlock(ifc);
return;
}
}
}
runlock(ifc);
}
}
/*
* returns first v4 address configured
*/
static void
findprimaryipv4(Fs *f, uchar *local)
{
Iplifc *lifc;
Ipifc *ifc;
Conv **cp;
/* find first ifc local address */
for(cp = f->ipifc->conv; *cp != nil; cp++){
ifc = (Ipifc*)(*cp)->ptcl;
rlock(ifc);
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
if((lifc->type & Rv4) != 0){
ipmove(local, lifc->local);
runlock(ifc);
return;
}
}
runlock(ifc);
}
ipmove(local, IPnoaddr);
}
/*
* return v4 address associated with an interface close to remote
*/
int
ipv4local(Ipifc *ifc, uchar *local, uchar *remote)
{
Iplifc *lifc;
int a, b;
b = -1;
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
if((lifc->type & Rv4) == 0 || ipcmp(lifc->local, IPnoaddr) == 0)
continue;
a = comprefixlen(lifc->local+IPv4off, remote, IPv4addrlen);
if(a > b){
b = a;
memmove(local, lifc->local+IPv4off, IPv4addrlen);
}
}
return b >= 0;
}
/*
* return v6 address associated with an interface close to remote
*/
int
ipv6local(Ipifc *ifc, uchar *local, uchar *remote)
{
struct {
int atype;
int deprecated;
int comprefixlen;
} a, b;
int atype;
ulong now;
Iplifc *lifc;
if(isv4(remote)){
ipmove(local, v4prefix);
return ipv4local(ifc, local+IPv4off, remote+IPv4off);
}
atype = v6addrtype(remote);
ipmove(local, v6Unspecified);
b.atype = unknownv6;
b.deprecated = 1;
b.comprefixlen = 0;
now = NOW/1000;
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
if(lifc->tentative)
continue;
a.atype = v6addrtype(lifc->local);
a.deprecated = lifc->preflt != ~0UL && lifc->preflt < now-lifc->origint;
a.comprefixlen = comprefixlen(lifc->local, remote, IPaddrlen);
/* prefer appropriate scope */
if(a.atype != b.atype){
if(a.atype > b.atype && b.atype < atype ||
a.atype < b.atype && b.atype > atype)
goto Good;
continue;
}
/* prefer non-deprecated addresses */
if(a.deprecated != b.deprecated){
if(b.deprecated)
goto Good;
continue;
}
/* prefer longer common prefix */
if(a.comprefixlen != b.comprefixlen){
if(a.comprefixlen > b.comprefixlen)
goto Good;
continue;
}
continue;
Good:
b = a;
ipmove(local, lifc->local);
}
return b.atype >= atype;
}
void
findlocalip(Fs *f, uchar *local, uchar *remote)
{
Route *r;
Iplifc *lifc;
Ipifc *ifc, *nifc;
Conv **cp;
for(cp = f->ipifc->conv; *cp != nil; cp++){
ifc = (Ipifc*)(*cp)->ptcl;
rlock(ifc);
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
if(lifc->tentative)
continue;
r = v6lookup(f, remote, lifc->local, nil);
if(r == nil || (nifc = r->ifc) == nil)
continue;
if(r->type & Runi){
ipmove(local, remote);
runlock(ifc);
return;
}
if(nifc != ifc) rlock(nifc);
if((r->type & (Rifc|Rbcast|Rmulti|Rv4)) == Rv4){
ipmove(local, v4prefix);
if(ipv4local(nifc, local+IPv4off, r->v4.gate)){
if(nifc != ifc) runlock(nifc);
runlock(ifc);
return;
}
}
if(ipv6local(nifc, local, remote)){
if(nifc != ifc) runlock(nifc);
runlock(ifc);
return;
}
if(nifc != ifc) runlock(nifc);
}
runlock(ifc);
}
if(isv4(remote))
findprimaryipv4(f, local);
else
findprimaryipv6(f, local);
}
/*
* see if this address is bound to the interface
*/
Iplifc*
iplocalonifc(Ipifc *ifc, uchar *ip)
{
Iplifc *lifc;
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next)
if(ipcmp(ip, lifc->local) == 0)
return lifc;
return nil;
}
Iplifc*
ipremoteonifc(Ipifc *ifc, uchar *ip)
{
uchar net[IPaddrlen];
Iplifc *lifc;
for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
maskip(ip, lifc->mask, net);
if(ipcmp(net, lifc->remote) == 0)
return lifc;
}
return nil;
}
/*
* See if we're proxying for this address on this interface
*/
int
ipproxyifc(Fs *f, Ipifc *ifc, uchar *ip)
{
Route *r;
/* see if this is a direct connected pt to pt address */
r = v6lookup(f, ip, ip, nil);
if(r == nil || (r->type & (Rifc|Rproxy)) != (Rifc|Rproxy))
return 0;
return ipremoteonifc(ifc, ip) != nil;
}
/*
* return multicast version if any
*/
int
ipismulticast(uchar *ip)
{
if(isv4(ip)){
if(ip[IPv4off] >= 0xe0 && ip[IPv4off] < 0xf0)
return V4;
}
else if(ip[0] == 0xff)
return V6;
return 0;
}
/*
* add a multicast address to an interface.
*/
void
ipifcaddmulti(Conv *c, uchar *ma, uchar *ia)
{
Ipmulti *multi, **l;
Iplifc *lifc;
Ipifc *ifc;
Fs *f;
if(isv4(ma) != isv4(ia))
error("incompatible multicast/interface ip address");
for(l = &c->multi; *l != nil; l = &(*l)->next)
if(ipcmp(ma, (*l)->ma) == 0 && ipcmp(ia, (*l)->ia) == 0)
return; /* it's already there */
f = c->p->f;
if((ifc = findipifc(f, ia, ma, Rmulti)) != nil){
rlock(ifc);
if(waserror()){
runlock(ifc);
nexterror();
}
if((lifc = iplocalonifc(ifc, ia)) != nil)
addselfcache(f, ifc, lifc, ma, Rmulti);
runlock(ifc);
poperror();
}
multi = smalloc(sizeof(*multi));
ipmove(multi->ma, ma);
ipmove(multi->ia, ia);
multi->next = nil;
*l = multi;
}
/*
* remove a multicast address from an interface.
*/
void
ipifcremmulti(Conv *c, uchar *ma, uchar *ia)
{
Ipmulti *multi, **l;
Iplifc *lifc;
Ipifc *ifc;
Fs *f;
for(l = &c->multi; *l != nil; l = &(*l)->next)
if(ipcmp(ma, (*l)->ma) == 0 && ipcmp(ia, (*l)->ia) == 0)
break;
multi = *l;
if(multi == nil)
return; /* we don't have it open */
*l = multi->next;
multi->next = nil;
f = c->p->f;
if((ifc = findipifc(f, ia, ma, Rmulti)) != nil){
rlock(ifc);
if(!waserror()){
if((lifc = iplocalonifc(ifc, ia)) != nil)
remselfcache(f, ifc, lifc, ma);
poperror();
}
runlock(ifc);
}
free(multi);
}
/* register the address on this network for address resolution */
static void
ipifcregisteraddr(Fs *f, Ipifc *ifc, Iplifc *lifc, uchar *ip)
{
if(waserror()){
print("ipifcregisteraddr %s %I %I: %s\n", ifc->dev, lifc->local, ip, up->errstr);
return;
}
if(ifc->m != nil && ifc->m->areg != nil)
(*ifc->m->areg)(f, ifc, lifc, ip);
poperror();
}
static void
ipifcregisterproxy(Fs *f, Ipifc *ifc, uchar *ip, int add)
{
uchar a[IPaddrlen];
Iplifc *lifc;
Ipifc *nifc;
Conv **cp;
/* register the address on any interface that will proxy for the ip */
for(cp = f->ipifc->conv; *cp != nil; cp++){
nifc = (Ipifc*)(*cp)->ptcl;
if(nifc == ifc || !canrlock(nifc))
continue;
if(nifc->m == nil
|| (lifc = ipremoteonifc(nifc, ip)) == nil
|| (lifc->type & Rptpt) != 0
|| waserror()){
runlock(nifc);
continue;
}
if((lifc->type & Rv4) == 0){
/* add solicited-node multicast addr */
ipv62smcast(a, ip);
if(add)
addselfcache(f, nifc, lifc, a, Rmulti);
else
remselfcache(f, nifc, lifc, a);
}
if(add)
ipifcregisteraddr(f, nifc, lifc, ip);
runlock(nifc);
poperror();
}
}
char*
ipifcadd6(Ipifc *ifc, char **argv, int argc)
{
int plen = 64;
char addr[40], preflen[6];
char *params[3];
uchar prefix[IPaddrlen];
Iplifc lifc;
Medium *m;
lifc.onlink = 1;
lifc.autoflag = 1;
lifc.validlt = lifc.preflt = ~0UL;
lifc.origint = NOW / 1000;
switch(argc) {
case 7:
lifc.preflt = strtoul(argv[6], 0, 10);
/* fall through */
case 6:
lifc.validlt = strtoul(argv[5], 0, 10);
/* fall through */
case 5:
lifc.autoflag = atoi(argv[4]) != 0;
/* fall through */
case 4:
lifc.onlink = atoi(argv[3]) != 0;
/* fall through */
case 3:
plen = atoi(argv[2]);
/* fall through */
case 2:
break;
default:
return Ebadarg;
}
if (parseip(prefix, argv[1]) != 6 || lifc.validlt < lifc.preflt || plen < 0 ||
plen > 64 || islinklocal(prefix))
return Ebadarg;
/* issue "add" ctl msg for v6 link-local addr and prefix len */
m = ifc->m;
if(m == nil || m->pref2addr == nil)
return Eunbound;
(*m->pref2addr)(prefix, ifc->mac); /* mac → v6 link-local addr */
sprint(addr, "%I", prefix);
sprint(preflen, "/%d", plen);
params[0] = "add";
params[1] = addr;
params[2] = preflen;
return ipifcadd(ifc, params, 3, 0, &lifc);
}
char*
ipifcremove6(Ipifc *ifc, char**, int argc)
{
Iplifc *lifc, **l;
ulong now;
if(argc != 1)
return Ebadarg;
wlock(ifc);
now = NOW/1000;
for(l = &ifc->lifc; (lifc = *l) != nil;) {
if((lifc->type & Rv4) == 0)
if(lifc->validlt != ~0UL && lifc->validlt < now-lifc->origint)
if(ipifcremlifc(ifc, l) == nil)
continue;
l = &lifc->next;
}
wunlock(ifc);
return nil;
}