[mirror_frr.git] / zebra / zebra_srte.c

/* Zebra SR-TE code
 * Copyright (C) 2020  NetDEF, Inc.
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra 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.
 *
 * GNU Zebra 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 "lib/zclient.h"
#include "lib/lib_errors.h"

#include "zebra/zebra_srte.h"
#include "zebra/zebra_memory.h"
#include "zebra/zebra_mpls.h"
#include "zebra/zebra_rnh.h"
#include "zebra/zapi_msg.h"

DEFINE_MTYPE_STATIC(ZEBRA, ZEBRA_SR_POLICY, "SR Policy")

static void zebra_sr_policy_deactivate(struct zebra_sr_policy *policy);

/* Generate rb-tree of SR Policy instances. */
static inline int
zebra_sr_policy_instance_compare(const struct zebra_sr_policy *a,
				 const struct zebra_sr_policy *b)
{
	return sr_policy_compare(&a->endpoint, &b->endpoint, a->color,
				 b->color);
}
RB_GENERATE(zebra_sr_policy_instance_head, zebra_sr_policy, entry,
	    zebra_sr_policy_instance_compare)

struct zebra_sr_policy_instance_head zebra_sr_policy_instances =
	RB_INITIALIZER(&zebra_sr_policy_instances);

struct zebra_sr_policy *zebra_sr_policy_add(uint32_t color,
					    struct ipaddr *endpoint, char *name)
{
	struct zebra_sr_policy *policy;

	policy = XCALLOC(MTYPE_ZEBRA_SR_POLICY, sizeof(*policy));
	policy->color = color;
	policy->endpoint = *endpoint;
	strlcpy(policy->name, name, sizeof(policy->name));
	policy->status = ZEBRA_SR_POLICY_DOWN;
	RB_INSERT(zebra_sr_policy_instance_head, &zebra_sr_policy_instances,
		  policy);

	return policy;
}

void zebra_sr_policy_del(struct zebra_sr_policy *policy)
{
	if (policy->status == ZEBRA_SR_POLICY_UP)
		zebra_sr_policy_deactivate(policy);
	RB_REMOVE(zebra_sr_policy_instance_head, &zebra_sr_policy_instances,
		  policy);
	XFREE(MTYPE_ZEBRA_SR_POLICY, policy);
}

struct zebra_sr_policy *zebra_sr_policy_find(uint32_t color,
					     struct ipaddr *endpoint)
{
	struct zebra_sr_policy policy = {};

	policy.color = color;
	policy.endpoint = *endpoint;
	return RB_FIND(zebra_sr_policy_instance_head,
		       &zebra_sr_policy_instances, &policy);
}

struct zebra_sr_policy *zebra_sr_policy_find_by_name(char *name)
{
	struct zebra_sr_policy *policy;

	// TODO: create index for policy names
	RB_FOREACH (policy, zebra_sr_policy_instance_head,
		    &zebra_sr_policy_instances) {
		if (strcmp(policy->name, name) == 0)
			return policy;
	}

	return NULL;
}

static int zebra_sr_policy_notify_update_client(struct zebra_sr_policy *policy,
						struct zserv *client)
{
	const zebra_nhlfe_t *nhlfe;
	struct stream *s;
	uint32_t message = 0;
	unsigned long nump = 0;
	uint8_t num;
	struct zapi_nexthop znh;
	int ret;

	/* Get output stream. */
	s = stream_new(ZEBRA_MAX_PACKET_SIZ);

	zclient_create_header(s, ZEBRA_NEXTHOP_UPDATE, zvrf_id(policy->zvrf));

	/* Message flags. */
	SET_FLAG(message, ZAPI_MESSAGE_SRTE);
	stream_putl(s, message);

	switch (policy->endpoint.ipa_type) {
	case IPADDR_V4:
		stream_putw(s, AF_INET);
		stream_putc(s, IPV4_MAX_BITLEN);
		stream_put_in_addr(s, &policy->endpoint.ipaddr_v4);
		break;
	case IPADDR_V6:
		stream_putw(s, AF_INET6);
		stream_putc(s, IPV6_MAX_BITLEN);
		stream_put(s, &policy->endpoint.ipaddr_v6, IPV6_MAX_BYTELEN);
		break;
	default:
		flog_warn(EC_LIB_DEVELOPMENT,
			  "%s: unknown policy endpoint address family: %u",
			  __func__, policy->endpoint.ipa_type);
		exit(1);
	}
	stream_putl(s, policy->color);

