[mirror_frr.git] / pbrd / pbr_zebra.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Zebra connect code.
 * Copyright (C) 2018 Cumulus Networks, Inc.
 *               Donald Sharp
 */
#include <zebra.h>

#include "frrevent.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);
}

/* Interface 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,
			       IPV6_MAX_BYTELEN);
			break;
		case NEXTHOP_TYPE_IPV6_IFINDEX:
			api_nh->ifindex = nhop->ifindex;
			memcpy(&api_nh->gate.ipv6, &nhop->gate.ipv6,
			       IPV6_MAX_BYTELEN);
			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;
	struct prefix matched;
	uint32_t i;

	if (!zapi_nexthop_update_decode(zclient->ibuf, &matched, &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 against %pFX",
		       __func__, &matched, &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);
		}
	}

	nhr.prefix = matched;
	pbr_nht_nexthop_update(&nhr);
	return 1;
}

extern struct zebra_privs_t pbr_privs;

static zclient_handler *const pbr_handlers[] = {
	[ZEBRA_INTERFACE_ADDRESS_ADD] = interface_address_add,
	[ZEBRA_INTERFACE_ADDRESS_DELETE] = interface_address_delete,
	[ZEBRA_INTERFACE_VRF_UPDATE] = interface_vrf_update,
	[ZEBRA_ROUTE_NOTIFY_OWNER] = route_notify_owner,
	[ZEBRA_RULE_NOTIFY_OWNER] = rule_notify_owner,
	[ZEBRA_NEXTHOP_UPDATE] = pbr_zebra_nexthop_update,
};

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

	zclient = zclient_new(master, &opt, pbr_handlers,
			      array_size(pbr_handlers));

	zclient_init(zclient, ZEBRA_ROUTE_PBR, 0, &pbr_privs);
	zclient->zebra_connected = zebra_connected;
}

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 = IPV4_MAX_BITLEN;
		break;
	case NEXTHOP_TYPE_IPV6:
	case NEXTHOP_TYPE_IPV6_IFINDEX:
		p.family = AF_INET6;
		memcpy(&p.u.prefix6, &nhop->gate.ipv6, IPV6_MAX_BYTELEN);
		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, SAFI_UNICAST, false, 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 = ifp->vrf->info;
	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);
	stream_putc(s, pbrms->ip_proto); /* The ip_proto */
	pbr_encode_pbr_map_sequence_prefix(s, pbrms->src, family);
	stream_putw(s, pbrms->src_prt);
	pbr_encode_pbr_map_sequence_prefix(s, pbrms->dst, family);
	stream_putw(s, pbrms->dst_prt);
	stream_putc(s, pbrms->dsfield);
	stream_putl(s, pbrms->mark);

	stream_putl(s, pbrms->action_queue_id);

	stream_putw(s, pbrms->action_vlan_id);
	stream_putw(s, pbrms->action_vlan_flags);
	stream_putw(s, pbrms->action_pcp);

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