[mirror_frr.git] / pbrd / pbr_zebra.c

/*
 * Zebra connect code.
 * Copyright (C) 2018 Cumulus Networks, Inc.
 *               Donald Sharp
 *
 * FRR is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * FRR is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <zebra.h>

#include "thread.h"
#include "command.h"
#include "network.h"
#include "prefix.h"
#include "routemap.h"
#include "table.h"
#include "stream.h"
#include "memory.h"
#include "zclient.h"
#include "filter.h"
#include "plist.h"
#include "log.h"
#include "nexthop.h"
#include "nexthop_group.h"

#include "pbr_nht.h"
#include "pbr_map.h"
#include "pbr_memory.h"
#include "pbr_zebra.h"
#include "pbr_debug.h"
#include "pbr_vrf.h"

DEFINE_MTYPE_STATIC(PBRD, PBR_INTERFACE, "PBR Interface")

/* Zebra structure to hold current status. */
struct zclient *zclient;

struct pbr_interface *pbr_if_new(struct interface *ifp)
{
	struct pbr_interface *pbr_ifp;

	zassert(ifp);
	zassert(!ifp->info);

	pbr_ifp = XCALLOC(MTYPE_PBR_INTERFACE, sizeof(*pbr_ifp));

	ifp->info = pbr_ifp;
	return pbr_ifp;
}

/* Inteface addition message from zebra. */
int pbr_ifp_create(struct interface *ifp)
{
	DEBUGD(&pbr_dbg_zebra,
	       "%s: %s", __PRETTY_FUNCTION__, ifp->name);

	if (!ifp->info)
		pbr_if_new(ifp);

	/* Update nexthops tracked from a `set nexthop` command */
	pbr_nht_nexthop_interface_update(ifp);

	pbr_map_policy_interface_update(ifp, true);

	return 0;
}

int pbr_ifp_destroy(struct interface *ifp)
{
	DEBUGD(&pbr_dbg_zebra,
	       "%s: %s", __PRETTY_FUNCTION__, ifp->name);

	pbr_map_policy_interface_update(ifp, false);

	return 0;
}

static int interface_address_add(ZAPI_CALLBACK_ARGS)
{
	struct connected *c;
	char buf[PREFIX_STRLEN];

	c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);

	DEBUGD(&pbr_dbg_zebra,
	       "%s: %s added %s", __PRETTY_FUNCTION__,
	       c ? c->ifp->name : "Unknown",
	       c ? prefix2str(c->address, buf, sizeof(buf)) : "Unknown");

	return 0;
}

static int interface_address_delete(ZAPI_CALLBACK_ARGS)
{
	struct connected *c;
	char buf[PREFIX_STRLEN];

	c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);

	if (!c)
		return 0;

	DEBUGD(&pbr_dbg_zebra,
	       "%s: %s deleted %s", __PRETTY_FUNCTION__, c->ifp->name,
	       prefix2str(c->address, buf, sizeof(buf)));

	connected_free(&c);
	return 0;
}

int pbr_ifp_up(struct interface *ifp)
{
	DEBUGD(&pbr_dbg_zebra,
	       "%s: %s is up", __PRETTY_FUNCTION__, ifp->name);

	pbr_nht_nexthop_interface_update(ifp);

	return 0;
}

int pbr_ifp_down(struct interface *ifp)
{
	DEBUGD(&pbr_dbg_zebra,
	       "%s: %s is down", __PRETTY_FUNCTION__, ifp->name);

	pbr_nht_nexthop_interface_update(ifp);

	return 0;
}

static int interface_vrf_update(ZAPI_CALLBACK_ARGS)
{
	struct interface *ifp;
	vrf_id_t new_vrf_id;

	ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
					      &new_vrf_id);

	if (!ifp) {
		DEBUGD(&pbr_dbg_zebra, "%s: VRF change interface not found",
		       __func__);

		return 0;
	}

	DEBUGD(&pbr_dbg_zebra, "%s: %s VRF change %u -> %u", __func__,
	       ifp->name, vrf_id, new_vrf_id);

	if_update_to_new_vrf(ifp, new_vrf_id);

	return 0;
}

static int route_notify_owner(ZAPI_CALLBACK_ARGS)
{
	struct prefix p;
	enum zapi_route_notify_owner note;
	uint32_t table_id;
	char buf[PREFIX_STRLEN];

	if (!zapi_route_notify_decode(zclient->ibuf, &p, &table_id, &note))
		return -1;

	prefix2str(&p, buf, sizeof(buf));

	switch (note) {
	case ZAPI_ROUTE_FAIL_INSTALL:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%s] Route install failure for table: %u",
		       __PRETTY_FUNCTION__, buf, table_id);
		break;
	case ZAPI_ROUTE_BETTER_ADMIN_WON:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%s] Route better admin distance won for table: %u",
		       __PRETTY_FUNCTION__, buf, table_id);
		break;
	case ZAPI_ROUTE_INSTALLED:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%s] Route installed succeeded for table: %u",
		       __PRETTY_FUNCTION__, buf, table_id);
		pbr_nht_route_installed_for_table(table_id);
		break;
	case ZAPI_ROUTE_REMOVED:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%s] Route Removed succeeded for table: %u",
		       __PRETTY_FUNCTION__, buf, table_id);
		pbr_nht_route_removed_for_table(table_id);
		break;
	case ZAPI_ROUTE_REMOVE_FAIL:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%s] Route remove fail for table: %u",
		       __PRETTY_FUNCTION__, buf, table_id);
		break;
	}

	return 0;
}

