[mirror_frr.git] / lib / distribute.c

/* Distribute list functions
 * Copyright (C) 1998, 1999 Kunihiro Ishiguro
 *
 * 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 "hash.h"
#include "if.h"
#include "filter.h"
#include "command.h"
#include "distribute.h"
#include "memory.h"

DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_CTX, "Distribute ctx");
DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE, "Distribute list");
DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_IFNAME, "Dist-list ifname");
DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_NAME, "Dist-list name");

static struct list *dist_ctx_list;

static struct distribute *distribute_new(void)
{
	return XCALLOC(MTYPE_DISTRIBUTE, sizeof(struct distribute));
}

/* Free distribute object. */
static void distribute_free(struct distribute *dist)
{
	int i = 0;

	XFREE(MTYPE_DISTRIBUTE_IFNAME, dist->ifname);

	for (i = 0; i < DISTRIBUTE_MAX; i++) {
		XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[i]);
	}

	for (i = 0; i < DISTRIBUTE_MAX; i++) {
		XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[i]);
	}

	XFREE(MTYPE_DISTRIBUTE, dist);
}

static void distribute_free_if_empty(struct distribute_ctx *ctx,
				     struct distribute *dist)
{
	int i;

	for (i = 0; i < DISTRIBUTE_MAX; i++)
		if (dist->list[i] != NULL || dist->prefix[i] != NULL)
			return;

	hash_release(ctx->disthash, dist);
	distribute_free(dist);
}

/* Lookup interface's distribute list. */
struct distribute *distribute_lookup(struct distribute_ctx *ctx,
				     const char *ifname)
{
	struct distribute key;
	struct distribute *dist;

	/* temporary reference */
	key.ifname = (ifname) ? XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, ifname) : NULL;

	dist = hash_lookup(ctx->disthash, &key);

	XFREE(MTYPE_DISTRIBUTE_IFNAME, key.ifname);

	return dist;
}

void distribute_list_add_hook(struct distribute_ctx *ctx,
			      void (*func)(struct distribute_ctx *ctx,
					   struct distribute *))
{
	ctx->distribute_add_hook = func;
}

void distribute_list_delete_hook(struct distribute_ctx *ctx,
				 void (*func)(struct distribute_ctx *ctx,
					      struct distribute *))
{
	ctx->distribute_delete_hook = func;
}

static void *distribute_hash_alloc(struct distribute *arg)
{
	struct distribute *dist;

	dist = distribute_new();
	if (arg->ifname)
		dist->ifname = XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, arg->ifname);
	else
		dist->ifname = NULL;
	return dist;
}

/* Make new distribute list and push into hash. */
static struct distribute *distribute_get(struct distribute_ctx *ctx,
					 const char *ifname)
{
	struct distribute key;
	struct distribute *ret;

	/* temporary reference */
	key.ifname = (ifname) ? XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, ifname) : NULL;

	ret = hash_get(ctx->disthash, &key,
		       (void *(*)(void *))distribute_hash_alloc);

	XFREE(MTYPE_DISTRIBUTE_IFNAME, key.ifname);

	return ret;
}

static unsigned int distribute_hash_make(const void *arg)
{
	const struct distribute *dist = arg;

	return dist->ifname ? string_hash_make(dist->ifname) : 0;
}

/* If two distribute-list have same value then return 1 else return
   0. This function is used by hash package. */
static bool distribute_cmp(const struct distribute *dist1,
			  const struct distribute *dist2)
{
	if (dist1->ifname && dist2->ifname)
		if (strcmp(dist1->ifname, dist2->ifname) == 0)
			return true;
	if (!dist1->ifname && !dist2->ifname)
		return true;
	return false;
}

/* Set access-list name to the distribute list. */
static void distribute_list_set(struct distribute_ctx *ctx,
				const char *ifname, enum distribute_type type,
				const char *alist_name)
{
	struct distribute *dist;

	dist = distribute_get(ctx, ifname);

	XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[type]);
	dist->list[type] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, alist_name);

	/* Apply this distribute-list to the interface. */
	(ctx->distribute_add_hook)(ctx, dist);
}

/* Unset distribute-list.  If matched distribute-list exist then
   return 1. */