	num = 0;
	frr_each (nhlfe_list_const, &policy->lsp->nhlfe_list, nhlfe) {
		if (!CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED)
		    || CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED))
			continue;

		if (num == 0) {
			stream_putc(s, re_type_from_lsp_type(nhlfe->type));
			stream_putw(s, 0); /* instance - not available */
			stream_putc(s, nhlfe->distance);
			stream_putl(s, 0); /* metric - not available */
			nump = stream_get_endp(s);
			stream_putc(s, 0);
		}

		zapi_nexthop_from_nexthop(&znh, nhlfe->nexthop);
		ret = zapi_nexthop_encode(s, &znh, 0, message);
		if (ret < 0)
			goto failure;

		num++;
	}
	stream_putc_at(s, nump, num);
	stream_putw_at(s, 0, stream_get_endp(s));

	client->nh_last_upd_time = monotime(NULL);
	client->last_write_cmd = ZEBRA_NEXTHOP_UPDATE;
	return zserv_send_message(client, s);

failure:

	stream_free(s);
	return -1;
}

static void zebra_sr_policy_notify_update(struct zebra_sr_policy *policy)
{
	struct rnh *rnh;
	struct prefix p = {};
	struct zebra_vrf *zvrf;
	struct listnode *node;
	struct zserv *client;

	zvrf = policy->zvrf;
	switch (policy->endpoint.ipa_type) {
	case IPADDR_V4:
		p.family = AF_INET;
		p.prefixlen = IPV4_MAX_BITLEN;
		p.u.prefix4 = policy->endpoint.ipaddr_v4;
		break;
	case IPADDR_V6:
		p.family = AF_INET6;
		p.prefixlen = IPV6_MAX_BITLEN;
		p.u.prefix6 = policy->endpoint.ipaddr_v6;
		break;
	default:
		flog_warn(EC_LIB_DEVELOPMENT,
			  "%s: unknown policy endpoint address family: %u",
			  __func__, policy->endpoint.ipa_type);
		exit(1);
	}

	rnh = zebra_lookup_rnh(&p, zvrf_id(zvrf), RNH_NEXTHOP_TYPE);
	if (!rnh)
		return;

	for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client)) {
		if (policy->status == ZEBRA_SR_POLICY_UP)
			zebra_sr_policy_notify_update_client(policy, client);
		else
			/* Fallback to the IGP shortest path. */
			zebra_send_rnh_update(rnh, client, RNH_NEXTHOP_TYPE,
					      zvrf_id(zvrf), policy->color);
	}
}

static void zebra_sr_policy_activate(struct zebra_sr_policy *policy,
				     zebra_lsp_t *lsp)
{
	policy->status = ZEBRA_SR_POLICY_UP;
	policy->lsp = lsp;
	(void)zebra_sr_policy_bsid_install(policy);
	zsend_sr_policy_notify_status(policy->color, &policy->endpoint,
				      policy->name, ZEBRA_SR_POLICY_UP);
	zebra_sr_policy_notify_update(policy);
}

static void zebra_sr_policy_update(struct zebra_sr_policy *policy,
				   zebra_lsp_t *lsp,
				   struct zapi_srte_tunnel *old_tunnel)
{
	bool bsid_changed;
	bool segment_list_changed;

	policy->lsp = lsp;

	bsid_changed =
		policy->segment_list.local_label != old_tunnel->local_label;
	segment_list_changed =
		policy->segment_list.label_num != old_tunnel->label_num
		|| memcmp(policy->segment_list.labels, old_tunnel->labels,
			  sizeof(mpls_label_t)
				  * policy->segment_list.label_num);

	/* Re-install label stack if necessary. */
	if (bsid_changed || segment_list_changed) {
		zebra_sr_policy_bsid_uninstall(policy, old_tunnel->local_label);
		(void)zebra_sr_policy_bsid_install(policy);
	}

	zsend_sr_policy_notify_status(policy->color, &policy->endpoint,
				      policy->name, ZEBRA_SR_POLICY_UP);

	/* Handle segment-list update. */
	if (segment_list_changed)
		zebra_sr_policy_notify_update(policy);
}

static void zebra_sr_policy_deactivate(struct zebra_sr_policy *policy)
{
	policy->status = ZEBRA_SR_POLICY_DOWN;
	policy->lsp = NULL;
	zebra_sr_policy_bsid_uninstall(policy,
				       policy->segment_list.local_label);
	zsend_sr_policy_notify_status(policy->color, &policy->endpoint,
				      policy->name, ZEBRA_SR_POLICY_DOWN);
	zebra_sr_policy_notify_update(policy);
}

