[mirror_frr.git] / zebra / label_manager.c

/*
 * Label Manager for FRR
 *
 * Copyright (C) 2017 by Bingen Eguzkitza,
 *                       Volta Networks Inc.
 *
 * This file is part of FreeRangeRouting (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 <stdio.h>
#include <string.h>
#include <sys/types.h>

#include "lib/log.h"
#include "lib/memory.h"
#include "lib/mpls.h"
#include "lib/network.h"
#include "lib/stream.h"
#include "lib/zclient.h"
#include "lib/libfrr.h"

#include "zebra/zserv.h"
#include "zebra/label_manager.h"
#include "zebra/zebra_errors.h"

#define CONNECTION_DELAY 5

struct label_manager lbl_mgr;

extern struct zebra_privs_t zserv_privs;

DEFINE_MGROUP(LBL_MGR, "Label Manager");
DEFINE_MTYPE_STATIC(LBL_MGR, LM_CHUNK, "Label Manager Chunk");

/* In case this zebra daemon is not acting as label manager,
 * it will be a proxy to relay messages to external label manager
 * This zclient thus is to connect to it
 */
static struct stream *obuf;
static struct zclient *zclient;
bool lm_is_external;

static void delete_label_chunk(void *val)
{
	XFREE(MTYPE_LM_CHUNK, val);
}

static int relay_response_back(void)
{
	int ret = 0;
	struct stream *src, *dst;
	uint16_t size = 0;
	uint8_t marker;
	uint8_t version;
	vrf_id_t vrf_id;
	uint16_t resp_cmd;
	uint8_t proto;
	const char *proto_str;
	unsigned short instance;
	struct zserv *zserv;

	/* input buffer with msg from label manager */
	src = zclient->ibuf;

	stream_reset(src);

	/* parse header */
	ret = zclient_read_header(src, zclient->sock, &size, &marker, &version,
				  &vrf_id, &resp_cmd);
	if (ret < 0 && errno != EAGAIN) {
		flog_err(EC_ZEBRA_LM_RESPONSE,
			 "Error reading Label Manager response: %s",
			 strerror(errno));
		return -1;
	}
	zlog_debug("Label Manager response received, %d bytes", size);
	if (size == 0)
		return -1;

	/* Get the 'proto' field of the message */
	proto = stream_getc(src);

	/* Get the 'instance' field of the message */
	instance = stream_getw(src);

	proto_str = zebra_route_string(proto);

	/* lookup the client to relay the msg to */
	zserv = zserv_find_client(proto, instance);
	if (!zserv) {
		flog_err(
			EC_ZEBRA_LM_NO_SUCH_CLIENT,
			"Error relaying LM response: can't find client %s, instance %u",
			proto_str, instance);
		return -1;
	}
	zlog_debug("Found client to relay LM response to client %s instance %u",
		   proto_str, instance);

	/* copy msg into output buffer */
	dst = obuf;
	stream_copy(dst, src);

	/* send response back */
	ret = writen(zserv->sock, dst->data, stream_get_endp(dst));
	if (ret <= 0) {
		flog_err(EC_ZEBRA_LM_RELAY_FAILED,
			 "Error relaying LM response to %s instance %u: %s",
			 proto_str, instance, strerror(errno));
		return -1;
	}
	zlog_debug("Relayed LM response (%d bytes) to %s instance %u", ret,
		   proto_str, instance);

	return 0;
}

static int lm_zclient_read(struct thread *t)
{
	int ret;

	zclient->t_read = NULL;

	/* read response and send it back */
	ret = relay_response_back();

	return ret;
}

static int reply_error(int cmd, struct zserv *zserv, vrf_id_t vrf_id)
{
	int ret;
	struct stream *s;

	s = stream_new(ZEBRA_MAX_PACKET_SIZ);

	zclient_create_header(s, cmd, vrf_id);

	/* proto */
	stream_putc(s, zserv->proto);
	/* instance */
	stream_putw(s, zserv->instance);
	/* result */
	stream_putc(s, 1);

	/* Write packet size. */
	stream_putw_at(s, 0, stream_get_endp(s));

	ret = writen(zserv->sock, s->data, stream_get_endp(s));

	stream_free(s);
	return ret;
}
/**
 * Receive a request to get or release a label chunk and forward it to external
 * label manager.
 *
 * It's called from zserv in case it's not an actual label manager, but just a
 * proxy.
 *
 * @param cmd Type of request (connect, get or release)
 * @param zserv
 * @return 0 on success, -1 otherwise
 */
