[mirror_frr.git] / sharpd / sharp_zebra.c

/*
 * Zebra connect code.
 * Copyright (C) Cumulus Networks, Inc.
 *               Donald Sharp
 *
 * This file is part of FRR.
 *
 * 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 "sharp_zebra.h"

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

/* For registering threads. */
extern struct thread_master *master;

static struct interface *zebra_interface_if_lookup(struct stream *s)
{
	char ifname_tmp[INTERFACE_NAMSIZ];

	/* Read interface name. */
	stream_get(ifname_tmp, s, INTERFACE_NAMSIZ);

	/* And look it up. */
	return if_lookup_by_name(ifname_tmp, VRF_DEFAULT);
}

/* Inteface addition message from zebra. */
static int interface_add(int command, struct zclient *zclient,
			 zebra_size_t length, vrf_id_t vrf_id)
{
	struct interface *ifp;

	ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);

	if (!ifp->info)
		return 0;

	return 0;
}

static int interface_delete(int command, struct zclient *zclient,
			    zebra_size_t length, vrf_id_t vrf_id)
{
	struct interface *ifp;
	struct stream *s;

	s = zclient->ibuf;
	/* zebra_interface_state_read () updates interface structure in iflist
	 */
	ifp = zebra_interface_state_read(s, vrf_id);

	if (ifp == NULL)
		return 0;

	if_set_index(ifp, IFINDEX_INTERNAL);

	return 0;
}

static int interface_address_add(int command, struct zclient *zclient,
				 zebra_size_t length, vrf_id_t vrf_id)
{

	zebra_interface_address_read(command, zclient->ibuf, vrf_id);

	return 0;
}

static int interface_address_delete(int command, struct zclient *zclient,
				    zebra_size_t length, vrf_id_t vrf_id)
{
	struct connected *c;

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

	if (!c)
		return 0;

	connected_free(c);
	return 0;
}

static int interface_state_up(int command, struct zclient *zclient,
			      zebra_size_t length, vrf_id_t vrf_id)
{

	zebra_interface_if_lookup(zclient->ibuf);

	return 0;
}

static int interface_state_down(int command, struct zclient *zclient,
				zebra_size_t length, vrf_id_t vrf_id)
{

	zebra_interface_state_read(zclient->ibuf, vrf_id);

	return 0;
}

extern uint32_t total_routes;
extern uint32_t installed_routes;
extern uint32_t removed_routes;

static int route_notify_owner(int command, struct zclient *zclient,
			      zebra_size_t length, vrf_id_t vrf_id)
{
	struct prefix p;
	enum zapi_route_notify_owner note;
	uint32_t table;

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

	switch (note) {
	case ZAPI_ROUTE_INSTALLED:
		installed_routes++;
		if (total_routes == installed_routes)
			zlog_debug("Installed All Items");
		break;
	case ZAPI_ROUTE_FAIL_INSTALL:
		zlog_debug("Failed install of route");
		break;
	case ZAPI_ROUTE_BETTER_ADMIN_WON:
		zlog_debug("Better Admin Distance won over us");
		break;
	case ZAPI_ROUTE_REMOVED:
		removed_routes++;
		if (total_routes == removed_routes)
			zlog_debug("Removed all Items");
		break;
	case ZAPI_ROUTE_REMOVE_FAIL:
		zlog_debug("Route removal Failure");
		break;
	}
	return 0;
}

static void zebra_connected(struct zclient *zclient)
{
	zclient_send_reg_requests(zclient, VRF_DEFAULT);
}

void vrf_label_add(vrf_id_t vrf_id, afi_t afi, mpls_label_t label)
{
	zclient_send_vrf_label(zclient, vrf_id, afi, label, ZEBRA_LSP_SHARP);
}

void route_add(struct prefix *p, uint8_t instance, struct nexthop *nh)
{
	struct zapi_route api;
	struct zapi_nexthop *api_nh;

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

	SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
	SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);

	api_nh = &api.nexthops[0];
	api_nh->vrf_id = VRF_DEFAULT;
	api_nh->gate = nh->gate;
	api_nh->type = nh->type;
	api_nh->ifindex = nh->ifindex;
	api.nexthop_num = 1;

	zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
}

void route_delete(struct prefix *p, uint8_t instance)
{
	struct zapi_route api;

	memset(&api, 0, sizeof(api));
	api.vrf_id = VRF_DEFAULT;
	api.type = ZEBRA_ROUTE_SHARP;
	api.safi = SAFI_UNICAST;
	api.instance = instance;
	memcpy(&api.prefix, p, sizeof(*p));
	zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);

	return;
}