int zebra_sr_policy_validate(struct zebra_sr_policy *policy,
			     struct zapi_srte_tunnel *new_tunnel)
{
	struct zapi_srte_tunnel old_tunnel = policy->segment_list;
	zebra_lsp_t *lsp;

	if (new_tunnel)
		policy->segment_list = *new_tunnel;

	/* Try to resolve the Binding-SID nexthops. */
	lsp = mpls_lsp_find(policy->zvrf, policy->segment_list.labels[0]);
	if (!lsp || !lsp->best_nhlfe
	    || lsp->addr_family != ipaddr_family(&policy->endpoint)) {
		if (policy->status == ZEBRA_SR_POLICY_UP)
			zebra_sr_policy_deactivate(policy);
		return -1;
	}

	/* First label was resolved successfully. */
	if (policy->status == ZEBRA_SR_POLICY_DOWN)
		zebra_sr_policy_activate(policy, lsp);
	else
		zebra_sr_policy_update(policy, lsp, &old_tunnel);

	return 0;
}

int zebra_sr_policy_bsid_install(struct zebra_sr_policy *policy)
{
	struct zapi_srte_tunnel *zt = &policy->segment_list;
	zebra_nhlfe_t *nhlfe;

	if (zt->local_label == MPLS_LABEL_NONE)
		return 0;

	frr_each_safe (nhlfe_list, &policy->lsp->nhlfe_list, nhlfe) {
		uint8_t num_out_labels;
		mpls_label_t *out_labels;
		mpls_label_t null_label = MPLS_LABEL_IMPLICIT_NULL;

		if (!CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED)
		    || CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED))
			continue;

		/*
		 * Don't push the first SID if the corresponding action in the
		 * LFIB is POP.
		 */
		if (!nhlfe->nexthop->nh_label
		    || !nhlfe->nexthop->nh_label->num_labels
		    || nhlfe->nexthop->nh_label->label[0]
			       == MPLS_LABEL_IMPLICIT_NULL) {
			if (zt->label_num > 1) {
				num_out_labels = zt->label_num - 1;
				out_labels = &zt->labels[1];
			} else {
				num_out_labels = 1;
				out_labels = &null_label;
			}
		} else {
			num_out_labels = zt->label_num;
			out_labels = zt->labels;
		}

		if (mpls_lsp_install(
			    policy->zvrf, zt->type, zt->local_label,
			    num_out_labels, out_labels, nhlfe->nexthop->type,
			    &nhlfe->nexthop->gate, nhlfe->nexthop->ifindex)
		    < 0)
			return -1;
	}

	return 0;
}

void zebra_sr_policy_bsid_uninstall(struct zebra_sr_policy *policy,
				    mpls_label_t old_bsid)
{
	struct zapi_srte_tunnel *zt = &policy->segment_list;

	mpls_lsp_uninstall_all_vrf(policy->zvrf, zt->type, old_bsid);
}

int zebra_sr_policy_label_update(mpls_label_t label,
				 enum zebra_sr_policy_update_label_mode mode)
{
	struct zebra_sr_policy *policy;

	RB_FOREACH (policy, zebra_sr_policy_instance_head,
		    &zebra_sr_policy_instances) {
		mpls_label_t next_hop_label;

		next_hop_label = policy->segment_list.labels[0];
		if (next_hop_label != label)
			continue;

		switch (mode) {
		case ZEBRA_SR_POLICY_LABEL_CREATED:
		case ZEBRA_SR_POLICY_LABEL_UPDATED:
		case ZEBRA_SR_POLICY_LABEL_REMOVED:
			zebra_sr_policy_validate(policy, NULL);
			break;
		}
	}

	return 0;
}