static int distribute_list_unset(struct distribute_ctx *ctx,
				 const char *ifname,
				 enum distribute_type type,
				 const char *alist_name)
{
	struct distribute *dist;

	dist = distribute_lookup(ctx, ifname);
	if (!dist)
		return 0;

	if (!dist->list[type])
		return 0;
	if (strcmp(dist->list[type], alist_name) != 0)
		return 0;

	XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[type]);

	/* Apply this distribute-list to the interface. */
	(ctx->distribute_delete_hook)(ctx, dist);

	/* If all dist are NULL, then free distribute list. */
	distribute_free_if_empty(ctx, dist);
	return 1;
}

/* Set access-list name to the distribute list. */
static void distribute_list_prefix_set(struct distribute_ctx *ctx,
				       const char *ifname,
				       enum distribute_type type,
				       const char *plist_name)
{
	struct distribute *dist;

	dist = distribute_get(ctx, ifname);

	XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[type]);
	dist->prefix[type] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, plist_name);

	/* Apply this distribute-list to the interface. */
	(ctx->distribute_add_hook)(ctx, dist);
}

/* Unset distribute-list.  If matched distribute-list exist then
   return 1. */
static int distribute_list_prefix_unset(struct distribute_ctx *ctx,
					const char *ifname,
					enum distribute_type type,
					const char *plist_name)
{
	struct distribute *dist;

	dist = distribute_lookup(ctx, ifname);
	if (!dist)
		return 0;

	if (!dist->prefix[type])
		return 0;
	if (strcmp(dist->prefix[type], plist_name) != 0)
		return 0;

	XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[type]);

	/* Apply this distribute-list to the interface. */
	(ctx->distribute_delete_hook)(ctx, dist);

	/* If all dist are NULL, then free distribute list. */
	distribute_free_if_empty(ctx, dist);
	return 1;
}

static enum distribute_type distribute_direction(const char *dir, bool v4)
{
	if (dir[0] == 'i') {
		if (v4)
			return DISTRIBUTE_V4_IN;
		else
			return DISTRIBUTE_V6_IN;
	} else if (dir[0] == 'o') {
		if (v4)
			return DISTRIBUTE_V4_OUT;
		else
			return DISTRIBUTE_V6_OUT;
	}

	assert(!"Expecting in or out only, fix your code");

	__builtin_unreachable();
}

int distribute_list_parser(bool prefix, bool v4, const char *dir,
			   const char *list, const char *ifname)
{
	enum distribute_type type = distribute_direction(dir, v4);
	struct distribute_ctx *ctx = listnode_head(dist_ctx_list);

	void (*distfn)(struct distribute_ctx *, const char *,
		       enum distribute_type, const char *) =
		prefix ? &distribute_list_prefix_set : &distribute_list_set;

	distfn(ctx, ifname, type, list);

	return CMD_SUCCESS;
}

int distribute_list_no_parser(struct vty *vty, bool prefix, bool v4,
			      const char *dir, const char *list,
			      const char *ifname)
{
	enum distribute_type type = distribute_direction(dir, v4);
	struct distribute_ctx *ctx = listnode_head(dist_ctx_list);
	int ret;

	int (*distfn)(struct distribute_ctx *, const char *,
		      enum distribute_type, const char *) =
		prefix ? &distribute_list_prefix_unset : &distribute_list_unset;


	ret = distfn(ctx, ifname, type, list);
	if (!ret) {
		vty_out(vty, "distribute list doesn't exist\n");
		return CMD_WARNING_CONFIG_FAILED;
	}

	return CMD_SUCCESS;
}

static int distribute_print(struct vty *vty, char *tab[], int is_prefix,
			    enum distribute_type type, int has_print)
{
	if (tab[type]) {
		vty_out(vty, "%s %s%s", has_print ? "," : "",
			is_prefix ? "(prefix-list) " : "", tab[type]);
		return 1;
	}
	return has_print;
}

