[mirror_frr.git] / nhrpd / nhrp_route.c

/* NHRP routing functions
 * Copyright (c) 2014-2015 Timo Teräs
 *
 * This file is free software: you may copy, redistribute and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "nhrpd.h"
#include "table.h"
#include "memory.h"
#include "stream.h"
#include "log.h"
#include "zclient.h"

DEFINE_MTYPE_STATIC(NHRPD, NHRP_ROUTE, "NHRP routing entry")

static struct zclient *zclient;
static struct route_table *zebra_rib[AFI_MAX];

struct route_info {
	union sockunion via;
	struct interface *ifp;
	struct interface *nhrp_ifp;
};

static struct route_node *nhrp_route_update_get(const struct prefix *p,
						int create)
{
	struct route_node *rn;
	afi_t afi = family2afi(PREFIX_FAMILY(p));

	if (!zebra_rib[afi])
		return NULL;

	if (create) {
		rn = route_node_get(zebra_rib[afi], p);
		if (!rn->info) {
			rn->info = XCALLOC(MTYPE_NHRP_ROUTE,
					   sizeof(struct route_info));
			route_lock_node(rn);
		}
		return rn;
	} else {
		return route_node_lookup(zebra_rib[afi], p);
	}
}

static void nhrp_route_update_put(struct route_node *rn)
{
	struct route_info *ri = rn->info;

	if (!ri->ifp && !ri->nhrp_ifp
	    && sockunion_family(&ri->via) == AF_UNSPEC) {
		XFREE(MTYPE_NHRP_ROUTE, rn->info);
		route_unlock_node(rn);
	}
	route_unlock_node(rn);
}

static void nhrp_route_update_zebra(const struct prefix *p,
				    union sockunion *nexthop,
				    struct interface *ifp)
{
	struct route_node *rn;
	struct route_info *ri;

	rn = nhrp_route_update_get(
		p, (sockunion_family(nexthop) != AF_UNSPEC) || ifp);
	if (rn) {
		ri = rn->info;
		ri->via = *nexthop;
		ri->ifp = ifp;
		nhrp_route_update_put(rn);
	}
}

void nhrp_route_update_nhrp(const struct prefix *p, struct interface *ifp)
{
	struct route_node *rn;
	struct route_info *ri;

	rn = nhrp_route_update_get(p, ifp != NULL);
	if (rn) {
		ri = rn->info;
		ri->nhrp_ifp = ifp;
		nhrp_route_update_put(rn);
	}
}

void nhrp_route_announce(int add, enum nhrp_cache_type type,
			 const struct prefix *p, struct interface *ifp,
			 const union sockunion *nexthop, uint32_t mtu)
{
	struct zapi_route api;
	struct zapi_nexthop *api_nh;

	if (zclient->sock < 0)
		return;

	memset(&api, 0, sizeof(api));
	api.type = ZEBRA_ROUTE_NHRP;
	api.safi = SAFI_UNICAST;
	api.vrf_id = VRF_DEFAULT;
	api.prefix = *p;

	switch (type) {
	case NHRP_CACHE_NEGATIVE:
		zapi_route_set_blackhole(&api, BLACKHOLE_REJECT);
		ifp = NULL;
		nexthop = NULL;
		break;
	case NHRP_CACHE_DYNAMIC:
	case NHRP_CACHE_NHS:
	case NHRP_CACHE_STATIC:
		/* Regular route, so these are announced
		 * to other routing daemons */
		break;
	default:
		SET_FLAG(api.flags, ZEBRA_FLAG_FIB_OVERRIDE);
		break;
	}
	SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);

	SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
	api.nexthop_num = 1;
	api_nh = &api.nexthops[0];
	api_nh->vrf_id = VRF_DEFAULT;

	switch (api.prefix.family) {
	case AF_INET:
		if (nexthop) {
			api_nh->gate.ipv4 = nexthop->sin.sin_addr;
			api_nh->type = NEXTHOP_TYPE_IPV4;
		}
		if (ifp) {
			api_nh->ifindex = ifp->ifindex;
			if (api_nh->type == NEXTHOP_TYPE_IPV4)
				api_nh->type = NEXTHOP_TYPE_IPV4_IFINDEX;
			else
				api_nh->type = NEXTHOP_TYPE_IFINDEX;
		}
		break;
	case AF_INET6:
		if (nexthop) {
			api_nh->gate.ipv6 = nexthop->sin6.sin6_addr;
			api_nh->type = NEXTHOP_TYPE_IPV6;
		}
		if (ifp) {
			api_nh->ifindex = ifp->ifindex;
			if (api_nh->type == NEXTHOP_TYPE_IPV6)
				api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
			else
				api_nh->type = NEXTHOP_TYPE_IFINDEX;
		}
		break;
	}
	if (mtu) {
		SET_FLAG(api.message, ZAPI_MESSAGE_MTU);
		api.mtu = mtu;
	}

	if (unlikely(debug_flags & NHRP_DEBUG_ROUTE)) {
		char buf[2][PREFIX_STRLEN];

		prefix2str(&api.prefix, buf[0], sizeof(buf[0]));
		zlog_debug(
			"Zebra send: route %s %s nexthop %s metric %u"
			" count %d dev %s",
			add ? "add" : "del", buf[0],
			nexthop ? inet_ntop(api.prefix.family, &api_nh->gate,
					    buf[1], sizeof(buf[1]))
				: "<onlink>",
			api.metric, api.nexthop_num, ifp ? ifp->name : "none");
	}

	zclient_route_send(add ? ZEBRA_ROUTE_ADD : ZEBRA_ROUTE_DELETE, zclient,
			   &api);
}

