[mirror_frr.git] / lib / srv6.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * SRv6 definitions
 * Copyright (C) 2020  Hiroki Shirokura, LINE Corporation
 */

#include "zebra.h"

#include "srv6.h"
#include "log.h"

DEFINE_QOBJ_TYPE(srv6_locator);
DEFINE_MTYPE_STATIC(LIB, SRV6_LOCATOR, "SRV6 locator");
DEFINE_MTYPE_STATIC(LIB, SRV6_LOCATOR_CHUNK, "SRV6 locator chunk");

const char *seg6local_action2str(uint32_t action)
{
	switch (action) {
	case ZEBRA_SEG6_LOCAL_ACTION_END:
		return "End";
	case ZEBRA_SEG6_LOCAL_ACTION_END_X:
		return "End.X";
	case ZEBRA_SEG6_LOCAL_ACTION_END_T:
		return "End.T";
	case ZEBRA_SEG6_LOCAL_ACTION_END_DX2:
		return "End.DX2";
	case ZEBRA_SEG6_LOCAL_ACTION_END_DX6:
		return "End.DX6";
	case ZEBRA_SEG6_LOCAL_ACTION_END_DX4:
		return "End.DX4";
	case ZEBRA_SEG6_LOCAL_ACTION_END_DT6:
		return "End.DT6";
	case ZEBRA_SEG6_LOCAL_ACTION_END_DT4:
		return "End.DT4";
	case ZEBRA_SEG6_LOCAL_ACTION_END_B6:
		return "End.B6";
	case ZEBRA_SEG6_LOCAL_ACTION_END_B6_ENCAP:
		return "End.B6.Encap";
	case ZEBRA_SEG6_LOCAL_ACTION_END_BM:
		return "End.BM";
	case ZEBRA_SEG6_LOCAL_ACTION_END_S:
		return "End.S";
	case ZEBRA_SEG6_LOCAL_ACTION_END_AS:
		return "End.AS";
	case ZEBRA_SEG6_LOCAL_ACTION_END_AM:
		return "End.AM";
	case ZEBRA_SEG6_LOCAL_ACTION_END_DT46:
		return "End.DT46";
	case ZEBRA_SEG6_LOCAL_ACTION_UNSPEC:
		return "unspec";
	default:
		return "unknown";
	}
}

int snprintf_seg6_segs(char *str,
		size_t size, const struct seg6_segs *segs)
{
	str[0] = '\0';
	for (size_t i = 0; i < segs->num_segs; i++) {
		char addr[INET6_ADDRSTRLEN];
		bool not_last = (i + 1) < segs->num_segs;

		inet_ntop(AF_INET6, &segs->segs[i], addr, sizeof(addr));
		strlcat(str, addr, size);
		strlcat(str, not_last ? "," : "", size);
	}
	return strlen(str);
}

const char *seg6local_context2str(char *str, size_t size,
				  const struct seg6local_context *ctx,
				  uint32_t action)
{
	switch (action) {

	case ZEBRA_SEG6_LOCAL_ACTION_END:
		snprintf(str, size, "USP");
		return str;

	case ZEBRA_SEG6_LOCAL_ACTION_END_X:
	case ZEBRA_SEG6_LOCAL_ACTION_END_DX6:
		snprintfrr(str, size, "nh6 %pI6", &ctx->nh6);
		return str;

	case ZEBRA_SEG6_LOCAL_ACTION_END_DX4:
		snprintfrr(str, size, "nh4 %pI4", &ctx->nh4);
		return str;

	case ZEBRA_SEG6_LOCAL_ACTION_END_T:
	case ZEBRA_SEG6_LOCAL_ACTION_END_DT6:
	case ZEBRA_SEG6_LOCAL_ACTION_END_DT4:
	case ZEBRA_SEG6_LOCAL_ACTION_END_DT46:
		snprintf(str, size, "table %u", ctx->table);
		return str;

	case ZEBRA_SEG6_LOCAL_ACTION_END_DX2:
	case ZEBRA_SEG6_LOCAL_ACTION_END_B6:
	case ZEBRA_SEG6_LOCAL_ACTION_END_B6_ENCAP:
	case ZEBRA_SEG6_LOCAL_ACTION_END_BM:
	case ZEBRA_SEG6_LOCAL_ACTION_END_S:
	case ZEBRA_SEG6_LOCAL_ACTION_END_AS:
	case ZEBRA_SEG6_LOCAL_ACTION_END_AM:
	case ZEBRA_SEG6_LOCAL_ACTION_UNSPEC:
	default:
		snprintf(str, size, "unknown(%s)", __func__);
		return str;
	}
}

