[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;

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

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

	ifp->info = pbr_ifp;
	return pbr_ifp;
}

void pbr_if_del(struct interface *ifp)
{
	XFREE(MTYPE_PBR_INTERFACE, ifp->info);
}

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

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

	pbr_nht_interface_update(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", __func__, 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", __func__,
	       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;

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

	if (!c)
		return 0;

	DEBUGD(&pbr_dbg_zebra, "%s: %s deleted %pFX", __func__, c->ifp->name,
	       c->address);

	connected_free(&c);
	return 0;
}

int pbr_ifp_up(struct interface *ifp)
{
	DEBUGD(&pbr_dbg_zebra, "%s: %s is up", __func__, 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", __func__, 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;

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

	switch (note) {
	case ZAPI_ROUTE_FAIL_INSTALL:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%pFX] Route install failure for table: %u",
		       __func__, &p, table_id);
		break;
	case ZAPI_ROUTE_BETTER_ADMIN_WON:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%pFX] Route better admin distance won for table: %u",
		       __func__, &p, table_id);
		break;
	case ZAPI_ROUTE_INSTALLED:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%pFX] Route installed succeeded for table: %u",
		       __func__, &p, table_id);
		pbr_nht_route_installed_for_table(table_id);
		break;
	case ZAPI_ROUTE_REMOVED:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%pFX] Route Removed succeeded for table: %u",
		       __func__, &p, table_id);
		pbr_nht_route_removed_for_table(table_id);
		break;
	case ZAPI_ROUTE_REMOVE_FAIL:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: [%pFX] Route remove fail for table: %u", __func__,
		       &p, 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;
	char ifname[INTERFACE_NAMSIZ + 1];
	uint64_t installed;

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

	pmi = NULL;
	pbrms = pbrms_lookup_unique(unique, ifname, &pmi);
	if (!pbrms) {
		DEBUGD(&pbr_dbg_zebra,
		       "%s: Failure to lookup pbrms based upon %u", __func__,
		       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", __func__);
	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;
	struct nexthop *nhop;
	int i;

	api->prefix.family = install_afi;

	DEBUGD(&pbr_dbg_zebra, "    Encoding %pFX", &api->prefix);

	i = 0;
	for (ALL_NEXTHOPS(nhg, nhop)) {
		api_nh = &api->nexthops[i];
		api_nh->vrf_id = nhop->vrf_id;
		api_nh->type = nhop->type;
		api_nh->weight = nhop->weight;
		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", __func__, 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",
		       __func__);
		break;
	case AFI_UNSPEC:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: Asked to install unspecified route type", __func__);
		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", __func__, 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",
		       __func__);
		break;
	case AFI_UNSPEC:
		DEBUGD(&pbr_dbg_zebra,
		       "%s: Asked to delete unspecified route type", __func__);
		break;
	}
}

static int pbr_zebra_nexthop_update(ZAPI_CALLBACK_ARGS)
{
	struct zapi_route nhr;
	uint32_t i;

	if (!zapi_nexthop_update_decode(zclient->ibuf, &nhr)) {
		zlog_err("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: %pFX",
		       __func__, &nhr.prefix);

		DEBUGD(&pbr_dbg_zebra, "%s:   (Nexthops(%u)", __func__,
		       nhr.nexthop_num);

		for (i = 0; i < nhr.nexthop_num; i++) {
			DEBUGD(&pbr_dbg_zebra,
			       "%s:     Type: %d: vrf: %d, ifindex: %d gate: %pI4",
			       __func__, nhr.nexthops[i].type,
			       nhr.nexthops[i].vrf_id, nhr.nexthops[i].ifindex,
			       &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 = IPV6_MAX_BITLEN;
		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)
	    == ZCLIENT_SEND_FAILURE) {
		zlog_warn("%s: Failure to send nexthop to zebra", __func__);
	}
}

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_putc(s, pbrms->dsfield);
	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_put(s, ifp->name, INTERFACE_NAMSIZ);
}

bool pbr_send_pbr_map(struct pbr_map_sequence *pbrms,
		      struct pbr_map_interface *pmi, bool install, bool changed)
{
	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 ")", __func__,
	       pbrm->name, install, is_installed);

	/*
	 * If we are installed and asked to do so again and the config
	 * has not changed, just return.
	 *
	 * If we are not installed and asked
	 * to delete just return.
	 */
	if (install && is_installed && !changed)
		return false;

	if (!install && !is_installed)
		return false;

	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:    %s %s seq %u %d %s %u", __func__,
	       install ? "Installing" : "Deleting", pbrm->name, pbrms->seqno,
	       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);

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