xref: /src/usr.sbin/ldpd/mpls_routes.c

/* $NetBSD: mpls_routes.c,v 1.20 2013/07/24 09:05:53 kefren Exp $ */

/*-
 * Copyright (c) 2010 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Mihai Chelaru <kefren (at) NetBSD.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/param.h>
#include <sys/sysctl.h>
#include <net/if.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netmpls/mpls.h>

#include <arpa/inet.h>

#include <assert.h>
#include <stdlib.h>
#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ldp.h"
#include "ldp_errors.h"
#include "ldp_peer.h"
#include "mpls_interface.h"
#include "tlv_stack.h"
#include "label.h"
#include "mpls_routes.h"
#include "socketops.h"

extern int      route_socket;
int             rt_seq = 200;
int		dont_catch = 0;
extern int	no_default_route;
extern int	debug_f, warn_f;

struct rt_msg   replay_rt[REPLAY_MAX];
int             replay_index = 0;

#if 0
static int read_route_socket(char *, int);
#endif
void	mask_addr(union sockunion *);
int	compare_sockunion(const union sockunion *, const union sockunion *);
static int check_if_addr_updown(struct rt_msg *, uint);

extern struct sockaddr mplssockaddr;

/* Many lines inspired or shamelessly stolen from sbin/route/route.c */

#define NEXTADDR(u) \
	do { l = RT_ROUNDUP(u->sa.sa_len); memcpy(cp, u, l); cp += l;} while(0);
#define NEXTADDR2(u) \
	do { l = RT_ROUNDUP(u.sa_len); memcpy(cp, &u, l); cp += l; } while(0);

#define CHECK_LEN(sunion) \
	if (size_cp + sunion->sa.sa_len > rlen) \
		return LDP_E_ROUTE_ERROR; \
	else \
		size_cp += sunion->sa.sa_len;

#define CHECK_MINSA \
	if (size_cp + sizeof(sa_family_t) + sizeof(uint8_t) > rlen) \
		return LDP_E_ROUTE_ERROR;

#define GETNEXT(dstunion, origunion) \
	do { \
	CHECK_MINSA \
	dstunion = (union sockunion *) ((char *) (origunion)  + \
	RT_ROUNDUP((origunion)->sa.sa_len)); \
	CHECK_LEN(dstunion) \
	} while (0);

#if 0
static int
read_route_socket(char *s, int max)
{
	int             rv, to_read;
	struct rt_msghdr *rhdr;
	struct pollfd pfd;

	pfd.fd = route_socket;
	pfd.events = POLLRDNORM;
	pfd.revents = 0;

	errno = 0;

	do {
		rv = poll(&pfd, 1, 100);
	} while (rv == -1 && errno == EINTR);

	if (rv < 1) {
		if (rv == 0) {
			fatalp("read_route_socket: poll timeout\n");
		} else
			fatalp("read_route_socket: poll: %s",
			    strerror(errno));
		return 0;
	}

	do {
		rv = recv(route_socket, s, max, MSG_PEEK);
	} while(rv == -1 && errno == EINTR);

	if (rv < 1) {
		debugp("read_route_socket: recv error\n");
		return 0;
	}
	if (rv > max) {
		rv = max;
		debugp("read_route_socket: rv > max\n");
	}

	rhdr = (struct rt_msghdr *)s;
	to_read = rhdr->rtm_msglen > max ? max : rhdr->rtm_msglen;
	rv = 0;

	do {
		rv += recv(route_socket, s, to_read - rv, 0);
	} while (rv != to_read);

	return rv;
}
#endif	/* 0 */

/* Recalculate length */
void
mask_addr(union sockunion * su)
{
/*
	int             olen = su->sa.sa_len;
	char           *cp1 = olen + (char *) su;

	for (su->sa.sa_len = 0; cp1 > (char *) su;)
		if (*--cp1 != 0) {
			su->sa.sa_len = 1 + cp1 - (char *) su;
			break;
		}
*/
/* Let's use INET only version for the moment */
su->sa.sa_len = 4 + from_union_to_cidr(su) / 8 +
    ( from_union_to_cidr(su) % 8 ? 1 : 0 );
}