int nhrp_route_read(ZAPI_CALLBACK_ARGS)
{
	struct zapi_route api;
	struct zapi_nexthop *api_nh;
	struct interface *ifp = NULL;
	union sockunion nexthop_addr;
	char buf[2][PREFIX_STRLEN];
	int added;

	if (zapi_route_decode(zclient->ibuf, &api) < 0)
		return -1;

	/* we completely ignore srcdest routes for now. */
	if (CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX))
		return 0;

	sockunion_family(&nexthop_addr) = AF_UNSPEC;
	if (CHECK_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP)) {
		api_nh = &api.nexthops[0];

		nexthop_addr.sa.sa_family = api.prefix.family;
		switch (nexthop_addr.sa.sa_family) {
		case AF_INET:
			nexthop_addr.sin.sin_addr = api_nh->gate.ipv4;
			break;
		case AF_INET6:
			nexthop_addr.sin6.sin6_addr = api_nh->gate.ipv6;
			break;
		}

		if (api_nh->ifindex != IFINDEX_INTERNAL)
			ifp = if_lookup_by_index(api_nh->ifindex, VRF_DEFAULT);
	}

	added = (cmd == ZEBRA_REDISTRIBUTE_ROUTE_ADD);
	debugf(NHRP_DEBUG_ROUTE, "if-route-%s: %s via %s dev %s",
	       added ? "add" : "del",
	       prefix2str(&api.prefix, buf[0], sizeof buf[0]),
	       sockunion2str(&nexthop_addr, buf[1], sizeof buf[1]),
	       ifp ? ifp->name : "(none)");

	nhrp_route_update_zebra(&api.prefix, &nexthop_addr, ifp);
	nhrp_shortcut_prefix_change(&api.prefix, !added);

	return 0;
}

int nhrp_route_get_nexthop(const union sockunion *addr, struct prefix *p,
			   union sockunion *via, struct interface **ifp)
{
	struct route_node *rn;
	struct route_info *ri;
	struct prefix lookup;
	afi_t afi = family2afi(sockunion_family(addr));
	char buf[PREFIX_STRLEN];

	sockunion2hostprefix(addr, &lookup);

	rn = route_node_match(zebra_rib[afi], &lookup);
	if (!rn)
		return 0;