static int rule_notify_owner(ZAPI_CALLBACK_ARGS)
{
	uint32_t seqno, priority, unique;
	enum zapi_rule_notify_owner note;
	struct pbr_map_sequence *pbrms;
	struct pbr_map_interface *pmi;
	ifindex_t ifi;
	uint64_t installed;

	if (!zapi_rule_notify_decode(zclient->ibuf, &seqno, &priority, &unique,
				     &ifi, &note))
		return -1;

	pmi = NULL;
	pbrms = pbrms_lookup_unique(unique, ifi, &pmi);
	if (!pbrms) {
		DEBUGD(&pbr_dbg_zebra,
		       "%s: Failure to lookup pbrms based upon %u",
		       __PRETTY_FUNCTION__, unique);
		return 0;
	}

	installed = 1 << pmi->install_bit;

	switch (note) {
	case ZAPI_RULE_FAIL_INSTALL:
		pbrms->installed &= ~installed;
		break;
	case ZAPI_RULE_INSTALLED:
		pbrms->installed |= installed;
		break;
	case ZAPI_RULE_FAIL_REMOVE:
		/* Don't change state on rule removal failure */
		break;
	case ZAPI_RULE_REMOVED:
		pbrms->installed &= ~installed;
		break;
	}

	DEBUGD(&pbr_dbg_zebra, "%s: Received %s: %" PRIu64, __func__,
	       zapi_rule_notify_owner2str(note), pbrms->installed);

	pbr_map_final_interface_deletion(pbrms->parent, pmi);

	return 0;
}

static void zebra_connected(struct zclient *zclient)
{
	DEBUGD(&pbr_dbg_zebra, "%s: Registering for fun and profit",
	       __PRETTY_FUNCTION__);
	zclient_send_reg_requests(zclient, VRF_DEFAULT);
}

static void route_add_helper(struct zapi_route *api, struct nexthop_group nhg,
			     uint8_t install_afi)
{
	struct zapi_nexthop *api_nh;
	char buf[PREFIX_STRLEN];
	struct nexthop *nhop;
	int i;

	api->prefix.family = install_afi;

	DEBUGD(&pbr_dbg_zebra, "\tEncoding %s",
	       prefix2str(&api->prefix, buf, sizeof(buf)));

	i = 0;
	for (ALL_NEXTHOPS(nhg, nhop)) {
		api_nh = &api->nexthops[i];
		api_nh->vrf_id = nhop->vrf_id;
		api_nh->type = nhop->type;
		switch (nhop->type) {
		case NEXTHOP_TYPE_IPV4:
			api_nh->gate.ipv4 = nhop->gate.ipv4;
			break;
		case NEXTHOP_TYPE_IPV4_IFINDEX:
			api_nh->gate.ipv4 = nhop->gate.ipv4;
			api_nh->ifindex = nhop->ifindex;
			break;
		case NEXTHOP_TYPE_IFINDEX:
			api_nh->ifindex = nhop->ifindex;
			break;
		case NEXTHOP_TYPE_IPV6:
			memcpy(&api_nh->gate.ipv6, &nhop->gate.ipv6, 16);
			break;
		case NEXTHOP_TYPE_IPV6_IFINDEX:
			api_nh->ifindex = nhop->ifindex;
			memcpy(&api_nh->gate.ipv6, &nhop->gate.ipv6, 16);
			break;
		case NEXTHOP_TYPE_BLACKHOLE:
			api_nh->bh_type = nhop->bh_type;
			break;
		}
		i++;
	}
	api->nexthop_num = i;

	zclient_route_send(ZEBRA_ROUTE_ADD, zclient, api);
}

/*
 * This function assumes a default route is being
 * installed into the appropriate tableid
 */
void route_add(struct pbr_nexthop_group_cache *pnhgc, struct nexthop_group nhg,
	       afi_t install_afi)
{
	struct zapi_route api;

	DEBUGD(&pbr_dbg_zebra, "%s for Table: %d", __PRETTY_FUNCTION__,
	       pnhgc->table_id);

	memset(&api, 0, sizeof(api));

	api.vrf_id = VRF_DEFAULT;
	api.type = ZEBRA_ROUTE_PBR;
	api.safi = SAFI_UNICAST;
	/*
	 * Sending a default route
	 */
	api.tableid = pnhgc->table_id;
	SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
	SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
	SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
	switch (install_afi) {
	case AFI_MAX:
		route_add_helper(&api, nhg, AF_INET);
		route_add_helper(&api, nhg, AF_INET6);
		break;
	case AFI_IP:
		route_add_helper(&api, nhg, AF_INET);
		break;
	case AFI_IP6:
		route_add_helper(&api, nhg, AF_INET6);
		break;
	case AFI_L2VPN:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: Asked to install unsupported route type: L2VPN",
		       __PRETTY_FUNCTION__);
		break;
	case AFI_UNSPEC:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: Asked to install unspecified route type",
		       __PRETTY_FUNCTION__);
		break;
	}
}

/*
 * This function assumes a default route is being
 * removed from the appropriate tableid
 */
void route_delete(struct pbr_nexthop_group_cache *pnhgc, afi_t afi)
{
	struct zapi_route api;

	DEBUGD(&pbr_dbg_zebra, "%s for Table: %d", __PRETTY_FUNCTION__,
	       pnhgc->table_id);

	memset(&api, 0, sizeof(api));
	api.vrf_id = VRF_DEFAULT;
	api.type = ZEBRA_ROUTE_PBR;
	api.safi = SAFI_UNICAST;

	api.tableid = pnhgc->table_id;
	SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);

	switch (afi) {
	case AFI_IP:
		api.prefix.family = AF_INET;
		zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
		break;
	case AFI_IP6:
		api.prefix.family = AF_INET6;
		zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
		break;
	case AFI_MAX:
		api.prefix.family = AF_INET;
		zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
		api.prefix.family = AF_INET6;
		zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
		break;
	case AFI_L2VPN:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: Asked to delete unsupported route type: L2VPN",
		       __PRETTY_FUNCTION__);
		break;
	case AFI_UNSPEC:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: Asked to delete unspecified route type",
		       __PRETTY_FUNCTION__);
		break;
	}
}