/* creates a sockunion from an IP address */
union sockunion *
make_inet_union(const char *s)
{
	union sockunion *so_inet;

	so_inet = calloc(1, sizeof(*so_inet));

	if (!so_inet) {
		fatalp("make_inet_union: malloc problem\n");
		return NULL;
	}

	so_inet->sin.sin_len = sizeof(struct sockaddr_in);
	so_inet->sin.sin_family = AF_INET;
	inet_aton(s, &so_inet->sin.sin_addr);

	return so_inet;
}

/* creates a sockunion from a label */
union sockunion *
make_mpls_union(uint32_t label)
{
	union sockunion *so_mpls;

	so_mpls = calloc(1, sizeof(*so_mpls));

	if (!so_mpls) {
		fatalp("make_mpls_union: malloc problem\n");
		return NULL;
	}

	so_mpls->smpls.smpls_len = sizeof(struct sockaddr_mpls);
	so_mpls->smpls.smpls_family = AF_MPLS;
	so_mpls->smpls.smpls_addr.shim.label = label;

	so_mpls->smpls.smpls_addr.s_addr =
		htonl(so_mpls->smpls.smpls_addr.s_addr);

	return so_mpls;
}

int
compare_sockunion(const union sockunion * __restrict a,
    const union sockunion * __restrict b)
{
	if (a->sa.sa_len != b->sa.sa_len)
		return 1;
	return memcmp(a, b, a->sa.sa_len);
}

union sockunion *
from_cidr_to_union(uint8_t prefixlen)
{
	union sockunion *u;
	uint32_t m = 0xFFFFFFFF;

	u = calloc(1, sizeof(*u));

	if (!u) {
		fatalp("from_cidr_to_union: malloc problem\n");
		return NULL;
	}
	u->sin.sin_len = sizeof(struct sockaddr_in);
	u->sin.sin_family = AF_INET;
	if (prefixlen != 0) {
		m = (m >> (32 - prefixlen) ) << (32 - prefixlen);
		m = ntohl(m);
		u->sin.sin_addr.s_addr = m;
	}
	return u;
}

uint8_t
from_mask_to_cidr(const char *mask)
{
	struct in_addr addr;
	uint8_t plen = 0;

	if (inet_aton(mask, &addr) != 0)
		for (; addr.s_addr; plen++)
			addr.s_addr &= addr.s_addr - 1;
	return plen;
}

uint8_t
from_union_to_cidr(const union sockunion *so_pref)
{
	const struct sockaddr_in *sin = (const struct sockaddr_in*) so_pref;
	uint32_t a;
	uint8_t r;

	a = ntohl(sin->sin_addr.s_addr);
	for (r=0; a ; a = a << 1, r++);

	return r;
}

/* returns in mask the netmask created from CIDR prefixlen */
void
from_cidr_to_mask(uint8_t prefixlen, char *mask)
{
	uint32_t a = 0;
	uint8_t plen = prefixlen < 32 ? prefixlen : 32;

	if (plen != 0)
		a = (0xffffffff >> (32 - plen)) << (32 - plen);
	snprintf(mask, 16, "%d.%d.%d.%d", a >> 24, (a << 8) >> 24,
	    (a << 16) >> 24, (a << 24) >> 24);
}

/* From src/sbin/route/route.c */
static const char *
route_strerror(int error)
{

	switch (error) {
	case ESRCH:
		return "not in table";
	case EBUSY:
		return "entry in use";
	case ENOBUFS:
		return "routing table overflow";
	default:
		return strerror(error);
	}
}


/* Adds a route. Or changes it. */
int
add_route(union sockunion *so_dest, union sockunion *so_prefix,
    union sockunion *so_gate, union sockunion *so_ifa,
    union sockunion *so_tag, int fr, int optype)
{
	int             l, rlen, rv = LDP_E_OK;
	struct rt_msg   rm;
	char           *cp;

	if(dont_catch)
		return LDP_E_OK;