int config_show_distribute(struct vty *vty, struct distribute_ctx *dist_ctxt)
{
	unsigned int i;
	int has_print = 0;
	struct hash_bucket *mp;
	struct distribute *dist;

	/* Output filter configuration. */
	dist = distribute_lookup(dist_ctxt, NULL);
	vty_out(vty, "  Outgoing update filter list for all interface is");
	has_print = 0;
	if (dist) {
		has_print = distribute_print(vty, dist->list, 0,
					     DISTRIBUTE_V4_OUT, has_print);
		has_print = distribute_print(vty, dist->prefix, 1,
					     DISTRIBUTE_V4_OUT, has_print);
		has_print = distribute_print(vty, dist->list, 0,
					     DISTRIBUTE_V6_OUT, has_print);
		has_print = distribute_print(vty, dist->prefix, 1,
					     DISTRIBUTE_V6_OUT, has_print);
	}
	if (has_print)
		vty_out(vty, "\n");
	else
		vty_out(vty, " not set\n");

	for (i = 0; i < dist_ctxt->disthash->size; i++)
		for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
			dist = mp->data;
			if (dist->ifname) {
				vty_out(vty, "    %s filtered by",
					dist->ifname);
				has_print = 0;
				has_print = distribute_print(vty, dist->list, 0,
							     DISTRIBUTE_V4_OUT,
							     has_print);
				has_print = distribute_print(
					vty, dist->prefix, 1, DISTRIBUTE_V4_OUT,
					has_print);
				has_print = distribute_print(vty, dist->list, 0,
							     DISTRIBUTE_V6_OUT,
							     has_print);
				has_print = distribute_print(
					vty, dist->prefix, 1, DISTRIBUTE_V6_OUT,
					has_print);
				if (has_print)
					vty_out(vty, "\n");
				else
					vty_out(vty, " nothing\n");
			}
		}


	/* Input filter configuration. */
	dist = distribute_lookup(dist_ctxt, NULL);
	vty_out(vty, "  Incoming update filter list for all interface is");
	has_print = 0;
	if (dist) {
		has_print = distribute_print(vty, dist->list, 0,
					     DISTRIBUTE_V4_IN, has_print);
		has_print = distribute_print(vty, dist->prefix, 1,
					     DISTRIBUTE_V4_IN, has_print);
		has_print = distribute_print(vty, dist->list, 0,
					     DISTRIBUTE_V6_IN, has_print);
		has_print = distribute_print(vty, dist->prefix, 1,
					     DISTRIBUTE_V6_IN, has_print);
	}
	if (has_print)
		vty_out(vty, "\n");
	else
		vty_out(vty, " not set\n");

	for (i = 0; i < dist_ctxt->disthash->size; i++)
		for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
			dist = mp->data;
			if (dist->ifname) {
				vty_out(vty, "    %s filtered by",
					dist->ifname);
				has_print = 0;
				has_print = distribute_print(vty, dist->list, 0,
							     DISTRIBUTE_V4_IN,
							     has_print);
				has_print = distribute_print(
					vty, dist->prefix, 1, DISTRIBUTE_V4_IN,
					has_print);
				has_print = distribute_print(vty, dist->list, 0,
							     DISTRIBUTE_V6_IN,
							     has_print);
				has_print = distribute_print(
					vty, dist->prefix, 1, DISTRIBUTE_V6_IN,
					has_print);
				if (has_print)
					vty_out(vty, "\n");
				else
					vty_out(vty, " nothing\n");
			}
		}
	return 0;
}

/* Configuration write function. */
int config_write_distribute(struct vty *vty,
			    struct distribute_ctx *dist_ctxt)
{
	unsigned int i;
	int j;
	int output, v6;
	struct hash_bucket *mp;
	int write = 0;

	for (i = 0; i < dist_ctxt->disthash->size; i++)
		for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
			struct distribute *dist;

			dist = mp->data;

			for (j = 0; j < DISTRIBUTE_MAX; j++)
				if (dist->list[j]) {
					output = j == DISTRIBUTE_V4_OUT
						 || j == DISTRIBUTE_V6_OUT;
					v6 = j == DISTRIBUTE_V6_IN
					     || j == DISTRIBUTE_V6_OUT;
					vty_out(vty,
						" %sdistribute-list %s %s %s\n",
						v6 ? "ipv6 " : "",
						dist->list[j],
						output ? "out" : "in",
						dist->ifname ? dist->ifname
							     : "");
					write++;
				}

			for (j = 0; j < DISTRIBUTE_MAX; j++)
				if (dist->prefix[j]) {
					output = j == DISTRIBUTE_V4_OUT
						 || j == DISTRIBUTE_V6_OUT;
					v6 = j == DISTRIBUTE_V6_IN
					     || j == DISTRIBUTE_V6_OUT;
					vty_out(vty,
						" %sdistribute-list prefix %s %s %s\n",
						v6 ? "ipv6 " : "",
						dist->prefix[j],
						output ? "out" : "in",
						dist->ifname ? dist->ifname
							     : "");
					write++;
				}
		}
	return write;
}