int zread_relay_label_manager_request(int cmd, struct zserv *zserv,
				      struct stream *msg, vrf_id_t vrf_id)
{
	struct stream *dst;
	int ret = 0;
	uint8_t proto;
	const char *proto_str;
	unsigned short instance;

	if (zclient->sock < 0) {
		flog_err(EC_ZEBRA_LM_NO_SOCKET,
			 "Unable to relay LM request: no socket");
		reply_error(cmd, zserv, vrf_id);
		return -1;
	}

	/* peek msg to get proto and instance id. This zebra, which acts as
	 * a proxy needs to have such values for each client in order to
	 * relay responses back to it.
	 */

	/* Get the 'proto' field of incoming msg */
	proto = stream_getc(msg);

	/* Get the 'instance' field of incoming msg */
	instance = stream_getw(msg);

	/* stringify proto */
	proto_str = zebra_route_string(proto);

	/* check & set client proto if unset */
	if (zserv->proto && zserv->proto != proto) {
		flog_warn(EC_ZEBRAING_LM_PROTO_MISMATCH,
			  "Client proto(%u) != msg proto(%u)", zserv->proto,
			  proto);
		return -1;
	}

	/* check & set client instance if unset */
	if (zserv->instance && zserv->instance != instance) {
		flog_err(EC_ZEBRA_LM_BAD_INSTANCE,
			 "Client instance(%u) != msg instance(%u)",
			 zserv->instance, instance);
		return -1;
	}

	/* recall proto and instance */
	zserv->instance = instance;
	zserv->proto = proto;

	/* in case there's any incoming message enqueued, read and forward it */
	while (ret == 0)
		ret = relay_response_back();

	/* get the msg buffer used toward the 'master' Label Manager */
	dst = zclient->obuf;

	/* copy the message */
	stream_copy(dst, msg);

	/* Send request to external label manager */
	ret = writen(zclient->sock, dst->data, stream_get_endp(dst));
	if (ret <= 0) {
		flog_err(EC_ZEBRA_LM_RELAY_FAILED,
			 "Error relaying LM request from %s instance %u: %s",
			 proto_str, instance, strerror(errno));
		reply_error(cmd, zserv, vrf_id);
		return -1;
	}
	zlog_debug("Relayed LM request (%d bytes) from %s instance %u", ret,
		   proto_str, instance);


	/* Release label chunk has no response */
	if (cmd == ZEBRA_RELEASE_LABEL_CHUNK)
		return 0;

	/* make sure we listen to the response */
	if (!zclient->t_read)
		thread_add_read(zclient->master, lm_zclient_read, NULL,
				zclient->sock, &zclient->t_read);

	return 0;
}

static int lm_zclient_connect(struct thread *t)
{
	zclient->t_connect = NULL;

	if (zclient->sock >= 0)
		return 0;

	if (zclient_socket_connect(zclient) < 0) {
		flog_err(EC_ZEBRA_LM_CLIENT_CONNECTION_FAILED,
			 "Error connecting synchronous zclient!");
		thread_add_timer(zebrad.master, lm_zclient_connect, zclient,
				 CONNECTION_DELAY, &zclient->t_connect);
		return -1;
	}

	/* make socket non-blocking */
	(void)set_nonblocking(zclient->sock);

	return 0;
}

/**
 * Function to initialize zclient in case this is not an actual
 * label manager, but just a proxy to an external one.
 *
 * @param lm_zserv_path Path to zserv socket of external label manager
 */
static void lm_zclient_init(char *lm_zserv_path)
{
	if (lm_zserv_path)
		frr_zclient_addr(&zclient_addr, &zclient_addr_len,
				 lm_zserv_path);

	/* Set default values. */
	zclient = zclient_new_notify(zebrad.master, &zclient_options_default);
	zclient->privs = &zserv_privs;
	zclient->sock = -1;
	zclient->t_connect = NULL;
	lm_zclient_connect(NULL);
}