static void srv6_locator_chunk_list_free(void *data)
{
	struct srv6_locator_chunk *chunk = data;

	srv6_locator_chunk_free(&chunk);
}

struct srv6_locator *srv6_locator_alloc(const char *name)
{
	struct srv6_locator *locator = NULL;

	locator = XCALLOC(MTYPE_SRV6_LOCATOR, sizeof(struct srv6_locator));
	strlcpy(locator->name, name, sizeof(locator->name));
	locator->chunks = list_new();
	locator->chunks->del = srv6_locator_chunk_list_free;

	QOBJ_REG(locator, srv6_locator);
	return locator;
}

struct srv6_locator_chunk *srv6_locator_chunk_alloc(void)
{
	struct srv6_locator_chunk *chunk = NULL;

	chunk = XCALLOC(MTYPE_SRV6_LOCATOR_CHUNK,
			sizeof(struct srv6_locator_chunk));
	return chunk;
}

void srv6_locator_free(struct srv6_locator *locator)
{
	if (locator) {
		QOBJ_UNREG(locator);
		list_delete(&locator->chunks);

		XFREE(MTYPE_SRV6_LOCATOR, locator);
	}
}

void srv6_locator_chunk_free(struct srv6_locator_chunk **chunk)
{
	XFREE(MTYPE_SRV6_LOCATOR_CHUNK, *chunk);
}

json_object *srv6_locator_chunk_json(const struct srv6_locator_chunk *chunk)
{
	json_object *jo_root = NULL;

	jo_root = json_object_new_object();
	json_object_string_addf(jo_root, "prefix", "%pFX", &chunk->prefix);
	json_object_string_add(jo_root, "proto",
			       zebra_route_string(chunk->proto));

	return jo_root;
}

json_object *
srv6_locator_chunk_detailed_json(const struct srv6_locator_chunk *chunk)
{
	json_object *jo_root = NULL;

	jo_root = json_object_new_object();

	/* set prefix */
	json_object_string_addf(jo_root, "prefix", "%pFX", &chunk->prefix);

	/* set block_bits_length */
	json_object_int_add(jo_root, "blockBitsLength",
			    chunk->block_bits_length);

	/* set node_bits_length */
	json_object_int_add(jo_root, "nodeBitsLength", chunk->node_bits_length);

	/* set function_bits_length */
	json_object_int_add(jo_root, "functionBitsLength",
			    chunk->function_bits_length);

	/* set argument_bits_length */
	json_object_int_add(jo_root, "argumentBitsLength",
			    chunk->argument_bits_length);

	/* set keep */
	json_object_int_add(jo_root, "keep", chunk->keep);

	/* set proto */
	json_object_string_add(jo_root, "proto",
			       zebra_route_string(chunk->proto));

	/* set instance */
	json_object_int_add(jo_root, "instance", chunk->instance);

	/* set session_id */
	json_object_int_add(jo_root, "sessionId", chunk->session_id);

	return jo_root;
}