void distribute_list_delete(struct distribute_ctx **ctx)
{
	if ((*ctx)->disthash) {
		hash_clean((*ctx)->disthash, (void (*)(void *))distribute_free);
	}
	if (!dist_ctx_list)
		dist_ctx_list = list_new();
	listnode_delete(dist_ctx_list, *ctx);
	if (list_isempty(dist_ctx_list))
		list_delete(&dist_ctx_list);
	XFREE(MTYPE_DISTRIBUTE_CTX, (*ctx));
}

/* Initialize distribute list container */
struct distribute_ctx *distribute_list_ctx_create(struct vrf *vrf)
{
	struct distribute_ctx *ctx;

	ctx = XCALLOC(MTYPE_DISTRIBUTE_CTX, sizeof(struct distribute_ctx));
	ctx->vrf = vrf;
	ctx->disthash = hash_create(
		distribute_hash_make,
		(bool (*)(const void *, const void *))distribute_cmp, NULL);
	if (!dist_ctx_list)
		dist_ctx_list = list_new();
	listnode_add(dist_ctx_list, ctx);
	return ctx;
}
Commit	Line	Data
718e3744	1	/* Distribute list functions
	2	* Copyright (C) 1998, 1999 Kunihiro Ishiguro
	3	*
	4	* This file is part of GNU Zebra.
	5	*
	6	* GNU Zebra is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published
	8	* by the Free Software Foundation; either version 2, or (at your
	9	* option) any 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	*
896014f4 DL	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
718e3744	19	*/
	20
	21	#include <zebra.h>
	22
	23	#include "hash.h"
	24	#include "if.h"
	25	#include "filter.h"
	26	#include "command.h"
	27	#include "distribute.h"
	28	#include "memory.h"
	29
bf8d3d6a DL	30	DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_CTX, "Distribute ctx");
	31	DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE, "Distribute list");
	32	DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_IFNAME, "Dist-list ifname");
	33	DEFINE_MTYPE_STATIC(LIB, DISTRIBUTE_NAME, "Dist-list name");
4a1ab8e4	34
c17faa4b	35	static struct list *dist_ctx_list;
6b0655a2	36
d62a17ae	37	static struct distribute *distribute_new(void)
718e3744	38	{
d62a17ae	39	return XCALLOC(MTYPE_DISTRIBUTE, sizeof(struct distribute));
718e3744	40	}
	41
	42	/* Free distribute object. */
d62a17ae	43	static void distribute_free(struct distribute *dist)
718e3744	44	{
d62a17ae	45	int i = 0;
ee5bb561	46
0a22ddfb	47	XFREE(MTYPE_DISTRIBUTE_IFNAME, dist->ifname);
718e3744	48
0a22ddfb QY	49	for (i = 0; i < DISTRIBUTE_MAX; i++) {
	50	XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[i]);
	51	}
718e3744	52
0a22ddfb QY	53	for (i = 0; i < DISTRIBUTE_MAX; i++) {
	54	XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[i]);
	55	}
718e3744	56
d62a17ae	57	XFREE(MTYPE_DISTRIBUTE, dist);
718e3744	58	}
718e3744	59
03a38493 PG	60	static void distribute_free_if_empty(struct distribute_ctx *ctx,
03a38493 PG	61	struct distribute *dist)
ee5bb561	62	{
d62a17ae	63	int i;
ee5bb561	64
d62a17ae	65	for (i = 0; i < DISTRIBUTE_MAX; i++)
	66	if (dist->list[i] != NULL \|\| dist->prefix[i] != NULL)
	67	return;
ee5bb561	68
03a38493	69	hash_release(ctx->disthash, dist);
d62a17ae	70	distribute_free(dist);
ee5bb561 MB	71	}
ee5bb561 MB	72
718e3744	73	/* Lookup interface's distribute list. */
03a38493 PG	74	struct distribute distribute_lookup(struct distribute_ctx ctx,
03a38493 PG	75	const char *ifname)
718e3744	76	{
d62a17ae	77	struct distribute key;
d62a17ae	78	struct distribute *dist;
718e3744	79
d62a17ae	80	/* temporary reference */
d62a17ae	81	key.ifname = (ifname) ? XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, ifname) : NULL;
718e3744	82
03a38493	83	dist = hash_lookup(ctx->disthash, &key);
3a7c85d1	84
0a22ddfb	85	XFREE(MTYPE_DISTRIBUTE_IFNAME, key.ifname);
24873f0c	86
d62a17ae	87	return dist;
718e3744	88	}
718e3744	89
03a38493 PG	90	void distribute_list_add_hook(struct distribute_ctx *ctx,
	91	void (func)(struct distribute_ctx ctx,
	92	struct distribute *))