/**
 * Release label chunks from a client.
 *
 * Called on client disconnection or reconnection. It only releases chunks
 * with empty keep value.
 *
 * @param proto Daemon protocol of client, to identify the owner
 * @param instance Instance, to identify the owner
 * @return Number of chunks released
 */
int release_daemon_label_chunks(struct zserv *client)
{
	uint8_t proto = client->proto;
	uint16_t instance = client->instance;
	struct listnode *node;
	struct label_manager_chunk *lmc;
	int count = 0;
	int ret;

	for (ALL_LIST_ELEMENTS_RO(lbl_mgr.lc_list, node, lmc)) {
		if (lmc->proto == proto && lmc->instance == instance
		    && lmc->keep == 0) {
			ret = release_label_chunk(lmc->proto, lmc->instance,
						  lmc->start, lmc->end);
			if (ret == 0)
				count++;
		}
	}

	zlog_debug("%s: Released %d label chunks", __func__, count);

	return count;
}

/**
 * Init label manager (or proxy to an external one)
 */
void label_manager_init(char *lm_zserv_path)
{
	/* this is an actual label manager */
	if (!lm_zserv_path) {
		zlog_debug("Initializing internal label manager");
		lm_is_external = false;
		lbl_mgr.lc_list = list_new();
		lbl_mgr.lc_list->del = delete_label_chunk;
	} else { /* it's acting just as a proxy */
		zlog_debug("Initializing external label manager at %s",
			   lm_zserv_path);
		lm_is_external = true;
		lm_zclient_init(lm_zserv_path);
	}

	obuf = stream_new(ZEBRA_MAX_PACKET_SIZ);

	hook_register(zserv_client_close, release_daemon_label_chunks);
}

/**
 * Core function, assigns label cunks
 *
 * It first searches through the list to check if there's one available
 * (previously released). Otherwise it creates and assigns a new one
 *
 * @param proto Daemon protocol of client, to identify the owner
 * @param instance Instance, to identify the owner
 * @param keep If set, avoid garbage collection
 * @para size Size of the label chunk
 * @return Pointer to the assigned label chunk
 */
struct label_manager_chunk *assign_label_chunk(uint8_t proto,
					       unsigned short instance,
					       uint8_t keep, uint32_t size)
{
	struct label_manager_chunk *lmc;
	struct listnode *node;

	/* first check if there's one available */
	for (ALL_LIST_ELEMENTS_RO(lbl_mgr.lc_list, node, lmc)) {
		if (lmc->proto == NO_PROTO
		    && lmc->end - lmc->start + 1 == size) {
			lmc->proto = proto;
			lmc->instance = instance;
			lmc->keep = keep;
			return lmc;
		}
	}
	/* otherwise create a new one */
	lmc = XCALLOC(MTYPE_LM_CHUNK, sizeof(struct label_manager_chunk));

	if (list_isempty(lbl_mgr.lc_list))
		lmc->start = MPLS_LABEL_UNRESERVED_MIN;
	else
		lmc->start = ((struct label_manager_chunk *)listgetdata(
				      listtail(lbl_mgr.lc_list)))
				     ->end
			     + 1;
	if (lmc->start > MPLS_LABEL_UNRESERVED_MAX - size + 1) {
		flog_err(EC_ZEBRA_LM_EXHAUSTED_LABELS,
			 "Reached max labels. Start: %u, size: %u", lmc->start,
			 size);
		XFREE(MTYPE_LM_CHUNK, lmc);
		return NULL;
	}
	lmc->end = lmc->start + size - 1;
	lmc->proto = proto;
	lmc->instance = instance;
	lmc->keep = keep;
	listnode_add(lbl_mgr.lc_list, lmc);

	return lmc;
}

/**
 * Core function, release no longer used label cunks
 *
 * @param proto Daemon protocol of client, to identify the owner
 * @param instance Instance, to identify the owner
 * @param start First label of the chunk
 * @param end Last label of the chunk
 * @return 0 on success, -1 otherwise
 */