	ri = rn->info;
	if (ri->nhrp_ifp) {
		debugf(NHRP_DEBUG_ROUTE, "lookup %s: nhrp_if=%s",
		       prefix2str(&lookup, buf, sizeof buf),
		       ri->nhrp_ifp->name);

		if (via)
			sockunion_family(via) = AF_UNSPEC;
		if (ifp)
			*ifp = ri->nhrp_ifp;
	} else {
		debugf(NHRP_DEBUG_ROUTE, "lookup %s: zebra route dev %s",
		       prefix2str(&lookup, buf, sizeof buf),
		       ri->ifp ? ri->ifp->name : "(none)");

		if (via)
			*via = ri->via;
		if (ifp)
			*ifp = ri->ifp;
	}
	if (p)
		*p = rn->p;
	route_unlock_node(rn);
	return 1;
}

enum nhrp_route_type nhrp_route_address(struct interface *in_ifp,
					union sockunion *addr, struct prefix *p,
					struct nhrp_peer **peer)
{
	struct interface *ifp = in_ifp;
	struct nhrp_interface *nifp;
	struct nhrp_cache *c;
	union sockunion via[4];
	uint32_t network_id = 0;
	afi_t afi = family2afi(sockunion_family(addr));
	int i;

	if (ifp) {
		nifp = ifp->info;
		network_id = nifp->afi[afi].network_id;

		c = nhrp_cache_get(ifp, addr, 0);
		if (c && c->cur.type == NHRP_CACHE_LOCAL) {
			if (p)
				memset(p, 0, sizeof(*p));
			return NHRP_ROUTE_LOCAL;
		}
	}

	for (i = 0; i < 4; i++) {
		if (!nhrp_route_get_nexthop(addr, p, &via[i], &ifp))
			return NHRP_ROUTE_BLACKHOLE;
		if (ifp) {
			/* Departing from nbma network? */
			nifp = ifp->info;
			if (network_id
			    && network_id != nifp->afi[afi].network_id)
				return NHRP_ROUTE_OFF_NBMA;
		}
		if (sockunion_family(&via[i]) == AF_UNSPEC)
			break;
		/* Resolve via node, but return the prefix of first match */
		addr = &via[i];
		p = NULL;
	}

	if (ifp) {
		c = nhrp_cache_get(ifp, addr, 0);
		if (c && c->cur.type >= NHRP_CACHE_DYNAMIC) {
			if (p)
				memset(p, 0, sizeof(*p));
			if (c->cur.type == NHRP_CACHE_LOCAL)
				return NHRP_ROUTE_LOCAL;
			if (peer)
				*peer = nhrp_peer_ref(c->cur.peer);
			return NHRP_ROUTE_NBMA_NEXTHOP;
		}
	}

	return NHRP_ROUTE_BLACKHOLE;
}

static void nhrp_zebra_connected(struct zclient *zclient)
{
	zclient_send_reg_requests(zclient, VRF_DEFAULT);
	zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP,
				ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
	zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP6,
				ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
}

void nhrp_zebra_init(void)
{
	zebra_rib[AFI_IP] = route_table_init();
	zebra_rib[AFI_IP6] = route_table_init();

	zclient = zclient_new(master, &zclient_options_default);
	zclient->zebra_connected = nhrp_zebra_connected;
	zclient->interface_address_add = nhrp_interface_address_add;
	zclient->interface_address_delete = nhrp_interface_address_delete;
	zclient->redistribute_route_add = nhrp_route_read;
	zclient->redistribute_route_del = nhrp_route_read;

	zclient_init(zclient, ZEBRA_ROUTE_NHRP, 0, &nhrpd_privs);
}

void nhrp_zebra_terminate(void)
{
	zclient_stop(zclient);
	zclient_free(zclient);
	route_table_finish(zebra_rib[AFI_IP]);
	route_table_finish(zebra_rib[AFI_IP6]);
}
Commit	Line	Data
2fb975da TT	1	/* NHRP routing functions
	2	* Copyright (c) 2014-2015 Timo Teräs
	3	*
	4	* This file is free software: you may copy, redistribute and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation, either version 2 of the License, or
	7	* (at your option) any later version.
	8	*/
	9