	memset(&rm, 0, sizeof(rm));
	cp = rm.m_space;

	rm.m_rtm.rtm_type = (optype == RTM_READD) ? RTM_ADD : optype;
	rm.m_rtm.rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC;

	rm.m_rtm.rtm_version = RTM_VERSION;
	rm.m_rtm.rtm_seq = ++rt_seq;
	rm.m_rtm.rtm_addrs = RTA_DST;
	if (so_gate)
		rm.m_rtm.rtm_addrs |= RTA_GATEWAY;

	assert(so_dest);

	/* Order is: destination, gateway, netmask, genmask, ifp, ifa, tag */
	NEXTADDR(so_dest);
	if (so_gate)
		NEXTADDR(so_gate);

	if (so_prefix) {
		union sockunion *so_prefix_temp = so_prefix;

		if (fr != FREESO) {
			/* don't modify so_prefix */
			so_prefix_temp = calloc(1, so_prefix->sa.sa_len);
			if (so_prefix_temp == NULL)
				return LDP_E_MEMORY;
			memcpy(so_prefix_temp, so_prefix, so_prefix->sa.sa_len);
		}
		mask_addr(so_prefix_temp);
		NEXTADDR(so_prefix_temp);
		if (fr != FREESO)
			free(so_prefix_temp);
		/* XXX: looks like nobody cares about this */
		rm.m_rtm.rtm_flags |= RTF_MASK;
		rm.m_rtm.rtm_addrs |= RTA_NETMASK;
	} else
		rm.m_rtm.rtm_flags |= RTF_HOST;

	/* route to mpls interface */
	if (optype != RTM_READD && so_dest->sa.sa_family != AF_MPLS) {
		NEXTADDR2(mplssockaddr);
		rm.m_rtm.rtm_addrs |= RTA_IFP;
	}

	if (so_ifa != NULL) {
		NEXTADDR(so_ifa);
		rm.m_rtm.rtm_addrs |= RTA_IFA;
	}

	if (so_tag) {
		NEXTADDR(so_tag);
		rm.m_rtm.rtm_addrs |= RTA_TAG;
	}

	rm.m_rtm.rtm_msglen = l = cp - (char *) &rm;

	if ((rlen = write(route_socket, (char *) &rm, l)) < l) {
		warnp("Error adding a route: %s\n", route_strerror(errno));
		warnp("Destination was: %s\n", satos(&so_dest->sa));
		if (so_prefix)
			warnp("Prefix was: %s\n", satos(&so_prefix->sa));
		if (so_gate)
			warnp("Gateway was: %s\n", satos(&so_gate->sa));
		rv = LDP_E_ROUTE_ERROR;
	}
	if (fr == FREESO) {
		free(so_dest);
		if (so_prefix)
			free(so_prefix);
		if (so_gate)
			free(so_gate);
		if (so_ifa)
			free(so_ifa);
		if (so_tag)
			free(so_tag);
	}

	return rv;
}