json_object *srv6_locator_json(const struct srv6_locator *loc)
{
	struct listnode *node;
	struct srv6_locator_chunk *chunk;
	json_object *jo_root = NULL;
	json_object *jo_chunk = NULL;
	json_object *jo_chunks = NULL;

	jo_root = json_object_new_object();

	/* set name */
	json_object_string_add(jo_root, "name", loc->name);

	/* set prefix */
	json_object_string_addf(jo_root, "prefix", "%pFX", &loc->prefix);

	/* set block_bits_length */
	json_object_int_add(jo_root, "blockBitsLength", loc->block_bits_length);

	/* set node_bits_length */
	json_object_int_add(jo_root, "nodeBitsLength", loc->node_bits_length);

	/* set function_bits_length */
	json_object_int_add(jo_root, "functionBitsLength",
			    loc->function_bits_length);

	/* set argument_bits_length */
	json_object_int_add(jo_root, "argumentBitsLength",
			    loc->argument_bits_length);

	/* set true if the locator is a Micro-segment (uSID) locator */
	if (CHECK_FLAG(loc->flags, SRV6_LOCATOR_USID))
		json_object_string_add(jo_root, "behavior", "usid");

	/* set status_up */
	json_object_boolean_add(jo_root, "statusUp",
				loc->status_up);

	/* set chunks */
	jo_chunks = json_object_new_array();
	json_object_object_add(jo_root, "chunks", jo_chunks);
	for (ALL_LIST_ELEMENTS_RO((struct list *)loc->chunks, node, chunk)) {
		jo_chunk = srv6_locator_chunk_json(chunk);
		json_object_array_add(jo_chunks, jo_chunk);
	}

	return jo_root;
}

json_object *srv6_locator_detailed_json(const struct srv6_locator *loc)
{
	struct listnode *node;
	struct srv6_locator_chunk *chunk;
	json_object *jo_root = NULL;
	json_object *jo_chunk = NULL;
	json_object *jo_chunks = NULL;

	jo_root = json_object_new_object();

	/* set name */
	json_object_string_add(jo_root, "name", loc->name);

	/* set prefix */
	json_object_string_addf(jo_root, "prefix", "%pFX", &loc->prefix);

	/* set block_bits_length */
	json_object_int_add(jo_root, "blockBitsLength", loc->block_bits_length);

	/* set node_bits_length */
	json_object_int_add(jo_root, "nodeBitsLength", loc->node_bits_length);

	/* set function_bits_length */
	json_object_int_add(jo_root, "functionBitsLength",
			    loc->function_bits_length);

	/* set argument_bits_length */
	json_object_int_add(jo_root, "argumentBitsLength",
			    loc->argument_bits_length);

	/* set true if the locator is a Micro-segment (uSID) locator */
	if (CHECK_FLAG(loc->flags, SRV6_LOCATOR_USID))
		json_object_string_add(jo_root, "behavior", "usid");

	/* set algonum */
	json_object_int_add(jo_root, "algoNum", loc->algonum);

	/* set status_up */
	json_object_boolean_add(jo_root, "statusUp", loc->status_up);

	/* set chunks */
	jo_chunks = json_object_new_array();
	json_object_object_add(jo_root, "chunks", jo_chunks);
	for (ALL_LIST_ELEMENTS_RO((struct list *)loc->chunks, node, chunk)) {
		jo_chunk = srv6_locator_chunk_detailed_json(chunk);
		json_object_array_add(jo_chunks, jo_chunk);
	}

	return jo_root;
}
Commit	Line	Data
acddc0ed	1	// SPDX-License-Identifier: GPL-2.0-or-later
e496b420 HS	2	/*
	3	* SRv6 definitions
	4	* Copyright (C) 2020 Hiroki Shirokura, LINE Corporation
e496b420 HS	5	*/
e496b420 HS	6
7309092b DL	7	#include "zebra.h"
7309092b DL	8
e496b420 HS	9	#include "srv6.h"
	10	#include "log.h"
	11
f2867068 HS	12	DEFINE_QOBJ_TYPE(srv6_locator);
	13	DEFINE_MTYPE_STATIC(LIB, SRV6_LOCATOR, "SRV6 locator");
	14	DEFINE_MTYPE_STATIC(LIB, SRV6_LOCATOR_CHUNK, "SRV6 locator chunk");
	15