b45ac5f5 DL	10	#ifdef HAVE_CONFIG_H
	11	#include "config.h"
	12	#endif
	13
2fb975da TT	14	#include "nhrpd.h"
	15	#include "table.h"
	16	#include "memory.h"
	17	#include "stream.h"
	18	#include "log.h"
	19	#include "zclient.h"
	20
819dc8bb DL	21	DEFINE_MTYPE_STATIC(NHRPD, NHRP_ROUTE, "NHRP routing entry")
819dc8bb DL	22
2fb975da TT	23	static struct zclient *zclient;
	24	static struct route_table *zebra_rib[AFI_MAX];
	25
	26	struct route_info {
	27	union sockunion via;
	28	struct interface *ifp;
	29	struct interface *nhrp_ifp;
	30	};
	31
996c9314 LB	32	static struct route_node nhrp_route_update_get(const struct prefix p,
996c9314 LB	33	int create)
2fb975da TT	34	{
	35	struct route_node *rn;
	36	afi_t afi = family2afi(PREFIX_FAMILY(p));
	37
	38	if (!zebra_rib[afi])
	39	return NULL;
	40
	41	if (create) {
	42	rn = route_node_get(zebra_rib[afi], p);
	43	if (!rn->info) {
996c9314 LB	44	rn->info = XCALLOC(MTYPE_NHRP_ROUTE,
996c9314 LB	45	sizeof(struct route_info));
2fb975da TT	46	route_lock_node(rn);
	47	}
	48	return rn;
	49	} else {
	50	return route_node_lookup(zebra_rib[afi], p);
	51	}
	52	}
	53
	54	static void nhrp_route_update_put(struct route_node *rn)
	55	{
	56	struct route_info *ri = rn->info;
	57
996c9314 LB	58	if (!ri->ifp && !ri->nhrp_ifp
996c9314 LB	59	&& sockunion_family(&ri->via) == AF_UNSPEC) {
2fb975da	60	XFREE(MTYPE_NHRP_ROUTE, rn->info);
2fb975da TT	61	route_unlock_node(rn);
	62	}
	63	route_unlock_node(rn);
	64	}
	65
996c9314 LB	66	static void nhrp_route_update_zebra(const struct prefix *p,
	67	union sockunion *nexthop,
	68	struct interface *ifp)
2fb975da TT	69	{
	70	struct route_node *rn;
	71	struct route_info *ri;
	72
996c9314 LB	73	rn = nhrp_route_update_get(
996c9314 LB	74	p, (sockunion_family(nexthop) != AF_UNSPEC) \|\| ifp);
2fb975da TT	75	if (rn) {
	76	ri = rn->info;
	77	ri->via = *nexthop;
	78	ri->ifp = ifp;
	79	nhrp_route_update_put(rn);
	80	}
	81	}
	82
	83	void nhrp_route_update_nhrp(const struct prefix p, struct interface ifp)
	84	{
	85	struct route_node *rn;
	86	struct route_info *ri;
	87
	88	rn = nhrp_route_update_get(p, ifp != NULL);
	89	if (rn) {
	90	ri = rn->info;
	91	ri->nhrp_ifp = ifp;
	92	nhrp_route_update_put(rn);
	93	}
	94	}
	95
996c9314 LB	96	void nhrp_route_announce(int add, enum nhrp_cache_type type,
	97	const struct prefix p, struct interface ifp,
	98	const union sockunion *nexthop, uint32_t mtu)