/* Deletes a route */
int
delete_route(union sockunion * so_dest, union sockunion * so_pref, int freeso)
{
	int             l, rlen;
	struct rt_msg   rm;
	char           *cp;

	if(dont_catch)
		return LDP_E_OK;

	memset(&rm, 0, sizeof(struct rt_msg));
	cp = rm.m_space;

	rm.m_rtm.rtm_type = RTM_DELETE;
	rm.m_rtm.rtm_version = RTM_VERSION;
	rm.m_rtm.rtm_seq = ++rt_seq;
	if (so_pref)
		rm.m_rtm.rtm_addrs = RTA_DST | RTA_NETMASK;
	else {
		rm.m_rtm.rtm_addrs = RTA_DST;
		rm.m_rtm.rtm_flags |= RTF_HOST;
	}

	/* destination, gateway, netmask, genmask, ifp, ifa */

	NEXTADDR(so_dest);

	if (so_pref) {
		union sockunion *so_pref_temp = so_pref;
		if (freeso != FREESO) {
			/* don't modify the original prefix */
			so_pref_temp = calloc(1, so_pref->sa.sa_len);
			if (so_pref_temp == NULL)
				return LDP_E_MEMORY;
			memcpy(so_pref_temp, so_pref, so_pref->sa.sa_len);
		}
		mask_addr(so_pref_temp);
		NEXTADDR(so_pref_temp);
		if (freeso != FREESO)
			free(so_pref_temp);
	}
	rm.m_rtm.rtm_msglen = l = cp - (char *) &rm;

	if (freeso == FREESO) {
		free(so_dest);
		if (so_pref)
			free(so_pref);
	}
	if ((rlen = write(route_socket, (char *) &rm, l)) < l) {
	    if(so_pref) {
		char spreftmp[INET_ADDRSTRLEN];
		strlcpy(spreftmp, inet_ntoa(so_pref->sin.sin_addr),
		    INET_ADDRSTRLEN);
		warnp("Error deleting route(%s): %s/%s",
		    route_strerror(errno), satos(&so_dest->sa),
		    spreftmp);
	    } else
		warnp("Error deleting route(%s) : %s",
		    route_strerror(errno), satos(&so_dest->sa));
	    return LDP_E_NO_SUCH_ROUTE;
	}
	return LDP_E_OK;
}

#if 0
/*
 * Check for a route and returns it in rg
 * If exact_match is set it compares also the so_dest and so_pref
 * with the returned result
 */
int
get_route(struct rt_msg * rg, const union sockunion * so_dest,
    const union sockunion * so_pref, int exact_match)
{
	int             l, rlen, myseq;
	struct rt_msg   rm;
	char           *cp;
	union sockunion *su;

	memset(&rm, 0, sizeof(struct rt_msg));
	cp = rm.m_space;

	myseq = ++rt_seq;

	rm.m_rtm.rtm_type = RTM_GET;
	rm.m_rtm.rtm_version = RTM_VERSION;
	rm.m_rtm.rtm_seq = myseq;

	/*
	 * rtm_addrs should contain what we provide into this message but
	 * RTA_DST | RTA_IFP trick is allowed in order to find out the
	 * interface.
	 */

	rm.m_rtm.rtm_addrs = RTA_DST | RTA_IFP;

	/*
	 * ORDER of fields is: destination, gateway, netmask, genmask, ifp,
	 * ifa
	 */

	NEXTADDR(so_dest);
	if (so_pref) {
		union sockunion *so_pref_temp = calloc(1, so_pref->sa.sa_len);

		if (so_pref_temp == NULL)
			return LDP_E_MEMORY;
		rm.m_rtm.rtm_addrs |= RTA_NETMASK;
		memcpy(so_pref_temp, so_pref, so_pref->sa.sa_len);
		mask_addr(so_pref_temp);
		NEXTADDR(so_pref_temp);
		free(so_pref_temp);
	}
	rm.m_rtm.rtm_msglen = l = cp - (char *) &rm;

	setsockopt(route_socket, SOL_SOCKET, SO_USELOOPBACK, &(int){1},
	    sizeof(int));
	rlen = write(route_socket, (char *) &rm, l);
	setsockopt(route_socket, SOL_SOCKET, SO_USELOOPBACK, &(int){0},
	    sizeof(int));

	if (rlen < l) {
		debugp("Cannot get a route !(rlen=%d instead of %d) - %s\n",
		    rlen, l, strerror(errno));
		return LDP_E_NO_SUCH_ROUTE;
	} else
		for ( ; ; ) {
			rlen = read_route_socket((char *) rg,
			    sizeof(struct rt_msg));
			if (rlen < 1)
				break;
			/*
			 * We might lose important messages here. WORKAROUND:
			 * For now I just try to save this messages and replay
			 * them later
			 */
			if (rg->m_rtm.rtm_pid == getpid() &&
			    rg->m_rtm.rtm_seq == myseq)
				break;
			/* Fast skip */
			if (rg->m_rtm.rtm_type != RTM_ADD &&
			    rg->m_rtm.rtm_type != RTM_DELETE &&
			    rg->m_rtm.rtm_type != RTM_CHANGE &&
			    rg->m_rtm.rtm_type != RTM_NEWADDR &&
			    rg->m_rtm.rtm_type != RTM_DELADDR)
				continue;
			warnp("Added to replay PID: %d, SEQ: %d\n",
			    rg->m_rtm.rtm_pid, rg->m_rtm.rtm_seq);
			memcpy(&replay_rt[replay_index], rg,
			    sizeof(struct rt_msg));
			if (replay_index < REPLAY_MAX - 1)
				replay_index++;
			else
				fatalp("Replay index is full\n");
		}

	if (rlen <= (int)sizeof(struct rt_msghdr)) {
		debugp("Got only %d bytes, expecting at least %zu\n", rlen,
		    sizeof(struct rt_msghdr));
		return LDP_E_ROUTE_ERROR;
	}

	/* Check if we don't have a less specific route */
	if (exact_match) {
		su = (union sockunion*)(rg->m_space);
		if (compare_sockunion(so_dest, su)) {
			debugp("Dest %s ", satos(&so_dest->sa));
			debugp("not like %s\n", satos(&su->sa));
			return LDP_E_NO_SUCH_ROUTE;
		}
	}

	return LDP_E_OK;
}