void sharp_zebra_nexthop_watch(struct prefix *p, bool watch)
{
	int command = ZEBRA_NEXTHOP_REGISTER;

	if (!watch)
		command = ZEBRA_NEXTHOP_UNREGISTER;

	if (zclient_send_rnh(zclient, command, p, true, VRF_DEFAULT) < 0)
		zlog_warn("%s: Failure to send nexthop to zebra",
			  __PRETTY_FUNCTION__);
}

static int sharp_nexthop_update(int command, struct zclient *zclient,
				zebra_size_t length, vrf_id_t vrf_id)
{
	struct zapi_route nhr;
	char buf[PREFIX_STRLEN];
	int i;

	if (!zapi_nexthop_update_decode(zclient->ibuf, &nhr)) {
		zlog_warn("%s: Decode of update failed", __PRETTY_FUNCTION__);

		return 0;
	}

	zlog_debug("Received update for %s",
		   prefix2str(&nhr.prefix, buf, sizeof(buf)));
	for (i = 0; i < nhr.nexthop_num; i++) {
		struct zapi_nexthop *znh = &nhr.nexthops[i];

		switch (znh->type) {
		case NEXTHOP_TYPE_IPV4_IFINDEX:
		case NEXTHOP_TYPE_IPV4:
			zlog_debug(
				"\tNexthop %s, type: %d, ifindex: %d, vrf: %d, label_num: %d",
				inet_ntop(AF_INET, &znh->gate.ipv4.s_addr, buf,
					  sizeof(buf)),
				znh->type, znh->ifindex, znh->vrf_id,
				znh->label_num);
			break;
		case NEXTHOP_TYPE_IPV6_IFINDEX:
		case NEXTHOP_TYPE_IPV6:
			zlog_debug(
				"\tNexthop %s, type: %d, ifindex: %d, vrf: %d, label_num: %d",
				inet_ntop(AF_INET6, &znh->gate.ipv6, buf,
					  sizeof(buf)),
				znh->type, znh->ifindex, znh->vrf_id,
				znh->label_num);
			break;
		case NEXTHOP_TYPE_IFINDEX:
			zlog_debug("\tNexthop IFINDEX: %d, ifindex: %d",
				   znh->type, znh->ifindex);
			break;
		case NEXTHOP_TYPE_BLACKHOLE:
			zlog_debug("\tNexthop blackhole");
			break;
		}
	}
	return 0;
}

extern struct zebra_privs_t sharp_privs;

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

	zclient = zclient_new(master, &opt);

	zclient_init(zclient, ZEBRA_ROUTE_SHARP, 0, &sharp_privs);
	zclient->zebra_connected = zebra_connected;
	zclient->interface_add = interface_add;
	zclient->interface_delete = interface_delete;
	zclient->interface_up = interface_state_up;
	zclient->interface_down = interface_state_down;
	zclient->interface_address_add = interface_address_add;
	zclient->interface_address_delete = interface_address_delete;
	zclient->route_notify_owner = route_notify_owner;
	zclient->nexthop_update = sharp_nexthop_update;
}
Commit	Line	Data
8a71d93d DS	1	/*
	2	* Zebra connect code.
	3	* Copyright (C) Cumulus Networks, Inc.
	4	* Donald Sharp
	5	*
	6	* This file is part of FRR.
	7	*
	8	* FRR is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2, or (at your option) any
	11	* later version.
	12	*
	13	* FRR is distributed in the hope that it will be useful, but
	14	* WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; see the file COPYING; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22	#include <zebra.h>
	23
	24	#include "thread.h"
	25	#include "command.h"
	26	#include "network.h"
	27	#include "prefix.h"
	28	#include "routemap.h"
	29	#include "table.h"
	30	#include "stream.h"
	31	#include "memory.h"
	32	#include "zclient.h"
	33	#include "filter.h"
	34	#include "plist.h"
	35	#include "log.h"
	36	#include "nexthop.h"
	37
	38	#include "sharp_zebra.h"
	39
	40	/* Zebra structure to hold current status. */
	41	struct zclient *zclient = NULL;
	42
	43	/* For registering threads. */
	44	extern struct thread_master *master;
	45
	46	static struct interface zebra_interface_if_lookup(struct stream s)
	47	{
	48	char ifname_tmp[INTERFACE_NAMSIZ];
	49
	50	/* Read interface name. */
	51	stream_get(ifname_tmp, s, INTERFACE_NAMSIZ);
	52
	53	/* And look it up. */
	54	return if_lookup_by_name(ifname_tmp, VRF_DEFAULT);
	55	}
	56
	57	/* Inteface addition message from zebra. */
	58	static int interface_add(int command, struct zclient *zclient,
996c9314	59	zebra_size_t length, vrf_id_t vrf_id)
8a71d93d DS	60	{
	61	struct interface *ifp;
	62
	63	ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);
	64
	65	if (!ifp->info)
	66	return 0;
	67
	68	return 0;
	69	}
	70
	71	static int interface_delete(int command, struct zclient *zclient,
	72	zebra_size_t length, vrf_id_t vrf_id)
	73	{
	74	struct interface *ifp;
	75	struct stream *s;
	76
	77	s = zclient->ibuf;
	78	/* zebra_interface_state_read () updates interface structure in iflist
	79	*/
	80	ifp = zebra_interface_state_read(s, vrf_id);
	81
	82	if (ifp == NULL)
	83	return 0;
	84
	85	if_set_index(ifp, IFINDEX_INTERNAL);
	86
	87	return 0;
	88	}
	89
	90	static int interface_address_add(int command, struct zclient *zclient,
	91	zebra_size_t length, vrf_id_t vrf_id)
	92	{
	93
	94	zebra_interface_address_read(command, zclient->ibuf, vrf_id);
	95
	96	return 0;
	97	}
	98
	99	static int interface_address_delete(int command, struct zclient *zclient,
	100	zebra_size_t length, vrf_id_t vrf_id)
	101	{
	102	struct connected *c;
	103
	104	c = zebra_interface_address_read(command, zclient->ibuf, vrf_id);
	105
	106	if (!c)
	107	return 0;
	108
	109	connected_free(c);
	110	return 0;
	111	}
	112
	113	static int interface_state_up(int command, struct zclient *zclient,
	114	zebra_size_t length, vrf_id_t vrf_id)
	115	{
	116
	117	zebra_interface_if_lookup(zclient->ibuf);
	118
	119	return 0;
	120	}
	121
	122	static int interface_state_down(int command, struct zclient *zclient,
	123	zebra_size_t length, vrf_id_t vrf_id)