static int pbr_zebra_nexthop_update(ZAPI_CALLBACK_ARGS)
{
	struct zapi_route nhr;
	char buf[PREFIX2STR_BUFFER];
	uint32_t i;

	if (!zapi_nexthop_update_decode(zclient->ibuf, &nhr)) {
		zlog_warn("Failure to decode Nexthop update message");
		return 0;
	}

	if (DEBUG_MODE_CHECK(&pbr_dbg_zebra, DEBUG_MODE_ALL)) {

		DEBUGD(&pbr_dbg_zebra, "%s: Received Nexthop update: %s",
		       __PRETTY_FUNCTION__,
		       prefix2str(&nhr.prefix, buf, sizeof(buf)));

		DEBUGD(&pbr_dbg_zebra, "%s: (\tNexthops(%u)",
		       __PRETTY_FUNCTION__, nhr.nexthop_num);

		for (i = 0; i < nhr.nexthop_num; i++) {
			DEBUGD(&pbr_dbg_zebra,
			       "%s: \tType: %d: vrf: %d, ifindex: %d gate: %s",
			       __PRETTY_FUNCTION__, nhr.nexthops[i].type,
			       nhr.nexthops[i].vrf_id, nhr.nexthops[i].ifindex,
			       inet_ntoa(nhr.nexthops[i].gate.ipv4));
		}
	}

	pbr_nht_nexthop_update(&nhr);
	return 1;
}

extern struct zebra_privs_t pbr_privs;

void pbr_zebra_init(void)
{
	struct zclient_options opt = { .receive_notify = true };

	zclient = zclient_new(master, &opt);

	zclient_init(zclient, ZEBRA_ROUTE_PBR, 0, &pbr_privs);
	zclient->zebra_connected = zebra_connected;
	zclient->interface_address_add = interface_address_add;
	zclient->interface_address_delete = interface_address_delete;
	zclient->interface_vrf_update = interface_vrf_update;
	zclient->route_notify_owner = route_notify_owner;
	zclient->rule_notify_owner = rule_notify_owner;
	zclient->nexthop_update = pbr_zebra_nexthop_update;
}

void pbr_send_rnh(struct nexthop *nhop, bool reg)
{
	uint32_t command;
	struct prefix p;

	command = (reg) ?
		ZEBRA_NEXTHOP_REGISTER : ZEBRA_NEXTHOP_UNREGISTER;

	memset(&p, 0, sizeof(p));
	switch (nhop->type) {
	case NEXTHOP_TYPE_IFINDEX:
	case NEXTHOP_TYPE_BLACKHOLE:
		return;
	case NEXTHOP_TYPE_IPV4:
	case NEXTHOP_TYPE_IPV4_IFINDEX:
		p.family = AF_INET;
		p.u.prefix4.s_addr = nhop->gate.ipv4.s_addr;
		p.prefixlen = 32;
		break;
	case NEXTHOP_TYPE_IPV6:
	case NEXTHOP_TYPE_IPV6_IFINDEX:
		p.family = AF_INET6;
		memcpy(&p.u.prefix6, &nhop->gate.ipv6, 16);
		p.prefixlen = 128;
		if (IN6_IS_ADDR_LINKLOCAL(&nhop->gate.ipv6))
			/*
			 * Don't bother tracking link locals, just track their
			 * interface state.
			 */
			return;
		break;
	}

	if (zclient_send_rnh(zclient, command, &p,
			     false, nhop->vrf_id) < 0) {
		zlog_warn("%s: Failure to send nexthop to zebra",
			  __PRETTY_FUNCTION__);
	}
}

static void pbr_encode_pbr_map_sequence_prefix(struct stream *s,
					       struct prefix *p,
					       unsigned char  family)
{
	struct prefix any;

	if (!p) {
		memset(&any, 0, sizeof(any));
		any.family = family;
		p = &any;
	}

	stream_putc(s, p->family);
	stream_putc(s, p->prefixlen);
	stream_put(s, &p->u.prefix, prefix_blen(p));
}

static void
pbr_encode_pbr_map_sequence_vrf(struct stream *s,
				const struct pbr_map_sequence *pbrms,
				const struct interface *ifp)
{
	struct pbr_vrf *pbr_vrf;

	if (pbrms->vrf_unchanged)
		pbr_vrf = pbr_vrf_lookup_by_id(ifp->vrf_id);
	else
		pbr_vrf = pbr_vrf_lookup_by_name(pbrms->vrf_name);

	if (!pbr_vrf) {
		DEBUGD(&pbr_dbg_zebra, "%s: VRF not found", __func__);
		return;
	}

	stream_putl(s, pbr_vrf->vrf->data.l.table_id);
}

static void pbr_encode_pbr_map_sequence(struct stream *s,
					struct pbr_map_sequence *pbrms,
					struct interface *ifp)
{
	unsigned char family;

	family = AF_INET;
	if (pbrms->family)
		family = pbrms->family;

	stream_putl(s, pbrms->seqno);
	stream_putl(s, pbrms->ruleno);
	stream_putl(s, pbrms->unique);
	pbr_encode_pbr_map_sequence_prefix(s, pbrms->src, family);
	stream_putw(s, 0);  /* src port */
	pbr_encode_pbr_map_sequence_prefix(s, pbrms->dst, family);
	stream_putw(s, 0);  /* dst port */
	stream_putl(s, pbrms->mark);