2fb975da	99	{
9350687d RW	100	struct zapi_route api;
9350687d RW	101	struct zapi_nexthop *api_nh;
2fb975da TT	102
	103	if (zclient->sock < 0)
	104	return;
	105
9350687d RW	106	memset(&api, 0, sizeof(api));
	107	api.type = ZEBRA_ROUTE_NHRP;
	108	api.safi = SAFI_UNICAST;
d5b2119c	109	api.vrf_id = VRF_DEFAULT;
9350687d RW	110	api.prefix = *p;
9350687d RW	111
2fb975da TT	112	switch (type) {
2fb975da TT	113	case NHRP_CACHE_NEGATIVE:
09a484dd DL	114	zapi_route_set_blackhole(&api, BLACKHOLE_REJECT);
	115	ifp = NULL;
	116	nexthop = NULL;
2fb975da TT	117	break;
	118	case NHRP_CACHE_DYNAMIC:
	119	case NHRP_CACHE_NHS:
	120	case NHRP_CACHE_STATIC:
	121	/* Regular route, so these are announced
	122	* to other routing daemons */
	123	break;
	124	default:
9350687d	125	SET_FLAG(api.flags, ZEBRA_FLAG_FIB_OVERRIDE);
2fb975da TT	126	break;
2fb975da TT	127	}
4e8b02f4	128	SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
2fb975da	129
9350687d RW	130	SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
	131	api.nexthop_num = 1;
	132	api_nh = &api.nexthops[0];
4a7371e9	133	api_nh->vrf_id = VRF_DEFAULT;
2fb975da	134
9350687d RW	135	switch (api.prefix.family) {
9350687d RW	136	case AF_INET:
2fb975da	137	if (nexthop) {
6f27a9f6 RW	138	api_nh->gate.ipv4 = nexthop->sin.sin_addr;
6f27a9f6 RW	139	api_nh->type = NEXTHOP_TYPE_IPV4;
2fb975da TT	140	}
2fb975da TT	141	if (ifp) {
6f27a9f6 RW	142	api_nh->ifindex = ifp->ifindex;
	143	if (api_nh->type == NEXTHOP_TYPE_IPV4)
	144	api_nh->type = NEXTHOP_TYPE_IPV4_IFINDEX;
	145	else
	146	api_nh->type = NEXTHOP_TYPE_IFINDEX;
2fb975da	147	}
9350687d RW	148	break;
9350687d RW	149	case AF_INET6:
37dc8ab5	150	if (nexthop) {
6f27a9f6 RW	151	api_nh->gate.ipv6 = nexthop->sin6.sin6_addr;
6f27a9f6 RW	152	api_nh->type = NEXTHOP_TYPE_IPV6;
37dc8ab5 TT	153	}
37dc8ab5 TT	154	if (ifp) {
6f27a9f6 RW	155	api_nh->ifindex = ifp->ifindex;
	156	if (api_nh->type == NEXTHOP_TYPE_IPV6)
	157	api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
	158	else
	159	api_nh->type = NEXTHOP_TYPE_IFINDEX;
37dc8ab5	160	}
9350687d RW	161	break;
	162	}
	163	if (mtu) {
	164	SET_FLAG(api.message, ZAPI_MESSAGE_MTU);
	165	api.mtu = mtu;
	166	}
37dc8ab5	167
9350687d RW	168	if (unlikely(debug_flags & NHRP_DEBUG_ROUTE)) {
9350687d RW	169	char buf[2][PREFIX_STRLEN];
37dc8ab5	170
9350687d	171	prefix2str(&api.prefix, buf[0], sizeof(buf[0]));
996c9314 LB	172	zlog_debug(
996c9314 LB	173	"Zebra send: route %s %s nexthop %s metric %u"
9350687d RW	174	" count %d dev %s",
9350687d RW	175	add ? "add" : "del", buf[0],
996c9314 LB	176	nexthop ? inet_ntop(api.prefix.family, &api_nh->gate,
	177	buf[1], sizeof(buf[1]))
	178	: "<onlink>",
09a484dd	179	api.metric, api.nexthop_num, ifp ? ifp->name : "none");
2fb975da	180	}
9350687d RW	181
	182	zclient_route_send(add ? ZEBRA_ROUTE_ADD : ZEBRA_ROUTE_DELETE, zclient,
	183	&api);
2fb975da TT	184	}
2fb975da TT	185
121f9dee	186	int nhrp_route_read(ZAPI_CALLBACK_ARGS)
2fb975da	187	{
74489921 RW	188	struct zapi_route api;
74489921 RW	189	struct zapi_nexthop *api_nh;
2fb975da	190	struct interface *ifp = NULL;
2fb975da	191	union sockunion nexthop_addr;
2fb975da	192	char buf[2][PREFIX_STRLEN];
74489921	193	int added;
2fb975da	194
74489921	195	if (zapi_route_decode(zclient->ibuf, &api) < 0)
2fb975da	196	return -1;
74489921 RW	197
	198	/* we completely ignore srcdest routes for now. */
	199	if (CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX))