int release_label_chunk(uint8_t proto, unsigned short instance, uint32_t start,
			uint32_t end)
{
	struct listnode *node;
	struct label_manager_chunk *lmc;
	int ret = -1;

	/* check that size matches */
	zlog_debug("Releasing label chunk: %u - %u", start, end);
	/* find chunk and disown */
	for (ALL_LIST_ELEMENTS_RO(lbl_mgr.lc_list, node, lmc)) {
		if (lmc->start != start)
			continue;
		if (lmc->end != end)
			continue;
		if (lmc->proto != proto || lmc->instance != instance) {
			flog_err(EC_ZEBRA_LM_DAEMON_MISMATCH,
				 "%s: Daemon mismatch!!", __func__);
			continue;
		}
		lmc->proto = NO_PROTO;
		lmc->instance = 0;
		lmc->keep = 0;
		ret = 0;
		break;
	}
	if (ret != 0)
		flog_err(EC_ZEBRA_LM_UNRELEASED_CHUNK,
			 "%s: Label chunk not released!!", __func__);

	return ret;
}


void label_manager_close()
{
	list_delete_and_null(&lbl_mgr.lc_list);
	stream_free(obuf);
}
Commit	Line	Data
fea12efb	1	/*
	2	* Label Manager for FRR
	3	*
	4	* Copyright (C) 2017 by Bingen Eguzkitza,
	5	* Volta Networks Inc.
	6	*
	7	* This file is part of FreeRangeRouting (FRR)
	8	*
	9	* FRR is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the
	11	* Free Software Foundation; either version 2, or (at your option) any
	12	* later version.
	13	*
	14	* FRR is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
896014f4 DL	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; see the file COPYING; if not, write to the Free Software
	21	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
fea12efb	22	*/
fea12efb	23
43e52561	24	#include <zebra.h>
fea12efb	25	#include <stdio.h>
	26	#include <string.h>
	27	#include <sys/types.h>
	28
fea12efb	29	#include "lib/log.h"
	30	#include "lib/memory.h"
	31	#include "lib/mpls.h"
	32	#include "lib/network.h"
	33	#include "lib/stream.h"
	34	#include "lib/zclient.h"
689f5a8c	35	#include "lib/libfrr.h"
fea12efb	36
43e52561 QY	37	#include "zebra/zserv.h"
	38	#include "zebra/label_manager.h"
	39	#include "zebra/zebra_errors.h"
fea12efb	40
	41	#define CONNECTION_DELAY 5
	42
	43	struct label_manager lbl_mgr;
	44
7bfe377d	45	extern struct zebra_privs_t zserv_privs;
7bfe377d	46
fea12efb	47	DEFINE_MGROUP(LBL_MGR, "Label Manager");
	48	DEFINE_MTYPE_STATIC(LBL_MGR, LM_CHUNK, "Label Manager Chunk");
	49
	50	/* In case this zebra daemon is not acting as label manager,
	51	* it will be a proxy to relay messages to external label manager
	52	* This zclient thus is to connect to it
	53	*/
1002497a	54	static struct stream *obuf;
fea12efb	55	static struct zclient *zclient;
	56	bool lm_is_external;
	57
	58	static void delete_label_chunk(void *val)
	59	{
	60	XFREE(MTYPE_LM_CHUNK, val);
	61	}
	62