	if (pbrms->vrf_unchanged || pbrms->vrf_lookup)
		pbr_encode_pbr_map_sequence_vrf(s, pbrms, ifp);
	else if (pbrms->nhgrp_name)
		stream_putl(s, pbr_nht_get_table(pbrms->nhgrp_name));
	else if (pbrms->nhg)
		stream_putl(s, pbr_nht_get_table(pbrms->internal_nhg_name));
	stream_putl(s, ifp->ifindex);
}

void pbr_send_pbr_map(struct pbr_map_sequence *pbrms,
		      struct pbr_map_interface *pmi, bool install)
{
	struct pbr_map *pbrm = pbrms->parent;
	struct stream *s;
	uint64_t is_installed = (uint64_t)1 << pmi->install_bit;

	is_installed &= pbrms->installed;

	DEBUGD(&pbr_dbg_zebra, "%s: for %s %d(%" PRIu64 ")",
	       __PRETTY_FUNCTION__, pbrm->name, install, is_installed);

	/*
	 * If we are installed and asked to do so again
	 * just return.  If we are not installed and asked
	 * and asked to delete just return;
	 */
	if (install && is_installed)
		return;

	if (!install && !is_installed)
		return;

	s = zclient->obuf;
	stream_reset(s);

	zclient_create_header(s,
			      install ? ZEBRA_RULE_ADD : ZEBRA_RULE_DELETE,
			      VRF_DEFAULT);

	/*
	 * We are sending one item at a time at the moment
	 */
	stream_putl(s, 1);

	DEBUGD(&pbr_dbg_zebra, "%s: \t%s %s %d %s %u",
	       __PRETTY_FUNCTION__, install ? "Installing" : "Deleting",
	       pbrm->name, install, pmi->ifp->name, pmi->delete);

	pbr_encode_pbr_map_sequence(s, pbrms, pmi->ifp);

	stream_putw_at(s, 0, stream_get_endp(s));

	zclient_send_message(zclient);
}
Commit	Line	Data
e5c83d9b DS	1	/*
	2	* Zebra connect code.
	3	* Copyright (C) 2018 Cumulus Networks, Inc.
	4	* Donald Sharp
	5	*
	6	* FRR is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2, or (at your option) any
	9	* later version.
	10	*
	11	* FRR is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License along
	17	* with this program; see the file COPYING; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20	#include <zebra.h>
	21
	22	#include "thread.h"
	23	#include "command.h"
	24	#include "network.h"
	25	#include "prefix.h"
	26	#include "routemap.h"
	27	#include "table.h"
	28	#include "stream.h"
	29	#include "memory.h"
	30	#include "zclient.h"
	31	#include "filter.h"
	32	#include "plist.h"
	33	#include "log.h"
	34	#include "nexthop.h"
	35	#include "nexthop_group.h"
	36
	37	#include "pbr_nht.h"
	38	#include "pbr_map.h"
	39	#include "pbr_memory.h"
	40	#include "pbr_zebra.h"
	41	#include "pbr_debug.h"
be3b67b5	42	#include "pbr_vrf.h"
e5c83d9b DS	43
	44	DEFINE_MTYPE_STATIC(PBRD, PBR_INTERFACE, "PBR Interface")
	45
	46	/* Zebra structure to hold current status. */
d3765386	47	struct zclient *zclient;
e5c83d9b	48
b13e5ad6	49	struct pbr_interface pbr_if_new(struct interface ifp)
e5c83d9b DS	50	{
	51	struct pbr_interface *pbr_ifp;
	52
	53	zassert(ifp);
	54	zassert(!ifp->info);
	55
	56	pbr_ifp = XCALLOC(MTYPE_PBR_INTERFACE, sizeof(*pbr_ifp));
	57
10a00758 DS	58	ifp->info = pbr_ifp;
10a00758 DS	59	return pbr_ifp;
e5c83d9b DS	60	}
	61
	62	/* Inteface addition message from zebra. */
ef7bd2a3	63	int pbr_ifp_create(struct interface *ifp)
e5c83d9b	64	{
2f61710b DS	65	DEBUGD(&pbr_dbg_zebra,
	66	"%s: %s", __PRETTY_FUNCTION__, ifp->name);
	67
10a00758 DS	68	if (!ifp->info)
10a00758 DS	69	pbr_if_new(ifp);
e5c83d9b	70
be3b67b5	71	/* Update nexthops tracked from a `set nexthop` command */
a106a408 RW	72	pbr_nht_nexthop_interface_update(ifp);
a106a408 RW	73
be3b67b5 SW	74	pbr_map_policy_interface_update(ifp, true);
be3b67b5 SW	75
e5c83d9b DS	76	return 0;
	77	}
	78
3c3c3252	79	int pbr_ifp_destroy(struct interface *ifp)
e5c83d9b	80	{
2f61710b DS	81	DEBUGD(&pbr_dbg_zebra,
	82	"%s: %s", __PRETTY_FUNCTION__, ifp->name);
	83
be3b67b5 SW	84	pbr_map_policy_interface_update(ifp, false);
be3b67b5 SW	85
e5c83d9b DS	86	return 0;
	87	}
	88
121f9dee	89	static int interface_address_add(ZAPI_CALLBACK_ARGS)
e5c83d9b	90	{
2f61710b DS	91	struct connected *c;
	92	char buf[PREFIX_STRLEN];
	93
121f9dee	94	c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
2f61710b DS	95
2f61710b DS	96	DEBUGD(&pbr_dbg_zebra,
964c3dba DS	97	"%s: %s added %s", __PRETTY_FUNCTION__,
	98	c ? c->ifp->name : "Unknown",
	99	c ? prefix2str(c->address, buf, sizeof(buf)) : "Unknown");
e5c83d9b DS	100
	101	return 0;
	102	}
	103