718e3744	93	{
03a38493	94	ctx->distribute_add_hook = func;
718e3744	95	}
718e3744	96
03a38493 PG	97	void distribute_list_delete_hook(struct distribute_ctx *ctx,
	98	void (func)(struct distribute_ctx ctx,
	99	struct distribute *))
718e3744	100	{
03a38493	101	ctx->distribute_delete_hook = func;
718e3744	102	}
718e3744	103
d62a17ae	104	static void distribute_hash_alloc(struct distribute arg)
718e3744	105	{
d62a17ae	106	struct distribute *dist;
	107
	108	dist = distribute_new();
	109	if (arg->ifname)
	110	dist->ifname = XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, arg->ifname);
	111	else
	112	dist->ifname = NULL;
	113	return dist;
718e3744	114	}
	115
	116	/* Make new distribute list and push into hash. */
03a38493 PG	117	static struct distribute distribute_get(struct distribute_ctx ctx,
03a38493 PG	118	const char *ifname)
718e3744	119	{
d62a17ae	120	struct distribute key;
	121	struct distribute *ret;
	122
	123	/* temporary reference */
	124	key.ifname = (ifname) ? XSTRDUP(MTYPE_DISTRIBUTE_IFNAME, ifname) : NULL;
718e3744	125
03a38493	126	ret = hash_get(ctx->disthash, &key,
d62a17ae	127	(void ()(void *))distribute_hash_alloc);
24873f0c	128
0a22ddfb	129	XFREE(MTYPE_DISTRIBUTE_IFNAME, key.ifname);
3a7c85d1	130
d62a17ae	131	return ret;
718e3744	132	}
718e3744	133
d8b87afe	134	static unsigned int distribute_hash_make(const void *arg)
718e3744	135	{
d62a17ae	136	const struct distribute *dist = arg;
718e3744	137
d62a17ae	138	return dist->ifname ? string_hash_make(dist->ifname) : 0;
718e3744	139	}
	140
	141	/* If two distribute-list have same value then return 1 else return
	142	0. This function is used by hash package. */
74df8d6d	143	static bool distribute_cmp(const struct distribute *dist1,
d62a17ae	144	const struct distribute *dist2)
718e3744	145	{
d62a17ae	146	if (dist1->ifname && dist2->ifname)
d62a17ae	147	if (strcmp(dist1->ifname, dist2->ifname) == 0)
74df8d6d	148	return true;
d62a17ae	149	if (!dist1->ifname && !dist2->ifname)
74df8d6d DS	150	return true;
74df8d6d DS	151	return false;
718e3744	152	}
6b0655a2	153
718e3744	154	/* Set access-list name to the distribute list. */
03a38493 PG	155	static void distribute_list_set(struct distribute_ctx *ctx,
03a38493 PG	156	const char *ifname, enum distribute_type type,
d62a17ae	157	const char *alist_name)
718e3744	158	{
d62a17ae	159	struct distribute *dist;
718e3744	160
03a38493	161	dist = distribute_get(ctx, ifname);
718e3744	162
0a22ddfb	163	XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[type]);
d62a17ae	164	dist->list[type] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, alist_name);
718e3744	165
d62a17ae	166	/* Apply this distribute-list to the interface. */
03a38493	167	(ctx->distribute_add_hook)(ctx, dist);
718e3744	168	}
	169
	170	/* Unset distribute-list. If matched distribute-list exist then
	171	return 1. */