void zebra_srte_init(void)
{
}
Commit	Line	Data
31f937fb SM	1	/* Zebra SR-TE code
	2	* Copyright (C) 2020 NetDEF, Inc.
	3	*
	4	* This file is part of GNU Zebra.
	5	*
	6	* GNU Zebra 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	* GNU Zebra 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
	21	#include <zebra.h>
	22
	23	#include "lib/zclient.h"
	24	#include "lib/lib_errors.h"
	25
	26	#include "zebra/zebra_srte.h"
	27	#include "zebra/zebra_memory.h"
	28	#include "zebra/zebra_mpls.h"
	29	#include "zebra/zebra_rnh.h"
	30	#include "zebra/zapi_msg.h"
	31
	32	DEFINE_MTYPE_STATIC(ZEBRA, ZEBRA_SR_POLICY, "SR Policy")
	33
	34	static void zebra_sr_policy_deactivate(struct zebra_sr_policy *policy);
	35
	36	/* Generate rb-tree of SR Policy instances. */
	37	static inline int
	38	zebra_sr_policy_instance_compare(const struct zebra_sr_policy *a,
	39	const struct zebra_sr_policy *b)
	40	{
	41	return sr_policy_compare(&a->endpoint, &b->endpoint, a->color,
	42	b->color);
	43	}
	44	RB_GENERATE(zebra_sr_policy_instance_head, zebra_sr_policy, entry,
	45	zebra_sr_policy_instance_compare)
	46
	47	struct zebra_sr_policy_instance_head zebra_sr_policy_instances =
	48	RB_INITIALIZER(&zebra_sr_policy_instances);
	49
	50	struct zebra_sr_policy *zebra_sr_policy_add(uint32_t color,
	51	struct ipaddr endpoint, char name)
	52	{
	53	struct zebra_sr_policy *policy;
	54
	55	policy = XCALLOC(MTYPE_ZEBRA_SR_POLICY, sizeof(*policy));
	56	policy->color = color;
	57	policy->endpoint = *endpoint;
	58	strlcpy(policy->name, name, sizeof(policy->name));
	59	policy->status = ZEBRA_SR_POLICY_DOWN;
	60	RB_INSERT(zebra_sr_policy_instance_head, &zebra_sr_policy_instances,
	61	policy);
	62
	63	return policy;
	64	}