121f9dee	104	static int interface_address_delete(ZAPI_CALLBACK_ARGS)
e5c83d9b DS	105	{
e5c83d9b DS	106	struct connected *c;
2f61710b	107	char buf[PREFIX_STRLEN];
e5c83d9b	108
121f9dee	109	c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
e5c83d9b DS	110
	111	if (!c)
	112	return 0;
	113
2f61710b DS	114	DEBUGD(&pbr_dbg_zebra,
	115	"%s: %s deleted %s", __PRETTY_FUNCTION__, c->ifp->name,
	116	prefix2str(c->address, buf, sizeof(buf)));
	117
721c0857	118	connected_free(&c);
e5c83d9b DS	119	return 0;
	120	}
	121
ddbf3e60	122	int pbr_ifp_up(struct interface *ifp)
e5c83d9b	123	{
2f61710b DS	124	DEBUGD(&pbr_dbg_zebra,
2f61710b DS	125	"%s: %s is up", __PRETTY_FUNCTION__, ifp->name);
e5c83d9b	126
a106a408 RW	127	pbr_nht_nexthop_interface_update(ifp);
a106a408 RW	128
e5c83d9b DS	129	return 0;
	130	}
	131
b0b69e59	132	int pbr_ifp_down(struct interface *ifp)
e5c83d9b	133	{
2f61710b DS	134	DEBUGD(&pbr_dbg_zebra,
2f61710b DS	135	"%s: %s is down", __PRETTY_FUNCTION__, ifp->name);
e5c83d9b	136
a106a408 RW	137	pbr_nht_nexthop_interface_update(ifp);
a106a408 RW	138
e5c83d9b DS	139	return 0;
	140	}
	141
be3b67b5 SW	142	static int interface_vrf_update(ZAPI_CALLBACK_ARGS)
	143	{
	144	struct interface *ifp;
	145	vrf_id_t new_vrf_id;
	146
	147	ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
	148	&new_vrf_id);
	149
	150	if (!ifp) {
	151	DEBUGD(&pbr_dbg_zebra, "%s: VRF change interface not found",
	152	__func__);
	153
	154	return 0;
	155	}
	156
	157	DEBUGD(&pbr_dbg_zebra, "%s: %s VRF change %u -> %u", __func__,
	158	ifp->name, vrf_id, new_vrf_id);
	159
	160	if_update_to_new_vrf(ifp, new_vrf_id);
	161
	162	return 0;
	163	}
	164
121f9dee	165	static int route_notify_owner(ZAPI_CALLBACK_ARGS)
e5c83d9b DS	166	{
	167	struct prefix p;
	168	enum zapi_route_notify_owner note;
	169	uint32_t table_id;
	170	char buf[PREFIX_STRLEN];
	171
e5c83d9b DS	172	if (!zapi_route_notify_decode(zclient->ibuf, &p, &table_id, &note))
	173	return -1;
	174
2f61710b DS	175	prefix2str(&p, buf, sizeof(buf));
2f61710b DS	176
e5c83d9b DS	177	switch (note) {
	178	case ZAPI_ROUTE_FAIL_INSTALL:
	179	DEBUGD(&pbr_dbg_zebra,
	180	"%s: [%s] Route install failure for table: %u",
	181	__PRETTY_FUNCTION__, buf, table_id);
	182	break;
	183	case ZAPI_ROUTE_BETTER_ADMIN_WON:
	184	DEBUGD(&pbr_dbg_zebra,
	185	"%s: [%s] Route better admin distance won for table: %u",
	186	__PRETTY_FUNCTION__, buf, table_id);
	187	break;
	188	case ZAPI_ROUTE_INSTALLED:
	189	DEBUGD(&pbr_dbg_zebra,
	190	"%s: [%s] Route installed succeeded for table: %u",
	191	__PRETTY_FUNCTION__, buf, table_id);
	192	pbr_nht_route_installed_for_table(table_id);
	193	break;
	194	case ZAPI_ROUTE_REMOVED:
	195	DEBUGD(&pbr_dbg_zebra,
	196	"%s: [%s] Route Removed succeeded for table: %u",
	197	__PRETTY_FUNCTION__, buf, table_id);
	198	pbr_nht_route_removed_for_table(table_id);
	199	break;
	200	case ZAPI_ROUTE_REMOVE_FAIL:
	201	DEBUGD(&pbr_dbg_zebra,
	202	"%s: [%s] Route remove fail for table: %u",
	203	__PRETTY_FUNCTION__, buf, table_id);
	204	break;
	205	}
	206
	207	return 0;
	208	}
	209