e496b420 HS	16	const char *seg6local_action2str(uint32_t action)
	17	{
	18	switch (action) {
	19	case ZEBRA_SEG6_LOCAL_ACTION_END:
	20	return "End";
	21	case ZEBRA_SEG6_LOCAL_ACTION_END_X:
	22	return "End.X";
	23	case ZEBRA_SEG6_LOCAL_ACTION_END_T:
	24	return "End.T";
	25	case ZEBRA_SEG6_LOCAL_ACTION_END_DX2:
	26	return "End.DX2";
	27	case ZEBRA_SEG6_LOCAL_ACTION_END_DX6:
	28	return "End.DX6";
	29	case ZEBRA_SEG6_LOCAL_ACTION_END_DX4:
	30	return "End.DX4";
	31	case ZEBRA_SEG6_LOCAL_ACTION_END_DT6:
	32	return "End.DT6";
	33	case ZEBRA_SEG6_LOCAL_ACTION_END_DT4:
	34	return "End.DT4";
	35	case ZEBRA_SEG6_LOCAL_ACTION_END_B6:
	36	return "End.B6";
	37	case ZEBRA_SEG6_LOCAL_ACTION_END_B6_ENCAP:
	38	return "End.B6.Encap";
	39	case ZEBRA_SEG6_LOCAL_ACTION_END_BM:
	40	return "End.BM";
	41	case ZEBRA_SEG6_LOCAL_ACTION_END_S:
	42	return "End.S";
	43	case ZEBRA_SEG6_LOCAL_ACTION_END_AS:
	44	return "End.AS";
	45	case ZEBRA_SEG6_LOCAL_ACTION_END_AM:
	46	return "End.AM";
8bea07e4 CS	47	case ZEBRA_SEG6_LOCAL_ACTION_END_DT46:
8bea07e4 CS	48	return "End.DT46";
e496b420 HS	49	case ZEBRA_SEG6_LOCAL_ACTION_UNSPEC:
	50	return "unspec";
	51	default:
	52	return "unknown";
	53	}
	54	}
	55
	56	int snprintf_seg6_segs(char *str,
	57	size_t size, const struct seg6_segs *segs)
	58	{
	59	str[0] = '\0';
	60	for (size_t i = 0; i < segs->num_segs; i++) {
	61	char addr[INET6_ADDRSTRLEN];
	62	bool not_last = (i + 1) < segs->num_segs;
	63
	64	inet_ntop(AF_INET6, &segs->segs[i], addr, sizeof(addr));
	65	strlcat(str, addr, size);
	66	strlcat(str, not_last ? "," : "", size);
	67	}
	68	return strlen(str);
	69	}
	70
	71	const char seg6local_context2str(char str, size_t size,
7a4b49bd HS	72	const struct seg6local_context *ctx,
7a4b49bd HS	73	uint32_t action)
e496b420	74	{
e496b420 HS	75	switch (action) {
	76
	77	case ZEBRA_SEG6_LOCAL_ACTION_END:
	78	snprintf(str, size, "USP");
	79	return str;
	80
	81	case ZEBRA_SEG6_LOCAL_ACTION_END_X:
	82	case ZEBRA_SEG6_LOCAL_ACTION_END_DX6:
84410eb0	83	snprintfrr(str, size, "nh6 %pI6", &ctx->nh6);
e496b420 HS	84	return str;
	85
	86	case ZEBRA_SEG6_LOCAL_ACTION_END_DX4:
84410eb0	87	snprintfrr(str, size, "nh4 %pI4", &ctx->nh4);
e496b420 HS	88	return str;
	89
	90	case ZEBRA_SEG6_LOCAL_ACTION_END_T:
	91	case ZEBRA_SEG6_LOCAL_ACTION_END_DT6:
	92	case ZEBRA_SEG6_LOCAL_ACTION_END_DT4:
8bea07e4	93	case ZEBRA_SEG6_LOCAL_ACTION_END_DT46:
e496b420 HS	94	snprintf(str, size, "table %u", ctx->table);
	95	return str;
	96
	97	case ZEBRA_SEG6_LOCAL_ACTION_END_DX2:
	98	case ZEBRA_SEG6_LOCAL_ACTION_END_B6:
	99	case ZEBRA_SEG6_LOCAL_ACTION_END_B6_ENCAP:
	100	case ZEBRA_SEG6_LOCAL_ACTION_END_BM:
	101	case ZEBRA_SEG6_LOCAL_ACTION_END_S:
	102	case ZEBRA_SEG6_LOCAL_ACTION_END_AS:
	103	case ZEBRA_SEG6_LOCAL_ACTION_END_AM:
	104	case ZEBRA_SEG6_LOCAL_ACTION_UNSPEC:
	105	default:
	106	snprintf(str, size, "unknown(%s)", __func__);
	107	return str;
	108	}
	109	}