c125d1d4 RW	200	return 0;
c125d1d4 RW	201
74489921 RW	202	sockunion_family(&nexthop_addr) = AF_UNSPEC;
	203	if (CHECK_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP)) {
	204	api_nh = &api.nexthops[0];
	205
	206	nexthop_addr.sa.sa_family = api.prefix.family;
	207	switch (nexthop_addr.sa.sa_family) {
	208	case AF_INET:
	209	nexthop_addr.sin.sin_addr = api_nh->gate.ipv4;
	210	break;
	211	case AF_INET6:
	212	nexthop_addr.sin6.sin6_addr = api_nh->gate.ipv6;
	213	break;
2fb975da	214	}
74489921 RW	215
74489921 RW	216	if (api_nh->ifindex != IFINDEX_INTERNAL)
996c9314	217	ifp = if_lookup_by_index(api_nh->ifindex, VRF_DEFAULT);
2fb975da	218	}
2fb975da	219
74489921	220	added = (cmd == ZEBRA_REDISTRIBUTE_ROUTE_ADD);
2fb975da	221	debugf(NHRP_DEBUG_ROUTE, "if-route-%s: %s via %s dev %s",
996c9314 LB	222	added ? "add" : "del",
	223	prefix2str(&api.prefix, buf[0], sizeof buf[0]),
	224	sockunion2str(&nexthop_addr, buf[1], sizeof buf[1]),
	225	ifp ? ifp->name : "(none)");
2fb975da	226
74489921 RW	227	nhrp_route_update_zebra(&api.prefix, &nexthop_addr, ifp);
74489921 RW	228	nhrp_shortcut_prefix_change(&api.prefix, !added);
2fb975da TT	229
	230	return 0;
	231	}
	232
996c9314 LB	233	int nhrp_route_get_nexthop(const union sockunion addr, struct prefix p,
996c9314 LB	234	union sockunion via, struct interface *ifp)
2fb975da TT	235	{
	236	struct route_node *rn;
	237	struct route_info *ri;
	238	struct prefix lookup;
	239	afi_t afi = family2afi(sockunion_family(addr));
	240	char buf[PREFIX_STRLEN];
	241
	242	sockunion2hostprefix(addr, &lookup);
	243
	244	rn = route_node_match(zebra_rib[afi], &lookup);
996c9314 LB	245	if (!rn)
996c9314 LB	246	return 0;
2fb975da TT	247
	248	ri = rn->info;
	249	if (ri->nhrp_ifp) {
	250	debugf(NHRP_DEBUG_ROUTE, "lookup %s: nhrp_if=%s",
996c9314 LB	251	prefix2str(&lookup, buf, sizeof buf),
996c9314 LB	252	ri->nhrp_ifp->name);
2fb975da	253
996c9314 LB	254	if (via)
	255	sockunion_family(via) = AF_UNSPEC;
	256	if (ifp)
	257	*ifp = ri->nhrp_ifp;
2fb975da TT	258	} else {
2fb975da TT	259	debugf(NHRP_DEBUG_ROUTE, "lookup %s: zebra route dev %s",
996c9314 LB	260	prefix2str(&lookup, buf, sizeof buf),
996c9314 LB	261	ri->ifp ? ri->ifp->name : "(none)");
2fb975da	262
996c9314 LB	263	if (via)
	264	*via = ri->via;
	265	if (ifp)
	266	*ifp = ri->ifp;
2fb975da	267	}
996c9314 LB	268	if (p)
996c9314 LB	269	*p = rn->p;
2fb975da TT	270	route_unlock_node(rn);
	271	return 1;
	272	}
	273
