188 lines
3.5 KiB
C
188 lines
3.5 KiB
C
/*
|
|
* BIRD -- Linux Routing Table Scanning
|
|
*
|
|
* (c) 1998 Martin Mares <mj@ucw.cz>
|
|
*
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <net/route.h>
|
|
|
|
#define LOCAL_DEBUG
|
|
|
|
#include "nest/bird.h"
|
|
#include "nest/route.h"
|
|
#include "nest/protocol.h"
|
|
#include "nest/iface.h"
|
|
#include "lib/timer.h"
|
|
#include "lib/unix.h"
|
|
#include "lib/krt.h"
|
|
|
|
#define SCANOPT struct krt_scan_params *p = &x->scanopt
|
|
|
|
static int krt_scan_fd = -1;
|
|
|
|
static void
|
|
krt_parse_entry(byte *e)
|
|
{
|
|
u32 dest0, gw0, mask0;
|
|
ip_addr dest, gw, mask;
|
|
unsigned int flags;
|
|
int masklen;
|
|
net *net;
|
|
byte *iface = e;
|
|
|
|
if (sscanf(e, "%*s\t%x\t%x\t%x\t%*d\t%*d\t%*d\t%x\t", &dest0, &gw0, &flags, &mask0) != 4)
|
|
{
|
|
log(L_ERR "krt read: unable to parse `%s'", e);
|
|
return;
|
|
}
|
|
while (*e != '\t')
|
|
e++;
|
|
*e = 0;
|
|
|
|
dest = ipa_from_u32(dest0);
|
|
ipa_ntoh(dest);
|
|
gw = ipa_from_u32(gw0);
|
|
ipa_ntoh(gw);
|
|
mask = ipa_from_u32(mask0);
|
|
ipa_ntoh(mask);
|
|
if ((masklen = ipa_mklen(mask)) < 0)
|
|
{
|
|
log(L_ERR "krt read: invalid netmask %08x", mask0);
|
|
return;
|
|
}
|
|
DBG("Got %I/%d via %I flags %x\n", dest, masklen, gw, flags);
|
|
|
|
if (!(flags & RTF_UP))
|
|
return;
|
|
if (flags & RTF_HOST)
|
|
masklen = 32;
|
|
if (flags & (RTF_DYNAMIC | RTF_MODIFIED)) /* Redirect route */
|
|
{
|
|
log(L_WARN "krt: Ignoring redirect to %I/%d via %I", dest, masklen, gw);
|
|
return;
|
|
}
|
|
net = net_get(&master_table, 0, dest, masklen);
|
|
if (net->routes)
|
|
{
|
|
rte *e = net->routes;
|
|
rta *a = e->attrs;
|
|
int ok;
|
|
switch (a->dest)
|
|
{
|
|
case RTD_ROUTER:
|
|
ok = (flags & RTF_GATEWAY) && ipa_equal(gw, a->gw);
|
|
break;
|
|
case RTD_DEVICE:
|
|
#ifdef CONFIG_AUTO_ROUTES
|
|
ok = 1;
|
|
#else
|
|
ok = !(flags & RTF_GATEWAY) && !strcmp(iface, a->iface->name);
|
|
#endif
|
|
break;
|
|
case RTD_UNREACHABLE:
|
|
ok = flags & RTF_REJECT;
|
|
default:
|
|
ok = 0;
|
|
}
|
|
net->n.flags |= ok ? KRF_SEEN : KRF_UPDATE;
|
|
}
|
|
else
|
|
{
|
|
#ifdef CONFIG_AUTO_ROUTES
|
|
if (!(flags & RTF_GATEWAY)) /* It's a device route */
|
|
return;
|
|
#endif
|
|
net->n.flags |= KRF_UPDATE;
|
|
}
|
|
}
|
|
|
|
static int
|
|
krt_scan_proc(void)
|
|
{
|
|
byte buf[32768];
|
|
int l, seen_hdr;
|
|
|
|
if (krt_scan_fd < 0)
|
|
{
|
|
krt_scan_fd = open("/proc/net/route", O_RDONLY);
|
|
if (krt_scan_fd < 0)
|
|
die("/proc/net/route: %m");
|
|
}
|
|
else if (lseek(krt_scan_fd, 0, SEEK_SET) < 0)
|
|
{
|
|
log(L_ERR "krt seek: %m");
|
|
return 0;
|
|
}
|
|
seen_hdr = 0;
|
|
while ((l = read(krt_scan_fd, buf, sizeof(buf))) > 0)
|
|
{
|
|
byte *z = buf;
|
|
if (l & 127)
|
|
{
|
|
log(L_ERR "krt read: misaligned entry: l=%d", l);
|
|
return 0;
|
|
}
|
|
while (l >= 128)
|
|
{
|
|
if (seen_hdr++)
|
|
krt_parse_entry(z);
|
|
z += 128;
|
|
l -= 128;
|
|
}
|
|
}
|
|
if (l < 0)
|
|
{
|
|
log(L_ERR "krt read: %m");
|
|
return 0;
|
|
}
|
|
DBG("KRT scan done, seen %d lines\n", seen_hdr);
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
krt_scan_fire(timer *t)
|
|
{
|
|
struct krt_proto *x = t->data;
|
|
SCANOPT;
|
|
|
|
DBG("Scanning kernel table...\n");
|
|
if (!krt_scan_proc())
|
|
return;
|
|
}
|
|
|
|
void
|
|
krt_scan_preconfig(struct krt_proto *x)
|
|
{
|
|
SCANOPT;
|
|
|
|
p->recurrence = 10; /* FIXME: use reasonable default value */
|
|
}
|
|
|
|
void
|
|
krt_scan_start(struct krt_proto *x)
|
|
{
|
|
SCANOPT;
|
|
timer *t = tm_new(x->p.pool);
|
|
|
|
p->timer = t;
|
|
t->hook = krt_scan_fire;
|
|
t->data = x;
|
|
t->recurrent = p->recurrence;
|
|
krt_scan_fire(t);
|
|
if (t->recurrent)
|
|
tm_start(t, t->recurrent);
|
|
}
|
|
|
|
void
|
|
krt_scan_shutdown(struct krt_proto *x)
|
|
{
|
|
SCANOPT;
|
|
|
|
tm_stop(p->timer);
|
|
}
|