1cbba8ce	63	static int relay_response_back(void)
5c7ef8dc	64	{
	65	int ret = 0;
	66	struct stream src, dst;
d7c0a89a QY	67	uint16_t size = 0;
	68	uint8_t marker;
	69	uint8_t version;
5c7ef8dc	70	vrf_id_t vrf_id;
d7c0a89a	71	uint16_t resp_cmd;
1cbba8ce FR	72	uint8_t proto;
	73	const char *proto_str;
	74	unsigned short instance;
	75	struct zserv *zserv;
5c7ef8dc	76
1cbba8ce	77	/* input buffer with msg from label manager */
5c7ef8dc	78	src = zclient->ibuf;
5c7ef8dc	79
	80	stream_reset(src);
	81
1cbba8ce	82	/* parse header */
5c7ef8dc	83	ret = zclient_read_header(src, zclient->sock, &size, &marker, &version,
d62a17ae	84	&vrf_id, &resp_cmd);
5c7ef8dc	85	if (ret < 0 && errno != EAGAIN) {
e914ccbe	86	flog_err(EC_ZEBRA_LM_RESPONSE,
1c50c1c0 QY	87	"Error reading Label Manager response: %s",
1c50c1c0 QY	88	strerror(errno));
5c7ef8dc	89	return -1;
5c7ef8dc	90	}
1cbba8ce	91	zlog_debug("Label Manager response received, %d bytes", size);
5c7ef8dc	92	if (size == 0)
	93	return -1;
	94
1cbba8ce FR	95	/* Get the 'proto' field of the message */
	96	proto = stream_getc(src);
	97
	98	/* Get the 'instance' field of the message */
	99	instance = stream_getw(src);
	100
	101	proto_str = zebra_route_string(proto);
	102
	103	/* lookup the client to relay the msg to */
c0ea1ae7	104	zserv = zserv_find_client(proto, instance);
1cbba8ce	105	if (!zserv) {
af4c2728	106	flog_err(
e914ccbe	107	EC_ZEBRA_LM_NO_SUCH_CLIENT,
0313523d FR	108	"Error relaying LM response: can't find client %s, instance %u",
0313523d FR	109	proto_str, instance);
1cbba8ce FR	110	return -1;
1cbba8ce FR	111	}
35cbe02a	112	zlog_debug("Found client to relay LM response to client %s instance %u",
0313523d	113	proto_str, instance);
1cbba8ce FR	114
	115	/* copy msg into output buffer */
	116	dst = obuf;
5c7ef8dc	117	stream_copy(dst, src);
1cbba8ce FR	118
1cbba8ce FR	119	/* send response back */
881999e6	120	ret = writen(zserv->sock, dst->data, stream_get_endp(dst));
5c7ef8dc	121	if (ret <= 0) {
e914ccbe	122	flog_err(EC_ZEBRA_LM_RELAY_FAILED,
1c50c1c0 QY	123	"Error relaying LM response to %s instance %u: %s",
1c50c1c0 QY	124	proto_str, instance, strerror(errno));
5c7ef8dc	125	return -1;
5c7ef8dc	126	}
0313523d FR	127	zlog_debug("Relayed LM response (%d bytes) to %s instance %u", ret,
0313523d FR	128	proto_str, instance);
5c7ef8dc	129
	130	return 0;
	131	}
	132
	133	static int lm_zclient_read(struct thread *t)
	134	{
5c7ef8dc	135	int ret;
5c7ef8dc	136
5c7ef8dc	137	zclient->t_read = NULL;
	138
	139	/* read response and send it back */
1cbba8ce	140	ret = relay_response_back();
5c7ef8dc	141
	142	return ret;
	143	}
	144