#endif	/* 0 */

/* triggered when a route event occurs */
int
check_route(struct rt_msg * rg, uint rlen)
{
	union sockunion *so_dest = NULL, *so_gate = NULL, *so_pref = NULL;
	int             so_pref_allocated = 0;
	int             prefixlen;
	size_t		size_cp;
	struct peer_map *pm;
	struct label	*lab;
	char            dest[50], gate[50], pref[50], oper[50];
	dest[0] = 0;
	gate[0] = 0;
	pref[0] = 0;

	if (rlen < 3 || rg->m_rtm.rtm_version != RTM_VERSION)
		return LDP_E_ROUTE_ERROR;

	if (rg->m_rtm.rtm_type == RTM_NEWADDR ||
	    rg->m_rtm.rtm_type == RTM_DELADDR)
		return check_if_addr_updown(rg, rlen);

	size_cp = sizeof(struct rt_msghdr);
	CHECK_MINSA;

	if (rg->m_rtm.rtm_pid == getpid() ||
	    ((rg->m_rtm.rtm_flags & RTF_DONE) == 0))
		return LDP_E_OK;

	debugp("Check route triggered by PID: %d\n", rg->m_rtm.rtm_pid);

	so_dest = (union sockunion *) rg->m_space;

	if (so_dest->sa.sa_family != AF_INET)
		return LDP_E_OK;/* We don't care about non-IP changes */

	CHECK_LEN(so_dest);

	if (rg->m_rtm.rtm_addrs & RTA_GATEWAY) {
		GETNEXT(so_gate, so_dest);
		if ((so_gate->sa.sa_family != AF_INET) &&
		    (so_gate->sa.sa_family != AF_MPLS))
			return LDP_E_OK;
	}
	if (rg->m_rtm.rtm_addrs & RTA_NETMASK) {
		if (so_gate != NULL) {
			GETNEXT(so_pref, so_gate);
		} else
			GETNEXT(so_pref, so_dest);
	}
	/* Calculate prefixlen */
	if (so_pref)
		prefixlen = from_union_to_cidr(so_pref);
	else {
		prefixlen = 32;
		if ((so_pref = from_cidr_to_union(32)) == NULL)
			return LDP_E_MEMORY;
		so_pref_allocated = 1;
	}

	so_pref->sa.sa_family = AF_INET;
	so_pref->sa.sa_len = sizeof(struct sockaddr_in);

	switch (rg->m_rtm.rtm_type) {
	case RTM_CHANGE:
		lab = label_get(so_dest, so_pref);
		if (lab) {
			send_withdraw_tlv_to_all(&so_dest->sa,
			    prefixlen);
			label_reattach_route(lab, REATT_INET_DEL);
			label_del(lab);
		}
	/* Fallthrough */
	case RTM_ADD:
		/*
		 * Check if the route is connected. If so, bind it to
		 * POP_LABEL and send announce. If not, check if the prefix
		 * was announced by a LDP neighbour and route it there
		 */

		/* First of all check if we already know this one */
		if (label_get(so_dest, so_pref) == NULL) {
			/* Just add an IMPLNULL label */
			if (so_gate == NULL)
				label_add(so_dest, so_pref, NULL,
					MPLS_LABEL_IMPLNULL, NULL, 0,
					rg->m_rtm.rtm_flags & RTF_HOST);
			else {
				pm = ldp_test_mapping(&so_dest->sa,
					 prefixlen, &so_gate->sa);
				if (pm) {
					/* create an implnull label as it
					 * gets rewritten in mpls_add_label */
					lab = label_add(so_dest, so_pref,
					    so_gate, MPLS_LABEL_IMPLNULL,
					    pm->peer, pm->lm->label,
					    rg->m_rtm.rtm_flags & RTF_HOST);
					if (lab != NULL)
						mpls_add_label(lab);
					free(pm);
				} else
					label_add(so_dest, so_pref, so_gate,
					    MPLS_LABEL_IMPLNULL, NULL, 0,
					    rg->m_rtm.rtm_flags & RTF_HOST);
			}
		} else	/* We already know about this prefix */
			fatalp("Binding already there for prefix %s/%d !\n",
			      satos(&so_dest->sa), prefixlen);
		break;
	case RTM_DELETE:
		/*
		 * Send withdraw check the binding, delete the route, delete
		 * the binding
		 */
		lab = label_get(so_dest, so_pref);
		if (!lab)
			break;
		send_withdraw_tlv_to_all(&so_dest->sa, prefixlen);
		/* No readd or delete IP route. Just delete the MPLS route */
		label_reattach_route(lab, REATT_INET_NODEL);
		label_del(lab);
		break;
	}

	if (!debug_f && !warn_f) {
		if(so_pref_allocated)
			free(so_pref);
		return LDP_E_OK;
	}

	/* Rest is just for debug */

	if (so_dest)
		strlcpy(dest, satos(&so_dest->sa), sizeof(dest));
	if (so_pref)
		snprintf(pref, sizeof(pref), "%d", prefixlen);
	if (so_gate)
		strlcpy(gate, satos(&so_gate->sa), sizeof(gate));

	switch (rg->m_rtm.rtm_type) {
	case RTM_ADD:
		strlcpy(oper, "added", 20);
		break;
	case RTM_DELETE:
		strlcpy(oper, "delete", 20);
		break;
	case RTM_GET:
		strlcpy(oper, "get", 20);
		break;
	case RTM_CHANGE:
		strlcpy(oper, "change", 20);
		break;
	case RTM_LOSING:
		strlcpy(oper, "losing", 20);
		break;
	case RTM_REDIRECT:
		strlcpy(oper, "redirect", 20);
		break;
	case RTM_NEWADDR:
		strlcpy(oper, "new address", 20);
		break;
	case RTM_DELADDR:
		strlcpy(oper, "del address", 20);
		break;
	default:
		snprintf(oper, sizeof(oper), "unknown 0x%X operation",
		    rg->m_rtm.rtm_type);
	}

	debugp("[check_route] Route %s: %s / %s -> %s by PID:%d\n", oper, dest,
		pref, gate, rg->m_rtm.rtm_pid);

	if(so_pref_allocated)
		free(so_pref);
	return LDP_E_OK;
}