f2867068	110
1fec35c3 DS	111	static void srv6_locator_chunk_list_free(void *data)
	112	{
	113	struct srv6_locator_chunk *chunk = data;
	114
	115	srv6_locator_chunk_free(&chunk);
	116	}
	117
f2867068 HS	118	struct srv6_locator srv6_locator_alloc(const char name)
	119	{
	120	struct srv6_locator *locator = NULL;
	121
	122	locator = XCALLOC(MTYPE_SRV6_LOCATOR, sizeof(struct srv6_locator));
	123	strlcpy(locator->name, name, sizeof(locator->name));
	124	locator->chunks = list_new();
1fec35c3	125	locator->chunks->del = srv6_locator_chunk_list_free;
4b220ad0	126
f2867068 HS	127	QOBJ_REG(locator, srv6_locator);
	128	return locator;
	129	}
	130
	131	struct srv6_locator_chunk *srv6_locator_chunk_alloc(void)
	132	{
	133	struct srv6_locator_chunk *chunk = NULL;
	134
	135	chunk = XCALLOC(MTYPE_SRV6_LOCATOR_CHUNK,
	136	sizeof(struct srv6_locator_chunk));
	137	return chunk;
	138	}
	139
	140	void srv6_locator_free(struct srv6_locator *locator)
	141	{
4b220ad0 MS	142	if (locator) {
	143	QOBJ_UNREG(locator);
	144	list_delete(&locator->chunks);
	145
	146	XFREE(MTYPE_SRV6_LOCATOR, locator);
	147	}
f2867068 HS	148	}
f2867068 HS	149
69467313	150	void srv6_locator_chunk_free(struct srv6_locator_chunk **chunk)
f2867068	151	{
69467313	152	XFREE(MTYPE_SRV6_LOCATOR_CHUNK, *chunk);
f2867068 HS	153	}
	154
	155	json_object srv6_locator_chunk_json(const struct srv6_locator_chunk chunk)
	156	{
f2867068 HS	157	json_object *jo_root = NULL;
	158
	159	jo_root = json_object_new_object();
a6c86424	160	json_object_string_addf(jo_root, "prefix", "%pFX", &chunk->prefix);
f2867068 HS	161	json_object_string_add(jo_root, "proto",
	162	zebra_route_string(chunk->proto));
	163
	164	return jo_root;
	165	}
	166
559f4b2f YS	167	json_object *
	168	srv6_locator_chunk_detailed_json(const struct srv6_locator_chunk *chunk)
	169	{
	170	json_object *jo_root = NULL;
	171
	172	jo_root = json_object_new_object();
	173
	174	/* set prefix */
	175	json_object_string_addf(jo_root, "prefix", "%pFX", &chunk->prefix);
	176
	177	/* set block_bits_length */
	178	json_object_int_add(jo_root, "blockBitsLength",
	179	chunk->block_bits_length);
	180
	181	/* set node_bits_length */
	182	json_object_int_add(jo_root, "nodeBitsLength", chunk->node_bits_length);
	183
	184	/* set function_bits_length */
	185	json_object_int_add(jo_root, "functionBitsLength",
	186	chunk->function_bits_length);
	187
	188	/* set argument_bits_length */
	189	json_object_int_add(jo_root, "argumentBitsLength",
	190	chunk->argument_bits_length);
	191
	192	/* set keep */
	193	json_object_int_add(jo_root, "keep", chunk->keep);
	194
	195	/* set proto */
	196	json_object_string_add(jo_root, "proto",
	197	zebra_route_string(chunk->proto));
	198
	199	/* set instance */
	200	json_object_int_add(jo_root, "instance", chunk->instance);
	201
	202	/* set session_id */
	203	json_object_int_add(jo_root, "sessionId", chunk->session_id);
	204
	205	return jo_root;
	206	}
	207