121f9dee	210	static int rule_notify_owner(ZAPI_CALLBACK_ARGS)
e5c83d9b DS	211	{
	212	uint32_t seqno, priority, unique;
	213	enum zapi_rule_notify_owner note;
	214	struct pbr_map_sequence *pbrms;
37c606ff	215	struct pbr_map_interface *pmi;
e5c83d9b	216	ifindex_t ifi;
37c606ff	217	uint64_t installed;
e5c83d9b DS	218
	219	if (!zapi_rule_notify_decode(zclient->ibuf, &seqno, &priority, &unique,
	220	&ifi, &note))
	221	return -1;
	222
37c606ff DS	223	pmi = NULL;
37c606ff DS	224	pbrms = pbrms_lookup_unique(unique, ifi, &pmi);
e5c83d9b DS	225	if (!pbrms) {
	226	DEBUGD(&pbr_dbg_zebra,
	227	"%s: Failure to lookup pbrms based upon %u",
	228	__PRETTY_FUNCTION__, unique);
	229	return 0;
	230	}
	231
37c606ff DS	232	installed = 1 << pmi->install_bit;
37c606ff DS	233
e5c83d9b DS	234	switch (note) {
e5c83d9b DS	235	case ZAPI_RULE_FAIL_INSTALL:
37c606ff	236	pbrms->installed &= ~installed;
e5c83d9b DS	237	break;
e5c83d9b DS	238	case ZAPI_RULE_INSTALLED:
37c606ff	239	pbrms->installed \|= installed;
e5c83d9b	240	break;
373dd3b5	241	case ZAPI_RULE_FAIL_REMOVE:
fde8af8d	242	/* Don't change state on rule removal failure */
fde8af8d	243	break;
e5c83d9b	244	case ZAPI_RULE_REMOVED:
0f03639d	245	pbrms->installed &= ~installed;
e5c83d9b DS	246	break;
	247	}
	248
23e8679f SW	249	DEBUGD(&pbr_dbg_zebra, "%s: Received %s: %" PRIu64, __func__,
	250	zapi_rule_notify_owner2str(note), pbrms->installed);
	251
38e9ccde DS	252	pbr_map_final_interface_deletion(pbrms->parent, pmi);
38e9ccde DS	253
e5c83d9b DS	254	return 0;
	255	}
	256
	257	static void zebra_connected(struct zclient *zclient)
	258	{
2f61710b DS	259	DEBUGD(&pbr_dbg_zebra, "%s: Registering for fun and profit",
2f61710b DS	260	__PRETTY_FUNCTION__);
e5c83d9b DS	261	zclient_send_reg_requests(zclient, VRF_DEFAULT);
	262	}
	263
	264	static void route_add_helper(struct zapi_route *api, struct nexthop_group nhg,
	265	uint8_t install_afi)
	266	{
	267	struct zapi_nexthop *api_nh;
2f61710b	268	char buf[PREFIX_STRLEN];
e5c83d9b DS	269	struct nexthop *nhop;
	270	int i;
	271
	272	api->prefix.family = install_afi;
	273
2f61710b DS	274	DEBUGD(&pbr_dbg_zebra, "\tEncoding %s",
	275	prefix2str(&api->prefix, buf, sizeof(buf)));
	276
e5c83d9b DS	277	i = 0;
	278	for (ALL_NEXTHOPS(nhg, nhop)) {
	279	api_nh = &api->nexthops[i];
	280	api_nh->vrf_id = nhop->vrf_id;
	281	api_nh->type = nhop->type;
	282	switch (nhop->type) {
	283	case NEXTHOP_TYPE_IPV4:
	284	api_nh->gate.ipv4 = nhop->gate.ipv4;
	285	break;
	286	case NEXTHOP_TYPE_IPV4_IFINDEX:
	287	api_nh->gate.ipv4 = nhop->gate.ipv4;
	288	api_nh->ifindex = nhop->ifindex;
	289	break;
	290	case NEXTHOP_TYPE_IFINDEX:
	291	api_nh->ifindex = nhop->ifindex;
	292	break;
	293	case NEXTHOP_TYPE_IPV6:
	294	memcpy(&api_nh->gate.ipv6, &nhop->gate.ipv6, 16);
	295	break;
	296	case NEXTHOP_TYPE_IPV6_IFINDEX:
	297	api_nh->ifindex = nhop->ifindex;
	298	memcpy(&api_nh->gate.ipv6, &nhop->gate.ipv6, 16);
	299	break;
	300	case NEXTHOP_TYPE_BLACKHOLE:
	301	api_nh->bh_type = nhop->bh_type;
	302	break;
	303	}
	304	i++;
	305	}
	306	api->nexthop_num = i;
	307
	308	zclient_route_send(ZEBRA_ROUTE_ADD, zclient, api);
	309	}
	310
	311	/*
	312	* This function assumes a default route is being
	313	* installed into the appropriate tableid
	314	*/
	315	void route_add(struct pbr_nexthop_group_cache *pnhgc, struct nexthop_group nhg,
	316	afi_t install_afi)
	317	{
	318	struct zapi_route api;
	319
2f61710b DS	320	DEBUGD(&pbr_dbg_zebra, "%s for Table: %d", __PRETTY_FUNCTION__,
	321	pnhgc->table_id);
	322
e5c83d9b DS	323	memset(&api, 0, sizeof(api));
	324
	325	api.vrf_id = VRF_DEFAULT;
	326	api.type = ZEBRA_ROUTE_PBR;
	327	api.safi = SAFI_UNICAST;
	328	/*
	329	* Sending a default route
	330	*/
	331	api.tableid = pnhgc->table_id;
	332	SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
	333	SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
	334	SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
	335	switch (install_afi) {
	336	case AFI_MAX:
	337	route_add_helper(&api, nhg, AF_INET);
	338	route_add_helper(&api, nhg, AF_INET6);
	339	break;
	340	case AFI_IP:
	341	route_add_helper(&api, nhg, AF_INET);
	342	break;
	343	case AFI_IP6:
	344	route_add_helper(&api, nhg, AF_INET6);
	345	break;
	346	case AFI_L2VPN:
	347	DEBUGD(&pbr_dbg_zebra,
	348	"%s: Asked to install unsupported route type: L2VPN",
	349	__PRETTY_FUNCTION__);
	350	break;
b26f891d SW	351	case AFI_UNSPEC:
	352	DEBUGD(&pbr_dbg_zebra,
	353	"%s: Asked to install unspecified route type",
	354	__PRETTY_FUNCTION__);
	355	break;
e5c83d9b DS	356	}
	357	}
	358
	359	/*
	360	* This function assumes a default route is being
	361	* removed from the appropriate tableid
	362	*/
	363	void route_delete(struct pbr_nexthop_group_cache *pnhgc, afi_t afi)
	364	{
	365	struct zapi_route api;
	366
2f61710b DS	367	DEBUGD(&pbr_dbg_zebra, "%s for Table: %d", __PRETTY_FUNCTION__,
	368	pnhgc->table_id);
	369
e5c83d9b DS	370	memset(&api, 0, sizeof(api));
	371	api.vrf_id = VRF_DEFAULT;
	372	api.type = ZEBRA_ROUTE_PBR;
	373	api.safi = SAFI_UNICAST;
	374
	375	api.tableid = pnhgc->table_id;
	376	SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
	377
	378	switch (afi) {
	379	case AFI_IP:
	380	api.prefix.family = AF_INET;
	381	zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
	382	break;
	383	case AFI_IP6:
	384	api.prefix.family = AF_INET6;
	385	zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
	386	break;
	387	case AFI_MAX:
	388	api.prefix.family = AF_INET;
	389	zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
	390	api.prefix.family = AF_INET6;
	391	zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
	392	break;
	393	case AFI_L2VPN:
	394	DEBUGD(&pbr_dbg_zebra,
	395	"%s: Asked to delete unsupported route type: L2VPN",
	396	__PRETTY_FUNCTION__);
	397	break;
b26f891d SW	398	case AFI_UNSPEC:
	399	DEBUGD(&pbr_dbg_zebra,
	400	"%s: Asked to delete unspecified route type",
	401	__PRETTY_FUNCTION__);
	402	break;
e5c83d9b	403	}
e5c83d9b DS	404	}
e5c83d9b DS	405
121f9dee	406	static int pbr_zebra_nexthop_update(ZAPI_CALLBACK_ARGS)
e5c83d9b DS	407	{
	408	struct zapi_route nhr;
	409	char buf[PREFIX2STR_BUFFER];
	410	uint32_t i;
	411
54317f2c A	412	if (!zapi_nexthop_update_decode(zclient->ibuf, &nhr)) {
	413	zlog_warn("Failure to decode Nexthop update message");
	414	return 0;
	415	}
e5c83d9b DS	416
	417	if (DEBUG_MODE_CHECK(&pbr_dbg_zebra, DEBUG_MODE_ALL)) {
	418
	419	DEBUGD(&pbr_dbg_zebra, "%s: Received Nexthop update: %s",
	420	__PRETTY_FUNCTION__,
	421	prefix2str(&nhr.prefix, buf, sizeof(buf)));
	422
	423	DEBUGD(&pbr_dbg_zebra, "%s: (\tNexthops(%u)",
	424	__PRETTY_FUNCTION__, nhr.nexthop_num);
	425
	426	for (i = 0; i < nhr.nexthop_num; i++) {
	427	DEBUGD(&pbr_dbg_zebra,
	428	"%s: \tType: %d: vrf: %d, ifindex: %d gate: %s",
	429	__PRETTY_FUNCTION__, nhr.nexthops[i].type,
	430	nhr.nexthops[i].vrf_id, nhr.nexthops[i].ifindex,
	431	inet_ntoa(nhr.nexthops[i].gate.ipv4));
	432	}
	433	}
	434
	435	pbr_nht_nexthop_update(&nhr);
	436	return 1;
	437	}
	438
	439	extern struct zebra_privs_t pbr_privs;
	440
	441	void pbr_zebra_init(void)
	442	{
	443	struct zclient_options opt = { .receive_notify = true };
	444
26f63a1e	445	zclient = zclient_new(master, &opt);
e5c83d9b DS	446
	447	zclient_init(zclient, ZEBRA_ROUTE_PBR, 0, &pbr_privs);
	448	zclient->zebra_connected = zebra_connected;
e5c83d9b DS	449	zclient->interface_address_add = interface_address_add;
e5c83d9b DS	450	zclient->interface_address_delete = interface_address_delete;
be3b67b5	451	zclient->interface_vrf_update = interface_vrf_update;
e5c83d9b DS	452	zclient->route_notify_owner = route_notify_owner;
	453	zclient->rule_notify_owner = rule_notify_owner;
	454	zclient->nexthop_update = pbr_zebra_nexthop_update;
	455	}
	456
	457	void pbr_send_rnh(struct nexthop *nhop, bool reg)
	458	{
	459	uint32_t command;
	460	struct prefix p;
	461
	462	command = (reg) ?
	463	ZEBRA_NEXTHOP_REGISTER : ZEBRA_NEXTHOP_UNREGISTER;
	464
	465	memset(&p, 0, sizeof(p));
d3765386	466	switch (nhop->type) {
e5c83d9b DS	467	case NEXTHOP_TYPE_IFINDEX:
	468	case NEXTHOP_TYPE_BLACKHOLE:
	469	return;
	470	case NEXTHOP_TYPE_IPV4:
	471	case NEXTHOP_TYPE_IPV4_IFINDEX:
	472	p.family = AF_INET;
	473	p.u.prefix4.s_addr = nhop->gate.ipv4.s_addr;
	474	p.prefixlen = 32;
	475	break;
	476	case NEXTHOP_TYPE_IPV6:
	477	case NEXTHOP_TYPE_IPV6_IFINDEX:
	478	p.family = AF_INET6;
	479	memcpy(&p.u.prefix6, &nhop->gate.ipv6, 16);
	480	p.prefixlen = 128;
cb254f41 SW	481	if (IN6_IS_ADDR_LINKLOCAL(&nhop->gate.ipv6))
	482	/*
	483	* Don't bother tracking link locals, just track their
	484	* interface state.
	485	*/
	486	return;
e5c83d9b DS	487	break;
	488	}
	489
	490	if (zclient_send_rnh(zclient, command, &p,
	491	false, nhop->vrf_id) < 0) {
	492	zlog_warn("%s: Failure to send nexthop to zebra",
	493	__PRETTY_FUNCTION__);
	494	}
	495	}
	496
	497	static void pbr_encode_pbr_map_sequence_prefix(struct stream *s,
	498	struct prefix *p,
49027ce8	499	unsigned char family)
e5c83d9b DS	500	{
	501	struct prefix any;
	502
	503	if (!p) {
	504	memset(&any, 0, sizeof(any));
	505	any.family = family;
	506	p = &any;
	507	}
	508
	509	stream_putc(s, p->family);
	510	stream_putc(s, p->prefixlen);
	511	stream_put(s, &p->u.prefix, prefix_blen(p));
	512	}
	513
