#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ip.h>
enum
{
Version= 1,
Pasize= 4,
/*
* definitions that are innately tied to BSD
*/
AF_INET= 2,
AF_UNSPEC= 0,
/*
* Packet types.
*/
Request= 1,
Response= 2,
Traceon= 3,
Traceoff= 4,
Infinity= 16, /* infinite hop count */
Maxpacket= 488, /* largest packet body */
};
/*
* network info
*/
typedef struct Rip Rip;
struct Rip
{
uchar family[2];
uchar port[2];
uchar addr[Pasize];
uchar pad[8];
uchar metric[4];
};
typedef struct Ripmsg Ripmsg;
struct Ripmsg
{
uchar type;
uchar vers;
uchar pad[2];
Rip rip[1]; /* the rest of the packet consists of routes */
};
enum
{
Maxroutes= (Maxpacket-4)/sizeof(Ripmsg),
};
/*
* internal route info
*/
enum
{
Nroute= 2048, /* this has to be smaller than what /ip has */
Nhash= 256, /* routing hash buckets */
Nifc= 16,
};
typedef struct Route Route;
struct Route
{
Route *next;
uchar dest[Pasize];
uchar mask[Pasize];
uchar gate[Pasize];
int metric;
int inuse;
long time;
};
struct {
Route route[Nroute];
Route *hash[Nhash];
int nroute;
Route def; /* default route (immutable by us) */
} ralloc;
typedef struct Ifc Ifc;
struct Ifc
{
int bcast;
uchar addr[Pasize]; /* my address */
uchar mask[Pasize]; /* subnet mask */
uchar net[Pasize]; /* subnet */
uchar *cmask; /* class mask */
uchar cnet[Pasize]; /* class net */
};
struct {
Ifc ifc[Nifc];
int nifc;
} ialloc;
/*
* specific networks to broadcast on
*/
typedef struct Bnet Bnet;
struct Bnet
{
Bnet *next;
uchar addr[Pasize];
};
Bnet *bnets;
int ripfd;
long now;
int debug;
int readonly;
char routefile[256];
char netdir[256];
int openport(void);
void readroutes(void);
void readifcs(void);
void considerroute(Route*);
void installroute(Route*);
void removeroute(Route*);
uchar *getmask(uchar*);
void broadcast(void);
void timeoutroutes(void);
void
fatal(int syserr, char *fmt, ...)
{
char buf[ERRMAX], sysbuf[ERRMAX];
va_list arg;
va_start(arg, fmt);
vseprint(buf, buf+sizeof(buf), fmt, arg);
va_end(arg);
if(syserr) {
errstr(sysbuf, sizeof sysbuf);
fprint(2, "routed: %s: %s\n", buf, sysbuf);
}
else
fprint(2, "routed: %s\n", buf);
exits(buf);
}
ulong
v4parseipmask(uchar *ip, char *p)
{
ulong x;
uchar v6ip[IPaddrlen];
x = parseipmask(v6ip, p);
memmove(ip, v6ip+IPv4off, 4);
return x;
}
uchar*
v4defmask(uchar *ip)
{
uchar v6ip[IPaddrlen];
v4tov6(v6ip, ip);
ip = defmask(v6ip);
return ip+IPv4off;
}
void
v4maskip(uchar *from, uchar *mask, uchar *to)
{
int i;
for(i = 0; i < Pasize; i++)
*to++ = *from++ & *mask++;
}
void
v6tov4mask(uchar *v4, uchar *v6)
{
memmove(v4, v6+IPv4off, 4);
}
#define equivip(a, b) (memcmp((a), (b), Pasize) == 0)
void
ding(void *u, char *msg)
{
USED(u);
if(strstr(msg, "alarm"))
noted(NCONT);
noted(NDFLT);
}
void
usage(void)
{
fprint(2, "usage: %s [-bnd] [-x netmtpt]\n", argv0);
exits("usage");
}
void
main(int argc, char *argv[])
{
int dobroadcast, i, n;
long diff;
char *p;
char buf[2*1024];
uchar raddr[Pasize];
Bnet *bn, **l;
Udphdr *up;
Rip *r;
Ripmsg *m;
Route route;
static long btime;
setnetmtpt(netdir, sizeof(netdir), nil);
dobroadcast = 0;
ARGBEGIN{
case 'b':
dobroadcast++;
break;
case 'd':
debug++;
break;
case 'n':
readonly++;
break;
case 'x':
p = ARGF();
if(p == nil)
usage();
setnetmtpt(netdir, sizeof(netdir), p);
break;
default:
usage();
}ARGEND
/* specific broadcast nets */
l = &bnets;
while(argc > 0){
bn = (Bnet*)malloc(sizeof(Bnet));
if(bn == 0)
fatal(1, "out of mem");
v4parseip(bn->addr, *argv);
*l = bn;
l = &bn->next;
argc--;
argv++;
dobroadcast++;
}
/* command returns */
if(!debug)
switch(rfork(RFNOTEG|RFPROC|RFFDG|RFNOWAIT)) {
case -1:
fatal(1, "fork");
case 0:
break;
default:
exits(0);
}
fmtinstall('E', eipfmt);
fmtinstall('V', eipfmt);
snprint(routefile, sizeof(routefile), "%s/iproute", netdir);
snprint(buf, sizeof(buf), "%s/iproute", netdir);
now = time(0);
readifcs();
readroutes();
notify(ding);
ripfd = openport();
for(;;) {
diff = btime - time(0);
if(diff <= 0){
if(dobroadcast)
broadcast();
timeoutroutes();
btime = time(0) + 2*60;
diff = 2*60;
}
alarm(diff*1000);
n = read(ripfd, buf, sizeof(buf));
alarm(0);
if(n <= 0)
continue;
n = (n - Udphdrsize - 4) / sizeof(Rip);
if(n <= 0)
continue;
up = (Udphdr*)buf;
m = (Ripmsg*)(buf+Udphdrsize);
if(m->type != Response || m->vers != Version)
continue;
v6tov4(raddr, up->raddr);
/* ignore our own messages */
for(i = 0; i < ialloc.nifc; i++)
if(equivip(ialloc.ifc[i].addr, raddr))
continue;
now = time(0);
for(r = m->rip; r < &m->rip[n]; r++){
memmove(route.gate, raddr, Pasize);
memmove(route.mask, getmask(r->addr), Pasize);
v4maskip(r->addr, route.mask, route.dest);
route.metric = nhgetl(r->metric) + 1;
if(route.metric < 1)
continue;
considerroute(&route);
}
}
/* not reached */
}
int
openport(void)
{
int ripctl, rip;
char data[128], devdir[40];
snprint(data, sizeof(data), "%s/udp!*!rip", netdir);
ripctl = announce(data, devdir);
if(ripctl < 0)
fatal(1, "can't announce");
if(fprint(ripctl, "headers") < 0)
fatal(1, "can't set header mode");
sprint(data, "%s/data", devdir);
rip = open(data, ORDWR);
if(rip < 0)
fatal(1, "open udp data");
return rip;
}
Ipifc *ifcs;
void
readifcs(void)
{
Ipifc *ifc;
Iplifc *lifc;
Ifc *ip;
Bnet *bn;
Route route;
int i;
ifcs = readipifc(netdir, ifcs, -1);
i = 0;
for(ifc = ifcs; ifc != nil; ifc = ifc->next){
for(lifc = ifc->lifc; lifc != nil && i < Nifc; lifc = lifc->next){
// ignore any interfaces that aren't v4
if(memcmp(lifc->ip, v4prefix, IPaddrlen-IPv4addrlen) != 0)
continue;
ip = &ialloc.ifc[i++];
v6tov4(ip->addr, lifc->ip);
v6tov4mask(ip->mask, lifc->mask);
v6tov4(ip->net, lifc->net);
ip->cmask = v4defmask(ip->net);
v4maskip(ip->net, ip->cmask, ip->cnet);
ip->bcast = 0;
/* add as a route */
memmove(route.mask, ip->mask, Pasize);
memmove(route.dest, ip->net, Pasize);
memset(route.gate, 0, Pasize);
route.metric = 0;
considerroute(&route);
/* mark as broadcast */
if(bnets == 0)
ip->bcast = 1;
else for(bn = bnets; bn; bn = bn->next)
if(memcmp(bn->addr, ip->net, Pasize) == 0){
ip->bcast = 1;
break;
}
}
}
ialloc.nifc = i;
}
void
readroutes(void)
{
int n;
char *p;
Biobuf *b;
char *f[6];
Route route;
b = Bopen(routefile, OREAD);
if(b == 0)
return;
while(p = Brdline(b, '\n')){
p[Blinelen(b)-1] = 0;
n = getfields(p, f, 6, 1, " \t");
if(n < 5)
continue;
v4parseip(route.dest, f[0]);
v4parseipmask(route.mask, f[1]);
v4parseip(route.gate, f[2]);
route.metric = Infinity;
if(equivip(route.dest, ralloc.def.dest)
&& equivip(route.mask, ralloc.def.mask))
memmove(ralloc.def.gate, route.gate, Pasize);
else if(!equivip(route.dest, route.gate) && strchr(f[3], 'i') == 0)
considerroute(&route);
}
Bterm(b);
}
/*
* route's hashed by net, not subnet
*/
ulong
rhash(uchar *d)
{
ulong h;
uchar net[Pasize];
v4maskip(d, v4defmask(d), net);
h = net[0] + net[1] + net[2];
return h % Nhash;
}
/*
* consider installing a route. Do so only if it is better than what
* we have.
*/
void
considerroute(Route *r)
{
ulong h;
Route *hp;
if(debug)
fprint(2, "consider %16V & %16V -> %16V %d\n", r->dest, r->mask, r->gate, r->metric);
r->next = 0;
r->time = now;
r->inuse = 1;
/* don't allow our default route to be highjacked */
if(equivip(r->dest, ralloc.def.dest) || equivip(r->mask, ralloc.def.mask))
return;
h = rhash(r->dest);
for(hp = ralloc.hash[h]; hp; hp = hp->next){
if(equivip(hp->dest, r->dest)){
/*
* found a match, replace if better (or much newer)
*/
if(r->metric < hp->metric || now-hp->time > 5*60){
removeroute(hp);
memmove(hp->mask, r->mask, Pasize);
memmove(hp->gate, r->gate, Pasize);
hp->metric = r->metric;
installroute(hp);
}
if(equivip(hp->gate, r->gate))
hp->time = now;
return;
}
}
/*
* no match, look for space
*/
for(hp = ralloc.route; hp < &ralloc.route[Nroute]; hp++)
if(hp->inuse == 0)
break;
if(hp == 0)
fatal(0, "no more routes");
memmove(hp, r, sizeof(Route));
hp->next = ralloc.hash[h];
ralloc.hash[h] = hp;
installroute(hp);
}
void
removeroute(Route *r)
{
int fd;
fd = open(routefile, ORDWR);
if(fd < 0){
fprint(2, "can't open oproute\n");
return;
}
if(!readonly)
fprint(fd, "delete %V", r->dest);
if(debug)
fprint(2, "removeroute %V\n", r->dest);
close(fd);
}
/*
* pass a route to the kernel or /ip. Don't bother if it is just the default
* gateway.
*/
void
installroute(Route *r)
{
int fd;
ulong h;
Route *hp;
uchar net[Pasize];
/*
* don't install routes whose gateway is 00000000
*/
if(equivip(r->gate, ralloc.def.dest))
return;
fd = open(routefile, ORDWR);
if(fd < 0){
fprint(2, "can't open oproute\n");
return;
}
h = rhash(r->dest);
/*
* if the gateway is the same as the default gateway
* we may be able to avoid a entry in the kernel
*/
if(equivip(r->gate, ralloc.def.gate)){
/*
* look for a less specific match
*/
for(hp = ralloc.hash[h]; hp; hp = hp->next){
v4maskip(hp->mask, r->dest, net);
if(equivip(net, hp->dest) && !equivip(hp->gate, ralloc.def.gate))
break;
}
/*
* if no less specific match, just use the default
*/
if(hp == 0){
if(!readonly)
fprint(fd, "delete %V", r->dest);
if(debug)
fprint(2, "delete %V\n", r->dest);
close(fd);
return;
}
}
if(!readonly)
fprint(fd, "add %V %V %V", r->dest, r->mask, r->gate);
if(debug)
fprint(2, "add %V & %V -> %V\n", r->dest, r->mask, r->gate);
close(fd);
}
/*
* return true of dest is on net
*/
int
onnet(uchar *dest, uchar *net, uchar *netmask)
{
uchar dnet[Pasize];
v4maskip(dest, netmask, dnet);
return equivip(dnet, net);
}
/*
* figure out what mask to use, if we have a direct connected network
* with the same class net use its subnet mask.
*/
uchar*
getmask(uchar *dest)
{
int i;
Ifc *ip;
ulong mask, nmask;
uchar *m;
m = 0;
mask = 0xffffffff;
for(i = 0; i < ialloc.nifc; i++){
ip = &ialloc.ifc[i];
if(onnet(dest, ip->cnet, ip->cmask)){
nmask = nhgetl(ip->mask);
if(nmask < mask){
mask = nmask;
m = ip->mask;
}
}
}
if(m == 0)
m = v4defmask(dest);
return m;
}
/*
* broadcast routes onto all networks
*/
void
sendto(Ifc *ip)
{
int h, n;
uchar raddr[Pasize], mbuf[Udphdrsize+512];
Ripmsg *m;
Route *r;
Udphdr *u;
u = (Udphdr*)mbuf;
for(n = 0; n < Pasize; n++)
raddr[n] = ip->net[n] | ~(ip->mask[n]);
v4tov6(u->raddr, raddr);
hnputs(u->rport, 520);
m = (Ripmsg*)(mbuf+Udphdrsize);
m->type = Response;
m->vers = Version;
if(debug)
fprint(2, "to %V\n", u->raddr);
n = 0;
for(h = 0; h < Nhash; h++){
for(r = ralloc.hash[h]; r; r = r->next){
/*
* don't send any route back to the net
* it came from
*/
if(onnet(r->gate, ip->net, ip->mask))
continue;
/*
* don't tell a network about itself
*/
if(equivip(r->dest, ip->net))
continue;
/*
* don't tell nets about other net's subnets
*/
if(!equivip(r->mask, v4defmask(r->dest))
&& !equivip(ip->cmask, v4defmask(r->dest)))
continue;
memset(&m->rip[n], 0, sizeof(m->rip[n]));
memmove(m->rip[n].addr, r->dest, Pasize);
if(r->metric < 1)
hnputl(m->rip[n].metric, 1);
else
hnputl(m->rip[n].metric, r->metric);
hnputs(m->rip[n].family, AF_INET);
if(debug)
fprint(2, " %16V & %16V -> %16V %2d\n",
r->dest, r->mask, r->gate, r->metric);
if(++n == Maxroutes && !readonly){
write(ripfd, mbuf, Udphdrsize + 4 + n*20);
n = 0;
}
}
}
if(n && !readonly)
write(ripfd, mbuf, Udphdrsize+4+n*20);
}
void
broadcast(void)
{
int i;
readifcs();
for(i = 0; i < ialloc.nifc; i++){
if(ialloc.ifc[i].bcast)
sendto(&ialloc.ifc[i]);
}
}
/*
* timeout any routes that haven't been refreshed and aren't wired
*/
void
timeoutroutes(void)
{
int h;
long now;
Route *r, **l;
now = time(0);
for(h = 0; h < Nhash; h++){
l = &ralloc.hash[h];
for(r = *l; r; r = *l){
if(r->metric < Infinity && now - r->time > 10*60){
removeroute(r);
r->inuse = 0;
*l = r->next;
continue;
}
l = &r->next;
}
}
}
|