124	{
125
126	zebra_interface_state_read(zclient->ibuf, vrf_id);
127
128	return 0;
129	}
130
131	extern uint32_t total_routes;
132	extern uint32_t installed_routes;
5e54c602	133	extern uint32_t removed_routes;
8a71d93d	134
28b11f81 DS	135	static int route_notify_owner(int command, struct zclient *zclient,
28b11f81 DS	136	zebra_size_t length, vrf_id_t vrf_id)
8a71d93d DS	137	{
	138	struct prefix p;
	139	enum zapi_route_notify_owner note;
28610f7e	140	uint32_t table;
8a71d93d	141
28610f7e	142	if (!zapi_route_notify_decode(zclient->ibuf, &p, &table, &note))
8a71d93d DS	143	return -1;
8a71d93d DS	144
5e54c602 DS	145	switch (note) {
	146	case ZAPI_ROUTE_INSTALLED:
	147	installed_routes++;
	148	if (total_routes == installed_routes)
	149	zlog_debug("Installed All Items");
	150	break;
	151	case ZAPI_ROUTE_FAIL_INSTALL:
	152	zlog_debug("Failed install of route");
	153	break;
	154	case ZAPI_ROUTE_BETTER_ADMIN_WON:
	155	zlog_debug("Better Admin Distance won over us");
	156	break;
	157	case ZAPI_ROUTE_REMOVED:
	158	removed_routes++;
	159	if (total_routes == removed_routes)
	160	zlog_debug("Removed all Items");
	161	break;
	162	case ZAPI_ROUTE_REMOVE_FAIL:
	163	zlog_debug("Route removal Failure");
	164	break;
	165	}
8a71d93d DS	166	return 0;
	167	}
	168
	169	static void zebra_connected(struct zclient *zclient)
	170	{
	171	zclient_send_reg_requests(zclient, VRF_DEFAULT);
	172	}
	173
7d061b3c	174	void vrf_label_add(vrf_id_t vrf_id, afi_t afi, mpls_label_t label)
ab18a495	175	{
7d061b3c	176	zclient_send_vrf_label(zclient, vrf_id, afi, label, ZEBRA_LSP_SHARP);
ab18a495 DS	177	}
ab18a495 DS	178
ae252c02	179	void route_add(struct prefix p, uint8_t instance, struct nexthop nh)
8a71d93d DS	180	{
	181	struct zapi_route api;
	182	struct zapi_nexthop *api_nh;
	183
	184	memset(&api, 0, sizeof(api));
	185	api.vrf_id = VRF_DEFAULT;
	186	api.type = ZEBRA_ROUTE_SHARP;
ae252c02	187	api.instance = instance;
8a71d93d DS	188	api.safi = SAFI_UNICAST;
	189	memcpy(&api.prefix, p, sizeof(*p));
	190
a3896844	191	SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
8a71d93d DS	192	SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
	193
	194	api_nh = &api.nexthops[0];
4a7371e9	195	api_nh->vrf_id = VRF_DEFAULT;
ba041bea	196	api_nh->gate = nh->gate;
8a71d93d DS	197	api_nh->type = nh->type;
	198	api_nh->ifindex = nh->ifindex;
	199	api.nexthop_num = 1;
	200
	201	zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
	202	}
	203