be3b67b5 SW	514	static void
	515	pbr_encode_pbr_map_sequence_vrf(struct stream *s,
	516	const struct pbr_map_sequence *pbrms,
	517	const struct interface *ifp)
	518	{
	519	struct pbr_vrf *pbr_vrf;
	520
	521	if (pbrms->vrf_unchanged)
	522	pbr_vrf = pbr_vrf_lookup_by_id(ifp->vrf_id);
	523	else
	524	pbr_vrf = pbr_vrf_lookup_by_name(pbrms->vrf_name);
	525
	526	if (!pbr_vrf) {
	527	DEBUGD(&pbr_dbg_zebra, "%s: VRF not found", __func__);
	528	return;
	529	}
	530
	531	stream_putl(s, pbr_vrf->vrf->data.l.table_id);
	532	}
	533
e5c83d9b DS	534	static void pbr_encode_pbr_map_sequence(struct stream *s,
	535	struct pbr_map_sequence *pbrms,
	536	struct interface *ifp)
	537	{
49027ce8	538	unsigned char family;
e5c83d9b DS	539
e5c83d9b DS	540	family = AF_INET;
49027ce8 DS	541	if (pbrms->family)
49027ce8 DS	542	family = pbrms->family;
e5c83d9b DS	543
	544	stream_putl(s, pbrms->seqno);
	545	stream_putl(s, pbrms->ruleno);
	546	stream_putl(s, pbrms->unique);
	547	pbr_encode_pbr_map_sequence_prefix(s, pbrms->src, family);
	548	stream_putw(s, 0); /* src port */
	549	pbr_encode_pbr_map_sequence_prefix(s, pbrms->dst, family);
	550	stream_putw(s, 0); /* dst port */
95a9fe02	551	stream_putl(s, pbrms->mark);
be3b67b5 SW	552
	553	if (pbrms->vrf_unchanged \|\| pbrms->vrf_lookup)
	554	pbr_encode_pbr_map_sequence_vrf(s, pbrms, ifp);
	555	else if (pbrms->nhgrp_name)
e5c83d9b DS	556	stream_putl(s, pbr_nht_get_table(pbrms->nhgrp_name));
	557	else if (pbrms->nhg)
	558	stream_putl(s, pbr_nht_get_table(pbrms->internal_nhg_name));
	559	stream_putl(s, ifp->ifindex);
	560	}
	561