65
66	void zebra_sr_policy_del(struct zebra_sr_policy *policy)
67	{
68	if (policy->status == ZEBRA_SR_POLICY_UP)
69	zebra_sr_policy_deactivate(policy);
70	RB_REMOVE(zebra_sr_policy_instance_head, &zebra_sr_policy_instances,
71	policy);
72	XFREE(MTYPE_ZEBRA_SR_POLICY, policy);
73	}
74
75	struct zebra_sr_policy *zebra_sr_policy_find(uint32_t color,
76	struct ipaddr *endpoint)
77	{
78	struct zebra_sr_policy policy = {};
79
80	policy.color = color;
81	policy.endpoint = *endpoint;
82	return RB_FIND(zebra_sr_policy_instance_head,
83	&zebra_sr_policy_instances, &policy);
84	}
85
86	struct zebra_sr_policy zebra_sr_policy_find_by_name(char name)
87	{
88	struct zebra_sr_policy *policy;
89
90	// TODO: create index for policy names
91	RB_FOREACH (policy, zebra_sr_policy_instance_head,
92	&zebra_sr_policy_instances) {
93	if (strcmp(policy->name, name) == 0)
94	return policy;
95	}
96
97	return NULL;
98	}
99
100	static int zebra_sr_policy_notify_update_client(struct zebra_sr_policy *policy,
101	struct zserv *client)
102	{
103	const zebra_nhlfe_t *nhlfe;
104	struct stream *s;
105	uint32_t message = 0;
106	unsigned long nump = 0;
107	uint8_t num;
108	struct zapi_nexthop znh;
109	int ret;
110
111	/* Get output stream. */
112	s = stream_new(ZEBRA_MAX_PACKET_SIZ);
113
114	zclient_create_header(s, ZEBRA_NEXTHOP_UPDATE, zvrf_id(policy->zvrf));
115
116	/* Message flags. */
117	SET_FLAG(message, ZAPI_MESSAGE_SRTE);
118	stream_putl(s, message);
119
120	switch (policy->endpoint.ipa_type) {
121	case IPADDR_V4:
122	stream_putw(s, AF_INET);
123	stream_putc(s, IPV4_MAX_BITLEN);
124	stream_put_in_addr(s, &policy->endpoint.ipaddr_v4);
125	break;
126	case IPADDR_V6:
127	stream_putw(s, AF_INET6);
128	stream_putc(s, IPV6_MAX_BITLEN);
129	stream_put(s, &policy->endpoint.ipaddr_v6, IPV6_MAX_BYTELEN);
130	break;
131	default:
132	flog_warn(EC_LIB_DEVELOPMENT,
133	"%s: unknown policy endpoint address family: %u",
134	__func__, policy->endpoint.ipa_type);
135	exit(1);
136	}
137	stream_putl(s, policy->color);
138
139	num = 0;
140	frr_each (nhlfe_list_const, &policy->lsp->nhlfe_list, nhlfe) {
141	if (!CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED)
142	\|\| CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED))
143	continue;
144
145	if (num == 0) {
146	stream_putc(s, re_type_from_lsp_type(nhlfe->type));
147	stream_putw(s, 0); /* instance - not available */
148	stream_putc(s, nhlfe->distance);
149	stream_putl(s, 0); /* metric - not available */
150	nump = stream_get_endp(s);
151	stream_putc(s, 0);
152	}
153
154	zapi_nexthop_from_nexthop(&znh, nhlfe->nexthop);
155	ret = zapi_nexthop_encode(s, &znh, 0, message);
156	if (ret < 0)
157	goto failure;
158
159	num++;
160	}
161	stream_putc_at(s, nump, num);
162	stream_putw_at(s, 0, stream_get_endp(s));
163
164	client->nh_last_upd_time = monotime(NULL);
165	client->last_write_cmd = ZEBRA_NEXTHOP_UPDATE;
166	return zserv_send_message(client, s);
167
168	failure:
169
170	stream_free(s);
171	return -1;
172	}
173
174	static void zebra_sr_policy_notify_update(struct zebra_sr_policy *policy)
175	{
176	struct rnh *rnh;
177	struct prefix p = {};
178	struct zebra_vrf *zvrf;
179	struct listnode *node;
180	struct zserv *client;
181
182	zvrf = policy->zvrf;
183	switch (policy->endpoint.ipa_type) {
184	case IPADDR_V4:
185	p.family = AF_INET;
186	p.prefixlen = IPV4_MAX_BITLEN;
187	p.u.prefix4 = policy->endpoint.ipaddr_v4;
188	break;
189	case IPADDR_V6:
190	p.family = AF_INET6;
191	p.prefixlen = IPV6_MAX_BITLEN;
192	p.u.prefix6 = policy->endpoint.ipaddr_v6;
193	break;
194	default:
195	flog_warn(EC_LIB_DEVELOPMENT,
196	"%s: unknown policy endpoint address family: %u",
197	__func__, policy->endpoint.ipa_type);
198	exit(1);
199	}
200
201	rnh = zebra_lookup_rnh(&p, zvrf_id(zvrf), RNH_NEXTHOP_TYPE);
202	if (!rnh)
203	return;
204
205	for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client)) {
206	if (policy->status == ZEBRA_SR_POLICY_UP)
207	zebra_sr_policy_notify_update_client(policy, client);
208	else
209	/* Fallback to the IGP shortest path. */
210	zebra_send_rnh_update(rnh, client, RNH_NEXTHOP_TYPE,
211	zvrf_id(zvrf), policy->color);
212	}
213	}
214
215	static void zebra_sr_policy_activate(struct zebra_sr_policy *policy,
216	zebra_lsp_t *lsp)
217	{
218	policy->status = ZEBRA_SR_POLICY_UP;
219	policy->lsp = lsp;
220	(void)zebra_sr_policy_bsid_install(policy);
221	zsend_sr_policy_notify_status(policy->color, &policy->endpoint,
222	policy->name, ZEBRA_SR_POLICY_UP);
223	zebra_sr_policy_notify_update(policy);
224	}
225
226	static void zebra_sr_policy_update(struct zebra_sr_policy *policy,
227	zebra_lsp_t *lsp,
228	struct zapi_srte_tunnel *old_tunnel)
229	{
230	bool bsid_changed;
231	bool segment_list_changed;
232
233	policy->lsp = lsp;
234
235	bsid_changed =
236	policy->segment_list.local_label != old_tunnel->local_label;
237	segment_list_changed =
238	policy->segment_list.label_num != old_tunnel->label_num
239	\|\| memcmp(policy->segment_list.labels, old_tunnel->labels,
240	sizeof(mpls_label_t)
241	* policy->segment_list.label_num);
242
243	/* Re-install label stack if necessary. */
244	if (bsid_changed \|\| segment_list_changed) {
245	zebra_sr_policy_bsid_uninstall(policy, old_tunnel->local_label);
246	(void)zebra_sr_policy_bsid_install(policy);
247	}
248
249	zsend_sr_policy_notify_status(policy->color, &policy->endpoint,
250	policy->name, ZEBRA_SR_POLICY_UP);
251
252	/* Handle segment-list update. */
253	if (segment_list_changed)
254	zebra_sr_policy_notify_update(policy);
255	}
256
257	static void zebra_sr_policy_deactivate(struct zebra_sr_policy *policy)
258	{
259	policy->status = ZEBRA_SR_POLICY_DOWN;
260	policy->lsp = NULL;
261	zebra_sr_policy_bsid_uninstall(policy,
262	policy->segment_list.local_label);
263	zsend_sr_policy_notify_status(policy->color, &policy->endpoint,
264	policy->name, ZEBRA_SR_POLICY_DOWN);
265	zebra_sr_policy_notify_update(policy);
266	}
267
268	int zebra_sr_policy_validate(struct zebra_sr_policy *policy,
269	struct zapi_srte_tunnel *new_tunnel)
270	{
271	struct zapi_srte_tunnel old_tunnel = policy->segment_list;
272	zebra_lsp_t *lsp;
273
274	if (new_tunnel)
275	policy->segment_list = *new_tunnel;
276
277	/* Try to resolve the Binding-SID nexthops. */
278	lsp = mpls_lsp_find(policy->zvrf, policy->segment_list.labels[0]);
279	if (!lsp \|\| !lsp->best_nhlfe
280	\|\| lsp->addr_family != ipaddr_family(&policy->endpoint)) {
281	if (policy->status == ZEBRA_SR_POLICY_UP)
282	zebra_sr_policy_deactivate(policy);
283	return -1;
284	}
285
286	/* First label was resolved successfully. */
287	if (policy->status == ZEBRA_SR_POLICY_DOWN)
288	zebra_sr_policy_activate(policy, lsp);
289	else
290	zebra_sr_policy_update(policy, lsp, &old_tunnel);
291
292	return 0;
293	}
294
295	int zebra_sr_policy_bsid_install(struct zebra_sr_policy *policy)
296	{
297	struct zapi_srte_tunnel *zt = &policy->segment_list;
298	zebra_nhlfe_t *nhlfe;
299
300	if (zt->local_label == MPLS_LABEL_NONE)
301	return 0;
302
303	frr_each_safe (nhlfe_list, &policy->lsp->nhlfe_list, nhlfe) {
304	uint8_t num_out_labels;
305	mpls_label_t *out_labels;
306	mpls_label_t null_label = MPLS_LABEL_IMPLICIT_NULL;
307
308	if (!CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED)
309	\|\| CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED))
310	continue;
311
312	/*
313	* Don't push the first SID if the corresponding action in the
314	* LFIB is POP.
315	*/
316	if (!nhlfe->nexthop->nh_label
317	\|\| !nhlfe->nexthop->nh_label->num_labels
318	\|\| nhlfe->nexthop->nh_label->label[0]
319	== MPLS_LABEL_IMPLICIT_NULL) {
320	if (zt->label_num > 1) {
321	num_out_labels = zt->label_num - 1;
322	out_labels = &zt->labels[1];
323	} else {
324	num_out_labels = 1;
325	out_labels = &null_label;
326	}
327	} else {
328	num_out_labels = zt->label_num;
329	out_labels = zt->labels;
330	}
331
332	if (mpls_lsp_install(
333	policy->zvrf, zt->type, zt->local_label,
334	num_out_labels, out_labels, nhlfe->nexthop->type,
335	&nhlfe->nexthop->gate, nhlfe->nexthop->ifindex)
336	< 0)
337	return -1;
338	}
339
340	return 0;
341	}
342
343	void zebra_sr_policy_bsid_uninstall(struct zebra_sr_policy *policy,
344	mpls_label_t old_bsid)
345	{
346	struct zapi_srte_tunnel *zt = &policy->segment_list;
347
348	mpls_lsp_uninstall_all_vrf(policy->zvrf, zt->type, old_bsid);
349	}
350
351	int zebra_sr_policy_label_update(mpls_label_t label,
352	enum zebra_sr_policy_update_label_mode mode)
353	{
354	struct zebra_sr_policy *policy;
355
356	RB_FOREACH (policy, zebra_sr_policy_instance_head,
357	&zebra_sr_policy_instances) {
358	mpls_label_t next_hop_label;
359
360	next_hop_label = policy->segment_list.labels[0];
361	if (next_hop_label != label)
362	continue;
363
364	switch (mode) {
365	case ZEBRA_SR_POLICY_LABEL_CREATED:
366	case ZEBRA_SR_POLICY_LABEL_UPDATED:
367	case ZEBRA_SR_POLICY_LABEL_REMOVED:
368	zebra_sr_policy_validate(policy, NULL);
369	break;
370	}
371	}
372
373	return 0;
374	}
375
376	void zebra_srte_init(void)
377	{
378	}