/*
 * Checks NEWADDR and DELADDR messages and sends announcements accordingly
 */
static int
check_if_addr_updown(struct rt_msg * rg, uint rlen)
{
	union sockunion *ifa, *netmask;
	struct ldp_peer *p;
	struct address_list_tlv al_tlv;
	struct ifa_msghdr *msghdr = (struct ifa_msghdr *)&rg->m_rtm;
	size_t size_cp = sizeof(struct ifa_msghdr);

	if (rlen < sizeof(struct ifa_msghdr) ||
	    (msghdr->ifam_addrs & RTA_NETMASK) == 0 ||
	    (msghdr->ifam_addrs & RTA_IFA) == 0)
		return LDP_E_ROUTE_ERROR;

	CHECK_MINSA;

	/* we should have RTA_NETMASK, RTA_IFP, RTA_IFA and RTA_BRD */
	ifa = netmask = (union sockunion *)(msghdr + 1);
	if (netmask->sa.sa_family != AF_INET)
		return LDP_E_OK;
	CHECK_LEN(netmask);

	if (msghdr->ifam_addrs & RTA_IFP)
		GETNEXT(ifa, ifa);

	GETNEXT(ifa, ifa);

	if (ifa->sa.sa_family != AF_INET ||
	    ntohl(ifa->sin.sin_addr.s_addr) >> 24 == IN_LOOPBACKNET)
		return LDP_E_OK;

	memset(&al_tlv, 0, sizeof(al_tlv));
	al_tlv.type = rg->m_rtm.rtm_type == RTM_NEWADDR ? htons(LDP_ADDRESS) :
	    htons(LDP_ADDRESS_WITHDRAW);
	al_tlv.length = htons(sizeof(al_tlv) - TLV_TYPE_LENGTH);
	al_tlv.messageid = htonl(get_message_id());
	al_tlv.a_type = htons(TLV_ADDRESS_LIST);
	al_tlv.a_length = htons(sizeof(al_tlv.a_af) + sizeof(al_tlv.a_address));
	al_tlv.a_af = htons(LDP_AF_INET);
	memcpy(&al_tlv.a_address, &ifa->sin.sin_addr, sizeof(al_tlv.a_address));

	SLIST_FOREACH(p, &ldp_peer_head, peers)
		if (p->state == LDP_PEER_ESTABLISHED)
			send_tlv(p, (struct tlv *)&al_tlv);

	return LDP_E_OK;
}