b13e5ad6 DS	562	void pbr_send_pbr_map(struct pbr_map_sequence *pbrms,
b13e5ad6 DS	563	struct pbr_map_interface *pmi, bool install)
e5c83d9b	564	{
b13e5ad6	565	struct pbr_map *pbrm = pbrms->parent;
e5c83d9b	566	struct stream *s;
10a00758	567	uint64_t is_installed = (uint64_t)1 << pmi->install_bit;
37c606ff DS	568
37c606ff DS	569	is_installed &= pbrms->installed;
e5c83d9b	570
37c606ff DS	571	DEBUGD(&pbr_dbg_zebra, "%s: for %s %d(%" PRIu64 ")",
37c606ff DS	572	__PRETTY_FUNCTION__, pbrm->name, install, is_installed);
9b71ea4b DS	573
	574	/*
	575	* If we are installed and asked to do so again
	576	* just return. If we are not installed and asked
	577	* and asked to delete just return;
	578	*/
37c606ff	579	if (install && is_installed)
9b71ea4b DS	580	return;
9b71ea4b DS	581
37c606ff	582	if (!install && !is_installed)
9b71ea4b	583	return;
e5c83d9b DS	584
	585	s = zclient->obuf;
	586	stream_reset(s);
	587
	588	zclient_create_header(s,
	589	install ? ZEBRA_RULE_ADD : ZEBRA_RULE_DELETE,
	590	VRF_DEFAULT);
	591
b13e5ad6 DS	592	/*
	593	* We are sending one item at a time at the moment
	594	*/
	595	stream_putl(s, 1);
e5c83d9b	596
b13e5ad6 DS	597	DEBUGD(&pbr_dbg_zebra, "%s: \t%s %s %d %s %u",
	598	__PRETTY_FUNCTION__, install ? "Installing" : "Deleting",
	599	pbrm->name, install, pmi->ifp->name, pmi->delete);
e5c83d9b	600
b13e5ad6	601	pbr_encode_pbr_map_sequence(s, pbrms, pmi->ifp);
e5c83d9b	602
e5c83d9b DS	603	stream_putw_at(s, 0, stream_get_endp(s));
e5c83d9b DS	604
e5c83d9b DS	605	zclient_send_message(zclient);
e5c83d9b DS	606	}