996c9314 LB	274	enum nhrp_route_type nhrp_route_address(struct interface *in_ifp,
	275	union sockunion addr, struct prefix p,
	276	struct nhrp_peer **peer)
2fb975da TT	277	{
	278	struct interface *ifp = in_ifp;
	279	struct nhrp_interface *nifp;
	280	struct nhrp_cache *c;
	281	union sockunion via[4];
	282	uint32_t network_id = 0;
	283	afi_t afi = family2afi(sockunion_family(addr));
	284	int i;
	285
	286	if (ifp) {
	287	nifp = ifp->info;
	288	network_id = nifp->afi[afi].network_id;
	289
	290	c = nhrp_cache_get(ifp, addr, 0);
	291	if (c && c->cur.type == NHRP_CACHE_LOCAL) {
996c9314 LB	292	if (p)
996c9314 LB	293	memset(p, 0, sizeof(*p));
2fb975da TT	294	return NHRP_ROUTE_LOCAL;
	295	}
	296	}
	297
	298	for (i = 0; i < 4; i++) {
	299	if (!nhrp_route_get_nexthop(addr, p, &via[i], &ifp))
	300	return NHRP_ROUTE_BLACKHOLE;
	301	if (ifp) {
	302	/* Departing from nbma network? */
	303	nifp = ifp->info;
996c9314 LB	304	if (network_id
996c9314 LB	305	&& network_id != nifp->afi[afi].network_id)
2fb975da TT	306	return NHRP_ROUTE_OFF_NBMA;
	307	}
	308	if (sockunion_family(&via[i]) == AF_UNSPEC)
	309	break;
	310	/* Resolve via node, but return the prefix of first match */
	311	addr = &via[i];
	312	p = NULL;
	313	}
	314
	315	if (ifp) {
	316	c = nhrp_cache_get(ifp, addr, 0);
	317	if (c && c->cur.type >= NHRP_CACHE_DYNAMIC) {
996c9314 LB	318	if (p)
996c9314 LB	319	memset(p, 0, sizeof(*p));
2fb975da TT	320	if (c->cur.type == NHRP_CACHE_LOCAL)
2fb975da TT	321	return NHRP_ROUTE_LOCAL;
996c9314 LB	322	if (peer)
996c9314 LB	323	*peer = nhrp_peer_ref(c->cur.peer);
2fb975da TT	324	return NHRP_ROUTE_NBMA_NEXTHOP;
	325	}
	326	}
	327
	328	return NHRP_ROUTE_BLACKHOLE;
	329	}
	330
996c9314	331	static void nhrp_zebra_connected(struct zclient *zclient)
a1f1bab0 JB	332	{
	333	zclient_send_reg_requests(zclient, VRF_DEFAULT);
	334	zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP,
996c9314	335	ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
a1f1bab0	336	zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP6,
996c9314	337	ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
a1f1bab0 JB	338	}
a1f1bab0 JB	339
2fb975da TT	340	void nhrp_zebra_init(void)
	341	{
	342	zebra_rib[AFI_IP] = route_table_init();
	343	zebra_rib[AFI_IP6] = route_table_init();
	344
26f63a1e	345	zclient = zclient_new(master, &zclient_options_default);
a1f1bab0	346	zclient->zebra_connected = nhrp_zebra_connected;
2fb975da TT	347	zclient->interface_address_add = nhrp_interface_address_add;
2fb975da TT	348	zclient->interface_address_delete = nhrp_interface_address_delete;
74489921 RW	349	zclient->redistribute_route_add = nhrp_route_read;
74489921 RW	350	zclient->redistribute_route_del = nhrp_route_read;
819dc8bb	351
342213ea	352	zclient_init(zclient, ZEBRA_ROUTE_NHRP, 0, &nhrpd_privs);
2fb975da TT	353	}
	354
	355	void nhrp_zebra_terminate(void)
	356	{
	357	zclient_stop(zclient);
20a11b25	358	zclient_free(zclient);
2fb975da TT	359	route_table_finish(zebra_rib[AFI_IP]);
	360	route_table_finish(zebra_rib[AFI_IP6]);
	361	}