int
bind_current_routes()
{
	size_t          needed, size_cp;
	int             mib[6];
	char           *buf, *next, *lim;
	struct rt_msghdr *rtmes;
	union sockunion *so_dst, *so_pref, *so_gate;
	uint rlen;

	mib[0] = CTL_NET;
	mib[1] = PF_ROUTE;
	mib[2] = 0;
	mib[3] = 0;
	mib[4] = NET_RT_DUMP;
	mib[5] = 0;
	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
		fatalp("route-sysctl-estimate: %s",
		    strerror(errno));
		return LDP_E_ROUTE_ERROR;
	}
	if ((buf = malloc(needed)) == 0)
		return LDP_E_ROUTE_ERROR;
	if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
		free(buf);
		return LDP_E_ROUTE_ERROR;
	}
	lim = buf + needed;

	for (next = buf; next < lim; next += rlen) {
		rtmes = (struct rt_msghdr *) next;
		rlen = rtmes->rtm_msglen;
		size_cp = sizeof(struct rt_msghdr);
		so_gate = so_pref = NULL;
		if (rtmes->rtm_flags & RTF_LLINFO)	/* No need for arps */
			continue;
		if (!(rtmes->rtm_addrs & RTA_DST)) {
			debugp("No dst\n");
			continue;
		}

		CHECK_MINSA;
		so_dst = (union sockunion *) & rtmes[1];
		CHECK_LEN(so_dst);

		/*
		 * This function is called only at startup, so use
		 * this ocassion to delete all MPLS routes
		 */
		if (so_dst->sa.sa_family == AF_MPLS) {
			delete_route(so_dst, NULL, NO_FREESO);
			debugp("MPLS route deleted.\n");
			continue;
		}

		if (so_dst->sa.sa_family != AF_INET) {
			/*debugp("sa_dst is not AF_INET\n");*/
			continue;
		}

		/* Check if it's the default gateway */
		if (so_dst->sin.sin_addr.s_addr == 0 && no_default_route != 0)
			continue;

		/* Check if it's loopback */
		if ((ntohl(so_dst->sin.sin_addr.s_addr) >> 24)==IN_LOOPBACKNET)
			continue;

		/* Get Gateway */
		if (rtmes->rtm_addrs & RTA_GATEWAY)
			GETNEXT(so_gate, so_dst);

		/* Get prefix */
		if (rtmes->rtm_flags & RTF_HOST) {
			if ((so_pref = from_cidr_to_union(32)) == NULL)
				return LDP_E_MEMORY;
		} else if (rtmes->rtm_addrs & RTA_GATEWAY) {
			GETNEXT(so_pref, so_gate);
		} else
			GETNEXT(so_pref, so_dst);

		so_pref->sa.sa_family = AF_INET;
		so_pref->sa.sa_len = sizeof(struct sockaddr_in);

		/* Also deletes when dest is IPv4 and gateway MPLS */
		if ((rtmes->rtm_addrs & RTA_GATEWAY) &&
		    (so_gate->sa.sa_family == AF_MPLS)) {
			debugp("MPLS route to %s deleted.\n",
			    inet_ntoa(so_dst->sin.sin_addr));
			delete_route(so_dst,
			    rtmes->rtm_flags & RTF_HOST ? NULL : so_pref,
			    NO_FREESO);
			if (rtmes->rtm_flags & RTF_HOST)
				free(so_pref);
			continue;
		}

		if (so_gate != NULL && so_gate->sa.sa_family == AF_LINK)
			so_gate = NULL;	/* connected route */

		if (so_gate == NULL || so_gate->sa.sa_family == AF_INET)
			label_add(so_dst, so_pref, so_gate,
			    MPLS_LABEL_IMPLNULL, NULL, 0,
			    rtmes->rtm_flags & RTF_HOST);

		if (rtmes->rtm_flags & RTF_HOST)
			free(so_pref);
	}
	free(buf);
	return LDP_E_OK;
}