03a38493 PG	172	static int distribute_list_unset(struct distribute_ctx *ctx,
	173	const char *ifname,
	174	enum distribute_type type,
d62a17ae	175	const char *alist_name)
718e3744	176	{
d62a17ae	177	struct distribute *dist;
718e3744	178
03a38493	179	dist = distribute_lookup(ctx, ifname);
d62a17ae	180	if (!dist)
d62a17ae	181	return 0;
718e3744	182
d62a17ae	183	if (!dist->list[type])
	184	return 0;
	185	if (strcmp(dist->list[type], alist_name) != 0)
	186	return 0;
718e3744	187
d62a17ae	188	XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[type]);
718e3744	189
d62a17ae	190	/* Apply this distribute-list to the interface. */
03a38493	191	(ctx->distribute_delete_hook)(ctx, dist);
718e3744	192
d62a17ae	193	/* If all dist are NULL, then free distribute list. */
03a38493	194	distribute_free_if_empty(ctx, dist);
d62a17ae	195	return 1;
718e3744	196	}
	197
	198	/* Set access-list name to the distribute list. */
03a38493 PG	199	static void distribute_list_prefix_set(struct distribute_ctx *ctx,
03a38493 PG	200	const char *ifname,
d62a17ae	201	enum distribute_type type,
d62a17ae	202	const char *plist_name)
718e3744	203	{
d62a17ae	204	struct distribute *dist;
718e3744	205
03a38493	206	dist = distribute_get(ctx, ifname);
718e3744	207
0a22ddfb	208	XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[type]);
d62a17ae	209	dist->prefix[type] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, plist_name);
718e3744	210
d62a17ae	211	/* Apply this distribute-list to the interface. */
03a38493	212	(ctx->distribute_add_hook)(ctx, dist);
718e3744	213	}
	214
	215	/* Unset distribute-list. If matched distribute-list exist then
	216	return 1. */
03a38493 PG	217	static int distribute_list_prefix_unset(struct distribute_ctx *ctx,
03a38493 PG	218	const char *ifname,
d62a17ae	219	enum distribute_type type,
d62a17ae	220	const char *plist_name)
718e3744	221	{
d62a17ae	222	struct distribute *dist;
718e3744	223
03a38493	224	dist = distribute_lookup(ctx, ifname);
d62a17ae	225	if (!dist)
d62a17ae	226	return 0;
718e3744	227
d62a17ae	228	if (!dist->prefix[type])
	229	return 0;
	230	if (strcmp(dist->prefix[type], plist_name) != 0)
	231	return 0;
718e3744	232
d62a17ae	233	XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[type]);
718e3744	234
d62a17ae	235	/* Apply this distribute-list to the interface. */
03a38493	236	(ctx->distribute_delete_hook)(ctx, dist);
718e3744	237
d62a17ae	238	/* If all dist are NULL, then free distribute list. */
03a38493	239	distribute_free_if_empty(ctx, dist);
d62a17ae	240	return 1;
718e3744	241	}
718e3744	242
df19c76a DS	243	static enum distribute_type distribute_direction(const char *dir, bool v4)
	244	{
	245	if (dir[0] == 'i') {
	246	if (v4)
	247	return DISTRIBUTE_V4_IN;
	248	else
	249	return DISTRIBUTE_V6_IN;
	250	} else if (dir[0] == 'o') {
	251	if (v4)
	252	return DISTRIBUTE_V4_OUT;
	253	else
	254	return DISTRIBUTE_V6_OUT;
	255	}
	256
	257	assert(!"Expecting in or out only, fix your code");
	258
	259	__builtin_unreachable();
	260	}
	261
458133db DS	262	int distribute_list_parser(bool prefix, bool v4, const char *dir,
458133db DS	263	const char list, const char ifname)
df19c76a DS	264	{
	265	enum distribute_type type = distribute_direction(dir, v4);
	266	struct distribute_ctx *ctx = listnode_head(dist_ctx_list);
	267
	268	void (distfn)(struct distribute_ctx , const char *,
	269	enum distribute_type, const char *) =
	270	prefix ? &distribute_list_prefix_set : &distribute_list_set;
	271
	272	distfn(ctx, ifname, type, list);
	273
	274	return CMD_SUCCESS;
	275	}
	276
458133db DS	277	int distribute_list_no_parser(struct vty *vty, bool prefix, bool v4,
	278	const char dir, const char list,
	279	const char *ifname)