f2867068 HS	208	json_object srv6_locator_json(const struct srv6_locator loc)
f2867068 HS	209	{
f2867068 HS	210	struct listnode *node;
	211	struct srv6_locator_chunk *chunk;
	212	json_object *jo_root = NULL;
	213	json_object *jo_chunk = NULL;
	214	json_object *jo_chunks = NULL;
	215
	216	jo_root = json_object_new_object();
	217
	218	/* set name */
	219	json_object_string_add(jo_root, "name", loc->name);
	220
	221	/* set prefix */
a6c86424	222	json_object_string_addf(jo_root, "prefix", "%pFX", &loc->prefix);
f2867068	223
696f4370 CS	224	/* set block_bits_length */
	225	json_object_int_add(jo_root, "blockBitsLength", loc->block_bits_length);
	226
	227	/* set node_bits_length */
	228	json_object_int_add(jo_root, "nodeBitsLength", loc->node_bits_length);
	229
f2867068	230	/* set function_bits_length */
326591dc	231	json_object_int_add(jo_root, "functionBitsLength",
f2867068 HS	232	loc->function_bits_length);
f2867068 HS	233
696f4370 CS	234	/* set argument_bits_length */
	235	json_object_int_add(jo_root, "argumentBitsLength",
	236	loc->argument_bits_length);
	237
a3ff3dff CS	238	/* set true if the locator is a Micro-segment (uSID) locator */
	239	if (CHECK_FLAG(loc->flags, SRV6_LOCATOR_USID))
	240	json_object_string_add(jo_root, "behavior", "usid");
	241
f2867068	242	/* set status_up */
326591dc	243	json_object_boolean_add(jo_root, "statusUp",
f2867068 HS	244	loc->status_up);
	245
	246	/* set chunks */
	247	jo_chunks = json_object_new_array();
	248	json_object_object_add(jo_root, "chunks", jo_chunks);
	249	for (ALL_LIST_ELEMENTS_RO((struct list *)loc->chunks, node, chunk)) {
	250	jo_chunk = srv6_locator_chunk_json(chunk);
	251	json_object_array_add(jo_chunks, jo_chunk);
	252	}
	253
	254	return jo_root;
	255	}
559f4b2f YS	256
	257	json_object srv6_locator_detailed_json(const struct srv6_locator loc)
	258	{
	259	struct listnode *node;
	260	struct srv6_locator_chunk *chunk;
	261	json_object *jo_root = NULL;
	262	json_object *jo_chunk = NULL;
	263	json_object *jo_chunks = NULL;
	264
	265	jo_root = json_object_new_object();
	266
	267	/* set name */
	268	json_object_string_add(jo_root, "name", loc->name);
	269
	270	/* set prefix */
	271	json_object_string_addf(jo_root, "prefix", "%pFX", &loc->prefix);
	272
	273	/* set block_bits_length */
	274	json_object_int_add(jo_root, "blockBitsLength", loc->block_bits_length);
	275
	276	/* set node_bits_length */
	277	json_object_int_add(jo_root, "nodeBitsLength", loc->node_bits_length);
	278
	279	/* set function_bits_length */
	280	json_object_int_add(jo_root, "functionBitsLength",
	281	loc->function_bits_length);
	282
	283	/* set argument_bits_length */
	284	json_object_int_add(jo_root, "argumentBitsLength",
	285	loc->argument_bits_length);
	286
a3ff3dff CS	287	/* set true if the locator is a Micro-segment (uSID) locator */
	288	if (CHECK_FLAG(loc->flags, SRV6_LOCATOR_USID))
	289	json_object_string_add(jo_root, "behavior", "usid");
	290
559f4b2f YS	291	/* set algonum */
	292	json_object_int_add(jo_root, "algoNum", loc->algonum);
	293
	294	/* set status_up */
	295	json_object_boolean_add(jo_root, "statusUp", loc->status_up);
	296
	297	/* set chunks */
	298	jo_chunks = json_object_new_array();
	299	json_object_object_add(jo_root, "chunks", jo_chunks);
	300	for (ALL_LIST_ELEMENTS_RO((struct list *)loc->chunks, node, chunk)) {
	301	jo_chunk = srv6_locator_chunk_detailed_json(chunk);
	302	json_object_array_add(jo_chunks, jo_chunk);
	303	}
	304
	305	return jo_root;
	306	}