int
flush_mpls_routes()
{
	size_t needed, size_cp;
	int mib[6];
	uint rlen;
	char *buf, *next, *lim;
	struct rt_msghdr *rtm;
	union sockunion *so_dst, *so_pref, *so_gate;

	mib[0] = CTL_NET;
	mib[1] = PF_ROUTE;
	mib[2] = 0;
	mib[3] = 0;
	mib[4] = NET_RT_DUMP;
	mib[5] = 0;
	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
		fatalp("route-sysctl-estimate: %s", strerror(errno));
		return LDP_E_ROUTE_ERROR;
	}
	if ((buf = malloc(needed)) == NULL) {
		fatalp("route-sysctl-estimate: %s", strerror(errno));
		return LDP_E_MEMORY;
	}
	if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
		free(buf);
		return LDP_E_ROUTE_ERROR;
	}
	lim = buf + needed;

	for (next = buf; next < lim; next += rlen) {
		rtm = (struct rt_msghdr *) next;
		size_cp = sizeof(struct rt_msghdr);
		rlen = rtm->rtm_msglen;
		so_pref = NULL;
		so_gate = NULL;
		if (rtm->rtm_flags & RTF_LLINFO)	/* No need for arps */
			continue;
		if (!(rtm->rtm_addrs & RTA_DST)) {
			debugp("No dst\n");
			continue;
		}
		so_dst = (union sockunion *) & rtm[1];

		if (so_dst->sa.sa_family == AF_MPLS) {
			delete_route(so_dst, NULL, NO_FREESO);
			debugp("MPLS route deleted.\n");
			continue;
		}

		if ((rtm->rtm_addrs & RTA_GATEWAY) == 0)
			continue;
		GETNEXT(so_gate, so_dst);

		if ((rtm->rtm_flags & RTF_HOST) == 0)
			GETNEXT(so_pref, so_gate);

		if (so_gate->sa.sa_family == AF_MPLS) {
			if (so_dst->sa.sa_family == AF_INET)
				debugp("MPLS route to %s deleted.\n",
				    inet_ntoa(so_dst->sin.sin_addr));
			delete_route(so_dst, so_pref, NO_FREESO);
			continue;
		}

	}
	free(buf);
	return LDP_E_OK;
}