bgp-ipma.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 2002-2011 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <[email protected]>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * bgp ipma method
 *
 * Glenn Fowler
 * AT&T Research
 */

#include "bgplib.h"

typedef struct Ipmastate_s
{
	Bgproute_t		route;
	Bgpnum_t		paddr;
	Bgpnum_t		pbits;
} Ipmastate_t;

static const char	magic1[] = "Internet Performance Measurement and Analysis";
static const char	magic2[] = "AS Path";

/*
 * ipma identf
 */

static int
ipmaident(Dssfile_t* file, void* buf, size_t n, Dssdisc_t* disc)
{
	register char*	s;
	register char*	e;
	register char*	e1;
	register char*	e2;

	s = (char*)buf;
	e = s + n;
	e1 = e - sizeof(magic1) + 1;
	e2 = e - sizeof(magic2) + 1;
	e = (e1 > e2) ? e1 : e2;
	while (s < e)
	{
		if (s < e1 && strneq(s, magic1, sizeof(magic1) - 1) || s < e2 && strneq(s, magic2, sizeof(magic2) - 1))
			return 1;
		s++;
	}
	return 0;
}

/*
 * ipma openf
 */

static int
ipmaopen(Dssfile_t* file, Dssdisc_t* disc)
{
	register char*	s;
	register char*	e;
	register char*	e1;
	register char*	e2;
	register int	c;
	register int	q;

	if (!(file->data = (void*)vmnewof(file->dss->vm, 0, Ipmastate_t, 1, 0)))
	{
		if (disc->errorf)
			(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
		return -1;
	}
	if (file->flags & DSS_FILE_READ)
	{
		while (s = sfgetr(file->io, '\n', 0))
		{
			e = s + sfvalue(file->io);
			e1 = e - sizeof(magic1) + 1;
			e2 = e - sizeof(magic2) + 1;
			e = (e1 > e2) ? e1 : e2;
			while (s < e)
			{
				if (s < e1 && strneq(s, magic1, sizeof(magic1) - 1) || s < e2 && strneq(s, magic2, sizeof(magic2) - 1))
					break;
				s++;
			}
			if (s < e)
				break;
		}
		q = 0;
		for (;;)
		{
			switch (c = sfgetc(file->io))
			{
			case EOF:
				break;
			case '\n':
				q = 0;
				continue;
			case '0': case '1': case '2': case '3': case '4':
			case '5': case '6': case '7': case '8': case '9':
				if (q == 0)
				{
					sfungetc(file->io, c);
					break;
				}
				continue;
			case '<':
				if (q == 0 || q == '&')
					q = c;
				continue;
			case '>':
				if (q == '<' || q == '&')
					q = 0;
				else if (q == 0)
					q = '#';
				continue;
			case '&':
				if (q == 0)
					q = c;
				continue;
			default:
				if (q == 0)
				{
					if (!isspace(c))
						q = '#';
				}
				else if (q == '&')
				{
					if (!isalnum(c) && c != '#')
						q = 0;
				}
				continue;
			}
			break;
		}
		((Ipmastate_t*)file->data)->route.attr = BGP_best;
		((Ipmastate_t*)file->data)->route.type = BGP_TYPE_table_dump;
	}
	else if (!(file->flags & DSS_FILE_APPEND))
		sfprintf(file->io, "%s\n\n", magic1);
	return 0;
}

/*
 * skip over html
 * number==1 skips to next number
 */

static char*
skip(register char* s, register char* e, int number)
{
	register char*	b;
	register char*	t;

	do
	{
		b = s;
		while (s < e && isspace(*s))
			s++;
		if (*s == '<')
		{
			while (s < e && *s++ != '>');
			while (s < e && isspace(*s))
				s++;
		}
		if (*s == '&')
		{
			if (*++s == '#' && s < e)
				s++;
			while (s < e && isalnum(*s))
				s++;
		}
		if (s < e && number)
		{
			if ((isdigit(*s) || (e - s) > 5 && strneq(s, "local", 5)) && (isspace(*(s - 1)) || *(s - 1) == '>' || *(s - 1) == ';' || *(s - 1) == '='))
			{
				if (!isdigit(*s))
					break;
				for (t = s; t < e && isdigit(*t); t++);
				if (t >= e || isspace(*t) || *t == '<' || *t == '&')
					break;
				s = t;
			}
			if (*s == '=' && (e - s) > 1 && isdigit(*(s + 1)))
			{
				s++;
				break;
			}
			while (s < e && !isspace(*s) && *s != '<' && *s != '&' && *s != '=')
				s++;
		}
	} while (s != b);
	return s;
}

/*
 * ipma readf
 */

static int
ipmaread(register Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc)
{
	register Ipmastate_t*	state = (Ipmastate_t*)file->data;
	register Bgproute_t*	rp;
	register char*		s;
	register int		i;
	int			c;
	int			n;
	int			o;
	char*			e;
	char*			p;
	Bgpasn_t*		ap;

	rp = &state->route;
	for (;;)
	{
		if (!(s = sfgetr(file->io, '\n', 0)))
			return 0;
		e = s + sfvalue(file->io);
		s = skip(s, e, 0);
		if (s >= e)
			continue;
		if (isdigit(*s))
		{
			if (strtoip4(s, &p, &rp->addr.v4, &rp->bits))
				break;
			s = skip(p, e, 1);
			if (s >= e || !isalnum(*s))
			{
				if ((c = sfgetc(file->io)) == EOF)
					break;
				if (!isspace(c))
				{
					sfungetc(file->io, c);
					s = e = "";
				}
				else if (!(s = sfgetr(file->io, '\n', 0)))
					return 0;
				else
				{
					e = s + sfvalue(file->io);
					s = skip(s, e, 1);
				}
			}
		}
		else if ((e - s) > 6 && (strneq(s, "Prefix", 6) || strneq(s, "Networ", 6) || strneq(s, "Receiv", 6) || strneq(s, "Advert", 6)))
			continue;
		else
			s = skip(s, e, 1);
		if (s >= e)
			break;
		if (*(s - 1) == '=')
		{
			if (strtoip4(s, &p, &rp->hop.v4, NiL))
				break;
			s = skip(s, e, 1);
		}
		i = 0;
		n = elementsof(rp->data) / sizeof(Bgpasn_t);
		ap = (Bgpasn_t*)rp->data;
		rp->path.offset = i;
		o = 0;
		p = s;
		do
		{
			for (s = p; *s == ' ' || *s == '\t' || *s == ','; s++);
			if (*s == '{')
			{
				if (i >= (n - 2))
				{
					if (disc->errorf && !(file->dss->flags & DSS_QUIET))
						(*disc->errorf)(NiL, disc, 1, "%s: AS path too long -- truncated to %d", file->format->name, n);
					break;
				}
				ap[i++] = BGP_SET16;
				o = i++;
				p = s + 1;
			}
			else if (*s == '}')
				s++;
			else if (!isdigit(*s))
				break;
			else
			{
				if (i >= n)
				{
					if (disc->errorf && !(file->dss->flags & DSS_QUIET))
						(*disc->errorf)(NiL, disc, 1, "%s: AS path too long -- truncated to %d", file->format->name, n);
					break;
				}
				if ((ap[i++] = strtol(s, &p, 10)) == BGP_SET16)
				{
					if (i >= (n - 2))
					{
						if (disc->errorf && !(file->dss->flags & DSS_QUIET))
							(*disc->errorf)(NiL, disc, 1, "%s: AS path too long -- truncated to %d", file->format->name, n);
						break;
					}
					ap[i++] = 0;
					ap[i++] = BGP_SET16;
				}
			}
		} while (p > s);
		rp->path.size = i;
		if (o)
			ap[o] = i - o;
		if (s[0] == 'E' || s[0] == 'e')
			rp->origin = BGP_ORIGIN_egp;
		else if ((s[0] == 'I' || s[0] == 'i') && (s[1] == 'G' || s[1] == 'g'))
			rp->origin = BGP_ORIGIN_igp;
		else
			rp->origin = BGP_ORIGIN_incomplete;
		record->data = rp;
		record->size = rp->size = (char*)(rp->data + i) - (char*)rp;
		return 1;
	}
	return 0;
}

/*
 * ipma writef
 */

static int
ipmawrite(Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc)
{
	register Ipmastate_t*	state = (Ipmastate_t*)file->data;
	register Bgproute_t*	rp = (Bgproute_t*)record->data;
	register Sfio_t*	io = file->io;
	register int		i;
	register int		j;
	register int		k;
	Bgpasn_t*		ap;

	if (rp->addr.v4 != state->paddr || rp->bits != state->pbits)
	{
		state->paddr = rp->addr.v4;
		state->pbits = rp->bits;
		sfprintf(io, "%s\n", fmtip4(rp->addr.v4, rp->bits));
	}
	sfprintf(io, "\tN=%s", fmtip4(rp->hop.v4, -1));
	if (j = rp->path.size)
	{
		ap = BGPPATH(rp);
		for (i = 0; i < j; i++)
			if (ap[i] == BGP_SET16)
			{
				if (k = ap[++i])
				{
					k += i - 1;
					sfprintf(io, " {%u", ap[++i]);
					while (i < k)
						sfprintf(io, ",%u", ap[++i]);
					sfputc(io, '}');
				}
				else
					sfprintf(io, " %u", ap[++i]);
			}
			else
				sfprintf(io, " %u", ap[i]);
	}
	switch (rp->origin)
	{
	case BGP_ORIGIN_egp:
		sfprintf(io, " EGP");
		break;
	case BGP_ORIGIN_igp:
		sfprintf(io, " IGP");
		break;
	default:
		sfprintf(io, " Incomplete");
		break;
	}
	if (sfputc(io, '\n') == EOF)
	{
		if (disc->errorf)
			(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: write error", file->format->name);
		return -1;
	}
	return 0;
}

/*
 * ipma closef
 */

static int
ipmaclose(Dssfile_t* file, Dssdisc_t* disc)
{
	if (!file->data)
		return -1;
	vmfree(file->dss->vm, file->data);
	return 0;
}

Dssformat_t bgp_ipma_format =
{
	"ipma",
	"ipma router dump format (2009-03-15) [http://www.merit.edu/~ipma/routing_table]",
	CXH,
	ipmaident,
	ipmaopen,
	ipmaread,
	ipmawrite,
	0,
	ipmaclose,
	0,
	0,
	bgp_ipma_next
};