df19c76a DS	280	{
	281	enum distribute_type type = distribute_direction(dir, v4);
	282	struct distribute_ctx *ctx = listnode_head(dist_ctx_list);
	283	int ret;
	284
	285	int (distfn)(struct distribute_ctx , const char *,
	286	enum distribute_type, const char *) =
	287	prefix ? &distribute_list_prefix_unset : &distribute_list_unset;
	288
	289
	290	ret = distfn(ctx, ifname, type, list);
	291	if (!ret) {
	292	vty_out(vty, "distribute list doesn't exist\n");
	293	return CMD_WARNING_CONFIG_FAILED;
	294	}
d62a17ae	295
d62a17ae	296	return CMD_SUCCESS;
fb23cf4a	297	}
d62a17ae	298
d62a17ae	299	static int distribute_print(struct vty vty, char tab[], int is_prefix,
d62a17ae	300	enum distribute_type type, int has_print)
ee5bb561	301	{
d62a17ae	302	if (tab[type]) {
	303	vty_out(vty, "%s %s%s", has_print ? "," : "",
	304	is_prefix ? "(prefix-list) " : "", tab[type]);
	305	return 1;
	306	}
	307	return has_print;
ee5bb561 MB	308	}
ee5bb561 MB	309
03a38493	310	int config_show_distribute(struct vty vty, struct distribute_ctx dist_ctxt)
718e3744	311	{
d62a17ae	312	unsigned int i;
d62a17ae	313	int has_print = 0;
e3b78da8	314	struct hash_bucket *mp;
d62a17ae	315	struct distribute *dist;
	316
	317	/* Output filter configuration. */
03a38493	318	dist = distribute_lookup(dist_ctxt, NULL);
d62a17ae	319	vty_out(vty, " Outgoing update filter list for all interface is");
	320	has_print = 0;
	321	if (dist) {
	322	has_print = distribute_print(vty, dist->list, 0,
	323	DISTRIBUTE_V4_OUT, has_print);
	324	has_print = distribute_print(vty, dist->prefix, 1,
	325	DISTRIBUTE_V4_OUT, has_print);
	326	has_print = distribute_print(vty, dist->list, 0,
	327	DISTRIBUTE_V6_OUT, has_print);
	328	has_print = distribute_print(vty, dist->prefix, 1,
	329	DISTRIBUTE_V6_OUT, has_print);
	330	}
	331	if (has_print)
	332	vty_out(vty, "\n");
	333	else
	334	vty_out(vty, " not set\n");
	335
03a38493 PG	336	for (i = 0; i < dist_ctxt->disthash->size; i++)
03a38493 PG	337	for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
d62a17ae	338	dist = mp->data;
	339	if (dist->ifname) {
	340	vty_out(vty, " %s filtered by",
	341	dist->ifname);
	342	has_print = 0;
	343	has_print = distribute_print(vty, dist->list, 0,
	344	DISTRIBUTE_V4_OUT,
	345	has_print);
	346	has_print = distribute_print(
	347	vty, dist->prefix, 1, DISTRIBUTE_V4_OUT,
	348	has_print);
	349	has_print = distribute_print(vty, dist->list, 0,
	350	DISTRIBUTE_V6_OUT,
	351	has_print);
	352	has_print = distribute_print(
	353	vty, dist->prefix, 1, DISTRIBUTE_V6_OUT,
	354	has_print);
	355	if (has_print)
	356	vty_out(vty, "\n");
	357	else
	358	vty_out(vty, " nothing\n");
	359	}
	360	}
	361
	362
	363	/* Input filter configuration. */
03a38493	364	dist = distribute_lookup(dist_ctxt, NULL);
d62a17ae	365	vty_out(vty, " Incoming update filter list for all interface is");
	366	has_print = 0;
	367	if (dist) {
	368	has_print = distribute_print(vty, dist->list, 0,
	369	DISTRIBUTE_V4_IN, has_print);
	370	has_print = distribute_print(vty, dist->prefix, 1,
	371	DISTRIBUTE_V4_IN, has_print);
	372	has_print = distribute_print(vty, dist->list, 0,
	373	DISTRIBUTE_V6_IN, has_print);
	374	has_print = distribute_print(vty, dist->prefix, 1,
	375	DISTRIBUTE_V6_IN, has_print);
	376	}
	377	if (has_print)
	378	vty_out(vty, "\n");
	379	else
	380	vty_out(vty, " not set\n");
	381