d62a17ae	145	static int reply_error(int cmd, struct zserv *zserv, vrf_id_t vrf_id)
5c7ef8dc	146	{
1002497a	147	int ret;
5c7ef8dc	148	struct stream *s;
5c7ef8dc	149
1002497a	150	s = stream_new(ZEBRA_MAX_PACKET_SIZ);
5c7ef8dc	151
7cf15b25	152	zclient_create_header(s, cmd, vrf_id);
5c7ef8dc	153
1cbba8ce FR	154	/* proto */
	155	stream_putc(s, zserv->proto);
	156	/* instance */
	157	stream_putw(s, zserv->instance);
5c7ef8dc	158	/* result */
d62a17ae	159	stream_putc(s, 1);
5c7ef8dc	160
5c7ef8dc	161	/* Write packet size. */
d62a17ae	162	stream_putw_at(s, 0, stream_get_endp(s));
5c7ef8dc	163
1002497a QY	164	ret = writen(zserv->sock, s->data, stream_get_endp(s));
	165
	166	stream_free(s);
	167	return ret;
5c7ef8dc	168	}
fea12efb	169	/**
	170	* Receive a request to get or release a label chunk and forward it to external
	171	* label manager.
	172	*
	173	* It's called from zserv in case it's not an actual label manager, but just a
	174	* proxy.
	175	*
	176	* @param cmd Type of request (connect, get or release)
5c7ef8dc	177	* @param zserv
fea12efb	178	* @return 0 on success, -1 otherwise
fea12efb	179	*/
d62a17ae	180	int zread_relay_label_manager_request(int cmd, struct zserv *zserv,
0313523d	181	struct stream *msg, vrf_id_t vrf_id)
fea12efb	182	{
1cbba8ce	183	struct stream *dst;
5c7ef8dc	184	int ret = 0;
1cbba8ce FR	185	uint8_t proto;
	186	const char *proto_str;
	187	unsigned short instance;
fea12efb	188
fea12efb	189	if (zclient->sock < 0) {
e914ccbe	190	flog_err(EC_ZEBRA_LM_NO_SOCKET,
1c50c1c0	191	"Unable to relay LM request: no socket");
d62a17ae	192	reply_error(cmd, zserv, vrf_id);
fea12efb	193	return -1;
fea12efb	194	}
5c7ef8dc	195
1cbba8ce FR	196	/* peek msg to get proto and instance id. This zebra, which acts as
	197	* a proxy needs to have such values for each client in order to
	198	* relay responses back to it.
	199	*/
	200
	201	/* Get the 'proto' field of incoming msg */
	202	proto = stream_getc(msg);
	203
	204	/* Get the 'instance' field of incoming msg */
	205	instance = stream_getw(msg);
	206
	207	/* stringify proto */
	208	proto_str = zebra_route_string(proto);
	209
	210	/* check & set client proto if unset */
	211	if (zserv->proto && zserv->proto != proto) {
e914ccbe	212	flog_warn(EC_ZEBRAING_LM_PROTO_MISMATCH,
9df414fe	213	"Client proto(%u) != msg proto(%u)", zserv->proto,
0313523d	214	proto);
1cbba8ce FR	215	return -1;
	216	}
	217
	218	/* check & set client instance if unset */
	219	if (zserv->instance && zserv->instance != instance) {
e914ccbe	220	flog_err(EC_ZEBRA_LM_BAD_INSTANCE,
1c50c1c0 QY	221	"Client instance(%u) != msg instance(%u)",
1c50c1c0 QY	222	zserv->instance, instance);
1cbba8ce FR	223	return -1;
	224	}
	225
	226	/* recall proto and instance */
	227	zserv->instance = instance;
	228	zserv->proto = proto;
	229
5c7ef8dc	230	/* in case there's any incoming message enqueued, read and forward it */
5c7ef8dc	231	while (ret == 0)
1cbba8ce	232	ret = relay_response_back();
5c7ef8dc	233
1cbba8ce	234	/* get the msg buffer used toward the 'master' Label Manager */
fea12efb	235	dst = zclient->obuf;
fea12efb	236
1cbba8ce FR	237	/* copy the message */
1cbba8ce FR	238	stream_copy(dst, msg);
fea12efb	239
1cbba8ce	240	/* Send request to external label manager */
fea12efb	241	ret = writen(zclient->sock, dst->data, stream_get_endp(dst));
fea12efb	242	if (ret <= 0) {
e914ccbe	243	flog_err(EC_ZEBRA_LM_RELAY_FAILED,
1c50c1c0 QY	244	"Error relaying LM request from %s instance %u: %s",
1c50c1c0 QY	245	proto_str, instance, strerror(errno));
d62a17ae	246	reply_error(cmd, zserv, vrf_id);
fea12efb	247	return -1;
fea12efb	248	}
0313523d FR	249	zlog_debug("Relayed LM request (%d bytes) from %s instance %u", ret,
0313523d FR	250	proto_str, instance);
1cbba8ce	251
fea12efb	252
	253	/* Release label chunk has no response */
	254	if (cmd == ZEBRA_RELEASE_LABEL_CHUNK)
	255	return 0;
	256
5c7ef8dc	257	/* make sure we listen to the response */
5c7ef8dc	258	if (!zclient->t_read)
1cbba8ce	259	thread_add_read(zclient->master, lm_zclient_read, NULL,
d62a17ae	260	zclient->sock, &zclient->t_read);
fea12efb	261
	262	return 0;
	263	}
	264