ae252c02	204	void route_delete(struct prefix *p, uint8_t instance)
8a71d93d DS	205	{
	206	struct zapi_route api;
	207
	208	memset(&api, 0, sizeof(api));
	209	api.vrf_id = VRF_DEFAULT;
	210	api.type = ZEBRA_ROUTE_SHARP;
	211	api.safi = SAFI_UNICAST;
ae252c02	212	api.instance = instance;
8a71d93d DS	213	memcpy(&api.prefix, p, sizeof(*p));
	214	zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
	215
	216	return;
	217	}
	218
0ae8130d DS	219	void sharp_zebra_nexthop_watch(struct prefix *p, bool watch)
	220	{
	221	int command = ZEBRA_NEXTHOP_REGISTER;
	222
	223	if (!watch)
	224	command = ZEBRA_NEXTHOP_UNREGISTER;
	225
b3beaea0 A	226	if (zclient_send_rnh(zclient, command, p, true, VRF_DEFAULT) < 0)
	227	zlog_warn("%s: Failure to send nexthop to zebra",
	228	__PRETTY_FUNCTION__);
0ae8130d DS	229	}
	230
	231	static int sharp_nexthop_update(int command, struct zclient *zclient,
	232	zebra_size_t length, vrf_id_t vrf_id)
	233	{
	234	struct zapi_route nhr;
	235	char buf[PREFIX_STRLEN];
	236	int i;
	237
	238	if (!zapi_nexthop_update_decode(zclient->ibuf, &nhr)) {
	239	zlog_warn("%s: Decode of update failed", __PRETTY_FUNCTION__);
	240
	241	return 0;
	242	}
	243
	244	zlog_debug("Received update for %s",
	245	prefix2str(&nhr.prefix, buf, sizeof(buf)));
	246	for (i = 0; i < nhr.nexthop_num; i++) {
	247	struct zapi_nexthop *znh = &nhr.nexthops[i];
	248
	249	switch (znh->type) {
	250	case NEXTHOP_TYPE_IPV4_IFINDEX:
	251	case NEXTHOP_TYPE_IPV4:
	252	zlog_debug(
	253	"\tNexthop %s, type: %d, ifindex: %d, vrf: %d, label_num: %d",
	254	inet_ntop(AF_INET, &znh->gate.ipv4.s_addr, buf,
	255	sizeof(buf)),
	256	znh->type, znh->ifindex, znh->vrf_id,
	257	znh->label_num);
	258	break;
	259	case NEXTHOP_TYPE_IPV6_IFINDEX:
	260	case NEXTHOP_TYPE_IPV6:
	261	zlog_debug(
	262	"\tNexthop %s, type: %d, ifindex: %d, vrf: %d, label_num: %d",
	263	inet_ntop(AF_INET6, &znh->gate.ipv6, buf,
	264	sizeof(buf)),
	265	znh->type, znh->ifindex, znh->vrf_id,
	266	znh->label_num);
	267	break;
	268	case NEXTHOP_TYPE_IFINDEX:
	269	zlog_debug("\tNexthop IFINDEX: %d, ifindex: %d",
	270	znh->type, znh->ifindex);
	271	break;
	272	case NEXTHOP_TYPE_BLACKHOLE:
	273	zlog_debug("\tNexthop blackhole");
	274	break;
	275	}
	276	}
	277	return 0;
	278	}
	279
8a71d93d DS	280	extern struct zebra_privs_t sharp_privs;
	281
	282	void sharp_zebra_init(void)
	283	{
996c9314	284	struct zclient_options opt = {.receive_notify = true};
8a71d93d	285
26f63a1e	286	zclient = zclient_new(master, &opt);
8a71d93d DS	287
	288	zclient_init(zclient, ZEBRA_ROUTE_SHARP, 0, &sharp_privs);
	289	zclient->zebra_connected = zebra_connected;
	290	zclient->interface_add = interface_add;
	291	zclient->interface_delete = interface_delete;
	292	zclient->interface_up = interface_state_up;
	293	zclient->interface_down = interface_state_down;
	294	zclient->interface_address_add = interface_address_add;
	295	zclient->interface_address_delete = interface_address_delete;
28b11f81	296	zclient->route_notify_owner = route_notify_owner;
0ae8130d	297	zclient->nexthop_update = sharp_nexthop_update;
8a71d93d	298	}