03a38493 PG	382	for (i = 0; i < dist_ctxt->disthash->size; i++)
03a38493 PG	383	for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
d62a17ae	384	dist = mp->data;
	385	if (dist->ifname) {
	386	vty_out(vty, " %s filtered by",
	387	dist->ifname);
	388	has_print = 0;
	389	has_print = distribute_print(vty, dist->list, 0,
	390	DISTRIBUTE_V4_IN,
	391	has_print);
	392	has_print = distribute_print(
	393	vty, dist->prefix, 1, DISTRIBUTE_V4_IN,
	394	has_print);
	395	has_print = distribute_print(vty, dist->list, 0,
	396	DISTRIBUTE_V6_IN,
	397	has_print);
	398	has_print = distribute_print(
	399	vty, dist->prefix, 1, DISTRIBUTE_V6_IN,
	400	has_print);
	401	if (has_print)
	402	vty_out(vty, "\n");
	403	else
	404	vty_out(vty, " nothing\n");
	405	}
	406	}
	407	return 0;
718e3744	408	}
	409
	410	/* Configuration write function. */
03a38493 PG	411	int config_write_distribute(struct vty *vty,
03a38493 PG	412	struct distribute_ctx *dist_ctxt)
718e3744	413	{
d62a17ae	414	unsigned int i;
	415	int j;
	416	int output, v6;
e3b78da8	417	struct hash_bucket *mp;
d62a17ae	418	int write = 0;
d62a17ae	419
03a38493 PG	420	for (i = 0; i < dist_ctxt->disthash->size; i++)
03a38493 PG	421	for (mp = dist_ctxt->disthash->index[i]; mp; mp = mp->next) {
d62a17ae	422	struct distribute *dist;
	423
	424	dist = mp->data;
	425
	426	for (j = 0; j < DISTRIBUTE_MAX; j++)
	427	if (dist->list[j]) {
	428	output = j == DISTRIBUTE_V4_OUT
	429	\|\| j == DISTRIBUTE_V6_OUT;
	430	v6 = j == DISTRIBUTE_V6_IN
	431	\|\| j == DISTRIBUTE_V6_OUT;
	432	vty_out(vty,
	433	" %sdistribute-list %s %s %s\n",
	434	v6 ? "ipv6 " : "",
	435	dist->list[j],
	436	output ? "out" : "in",
	437	dist->ifname ? dist->ifname
	438	: "");
	439	write++;
	440	}
	441
	442	for (j = 0; j < DISTRIBUTE_MAX; j++)
	443	if (dist->prefix[j]) {
	444	output = j == DISTRIBUTE_V4_OUT
	445	\|\| j == DISTRIBUTE_V6_OUT;
	446	v6 = j == DISTRIBUTE_V6_IN
	447	\|\| j == DISTRIBUTE_V6_OUT;
	448	vty_out(vty,
	449	" %sdistribute-list prefix %s %s %s\n",
	450	v6 ? "ipv6 " : "",
	451	dist->prefix[j],
	452	output ? "out" : "in",
	453	dist->ifname ? dist->ifname
	454	: "");
	455	write++;
	456	}
	457	}
	458	return write;
718e3744	459	}
718e3744	460
03a38493	461	void distribute_list_delete(struct distribute_ctx **ctx)
718e3744	462	{
03a38493 PG	463	if ((*ctx)->disthash) {
	464	hash_clean((ctx)->disthash, (void ()(void *))distribute_free);
	465	}
	466	if (!dist_ctx_list)
	467	dist_ctx_list = list_new();
	468	listnode_delete(dist_ctx_list, *ctx);
	469	if (list_isempty(dist_ctx_list))
	470	list_delete(&dist_ctx_list);
	471	XFREE(MTYPE_DISTRIBUTE_CTX, (*ctx));
718e3744	472	}
718e3744	473
03a38493 PG	474	/* Initialize distribute list container */
03a38493 PG	475	struct distribute_ctx distribute_list_ctx_create(struct vrf vrf)
718e3744	476	{
03a38493 PG	477	struct distribute_ctx *ctx;
	478
	479	ctx = XCALLOC(MTYPE_DISTRIBUTE_CTX, sizeof(struct distribute_ctx));
	480	ctx->vrf = vrf;
	481	ctx->disthash = hash_create(
d62a17ae	482	distribute_hash_make,
74df8d6d	483	(bool ()(const void , const void *))distribute_cmp, NULL);
03a38493 PG	484	if (!dist_ctx_list)
	485	dist_ctx_list = list_new();
	486	listnode_add(dist_ctx_list, ctx);
	487	return ctx;
	488	}