5c7ef8dc	265	static int lm_zclient_connect(struct thread *t)
fea12efb	266	{
	267	zclient->t_connect = NULL;
	268
	269	if (zclient->sock >= 0)
	270	return 0;
	271
	272	if (zclient_socket_connect(zclient) < 0) {
e914ccbe	273	flog_err(EC_ZEBRA_LM_CLIENT_CONNECTION_FAILED,
1c50c1c0	274	"Error connecting synchronous zclient!");
fa84d193	275	thread_add_timer(zebrad.master, lm_zclient_connect, zclient,
ffa2c898	276	CONNECTION_DELAY, &zclient->t_connect);
fea12efb	277	return -1;
	278	}
	279
5c7ef8dc	280	/* make socket non-blocking */
9df414fe	281	(void)set_nonblocking(zclient->sock);
5c7ef8dc	282
fea12efb	283	return 0;
	284	}
	285
	286	/**
	287	* Function to initialize zclient in case this is not an actual
	288	* label manager, but just a proxy to an external one.
	289	*
	290	* @param lm_zserv_path Path to zserv socket of external label manager
	291	*/
	292	static void lm_zclient_init(char *lm_zserv_path)
	293	{
	294	if (lm_zserv_path)
689f5a8c DL	295	frr_zclient_addr(&zclient_addr, &zclient_addr_len,
689f5a8c DL	296	lm_zserv_path);
fea12efb	297
fea12efb	298	/* Set default values. */
e1a1880d	299	zclient = zclient_new_notify(zebrad.master, &zclient_options_default);
7bfe377d	300	zclient->privs = &zserv_privs;
fea12efb	301	zclient->sock = -1;
fea12efb	302	zclient->t_connect = NULL;
5c7ef8dc	303	lm_zclient_connect(NULL);
fea12efb	304	}
fea12efb	305
453844ab QY	306	/**
	307	* Release label chunks from a client.
	308	*
	309	* Called on client disconnection or reconnection. It only releases chunks
	310	* with empty keep value.
	311	*
	312	* @param proto Daemon protocol of client, to identify the owner
	313	* @param instance Instance, to identify the owner
	314	* @return Number of chunks released
	315	*/
	316	int release_daemon_label_chunks(struct zserv *client)
	317	{
	318	uint8_t proto = client->proto;
	319	uint16_t instance = client->instance;
	320	struct listnode *node;
	321	struct label_manager_chunk *lmc;
	322	int count = 0;
	323	int ret;
	324
	325	for (ALL_LIST_ELEMENTS_RO(lbl_mgr.lc_list, node, lmc)) {
	326	if (lmc->proto == proto && lmc->instance == instance
	327	&& lmc->keep == 0) {
	328	ret = release_label_chunk(lmc->proto, lmc->instance,
	329	lmc->start, lmc->end);
	330	if (ret == 0)
	331	count++;
	332	}
	333	}
	334
	335	zlog_debug("%s: Released %d label chunks", __func__, count);
	336
	337	return count;
	338	}
	339
fea12efb	340	/**
	341	* Init label manager (or proxy to an external one)
	342	*/
	343	void label_manager_init(char *lm_zserv_path)
	344	{
	345	/* this is an actual label manager */
	346	if (!lm_zserv_path) {
35cbe02a	347	zlog_debug("Initializing internal label manager");
fea12efb	348	lm_is_external = false;
	349	lbl_mgr.lc_list = list_new();
	350	lbl_mgr.lc_list->del = delete_label_chunk;
d62a17ae	351	} else { /* it's acting just as a proxy */
fea12efb	352	zlog_debug("Initializing external label manager at %s",
	353	lm_zserv_path);
	354	lm_is_external = true;
	355	lm_zclient_init(lm_zserv_path);
	356	}
1002497a	357
1002497a	358	obuf = stream_new(ZEBRA_MAX_PACKET_SIZ);
453844ab	359
21ccc0cf	360	hook_register(zserv_client_close, release_daemon_label_chunks);
fea12efb	361	}
	362
	363	/**
	364	* Core function, assigns label cunks
	365	*
	366	* It first searches through the list to check if there's one available
	367	* (previously released). Otherwise it creates and assigns a new one
	368	*
	369	* @param proto Daemon protocol of client, to identify the owner
	370	* @param instance Instance, to identify the owner
	371	* @param keep If set, avoid garbage collection
	372	* @para size Size of the label chunk
	373	* @return Pointer to the assigned label chunk
	374	*/
d7c0a89a QY	375	struct label_manager_chunk *assign_label_chunk(uint8_t proto,
	376	unsigned short instance,
	377	uint8_t keep, uint32_t size)
fea12efb	378	{
	379	struct label_manager_chunk *lmc;
	380	struct listnode *node;
	381
fea12efb	382	/* first check if there's one available */
fea12efb	383	for (ALL_LIST_ELEMENTS_RO(lbl_mgr.lc_list, node, lmc)) {
d62a17ae	384	if (lmc->proto == NO_PROTO
d62a17ae	385	&& lmc->end - lmc->start + 1 == size) {
fea12efb	386	lmc->proto = proto;
	387	lmc->instance = instance;
	388	lmc->keep = keep;
	389	return lmc;
	390	}
	391	}
	392	/* otherwise create a new one */
	393	lmc = XCALLOC(MTYPE_LM_CHUNK, sizeof(struct label_manager_chunk));
	394
	395	if (list_isempty(lbl_mgr.lc_list))
70e98a7f	396	lmc->start = MPLS_LABEL_UNRESERVED_MIN;
fea12efb	397	else
d62a17ae	398	lmc->start = ((struct label_manager_chunk *)listgetdata(
	399	listtail(lbl_mgr.lc_list)))
	400	->end
	401	+ 1;
70e98a7f	402	if (lmc->start > MPLS_LABEL_UNRESERVED_MAX - size + 1) {
e914ccbe	403	flog_err(EC_ZEBRA_LM_EXHAUSTED_LABELS,
1c50c1c0 QY	404	"Reached max labels. Start: %u, size: %u", lmc->start,
1c50c1c0 QY	405	size);
d62a17ae	406	XFREE(MTYPE_LM_CHUNK, lmc);
fea12efb	407	return NULL;
	408	}
	409	lmc->end = lmc->start + size - 1;
	410	lmc->proto = proto;
	411	lmc->instance = instance;
	412	lmc->keep = keep;
	413	listnode_add(lbl_mgr.lc_list, lmc);
	414
	415	return lmc;
	416	}
	417
	418	/**
	419	* Core function, release no longer used label cunks
	420	*
	421	* @param proto Daemon protocol of client, to identify the owner
	422	* @param instance Instance, to identify the owner
	423	* @param start First label of the chunk
	424	* @param end Last label of the chunk
	425	* @return 0 on success, -1 otherwise
	426	*/
d7c0a89a	427	int release_label_chunk(uint8_t proto, unsigned short instance, uint32_t start,
d62a17ae	428	uint32_t end)
fea12efb	429	{
	430	struct listnode *node;
	431	struct label_manager_chunk *lmc;
	432	int ret = -1;
	433
	434	/* check that size matches */
	435	zlog_debug("Releasing label chunk: %u - %u", start, end);
	436	/* find chunk and disown */
	437	for (ALL_LIST_ELEMENTS_RO(lbl_mgr.lc_list, node, lmc)) {
	438	if (lmc->start != start)
	439	continue;
	440	if (lmc->end != end)
	441	continue;
	442	if (lmc->proto != proto \|\| lmc->instance != instance) {
e914ccbe	443	flog_err(EC_ZEBRA_LM_DAEMON_MISMATCH,
1c50c1c0	444	"%s: Daemon mismatch!!", __func__);
fea12efb	445	continue;
	446	}
	447	lmc->proto = NO_PROTO;
	448	lmc->instance = 0;
	449	lmc->keep = 0;
	450	ret = 0;
	451	break;
	452	}
	453	if (ret != 0)
e914ccbe	454	flog_err(EC_ZEBRA_LM_UNRELEASED_CHUNK,
1c50c1c0	455	"%s: Label chunk not released!!", __func__);
fea12efb	456
	457	return ret;
	458	}
	459
fea12efb	460
	461	void label_manager_close()
	462	{
affe9e99	463	list_delete_and_null(&lbl_mgr.lc_list);
1002497a	464	stream_free(obuf);
fea12efb	465	}