diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 09:53:30 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 09:53:30 +0000 |
commit | 2c7cac91ed6e7db0f6937923d2b57f97dbdbc337 (patch) | |
tree | c05dc0f8e6aa3accc84e3e5cffc933ed94941383 /lib/if_rmap.c | |
parent | Initial commit. (diff) | |
download | frr-upstream/8.4.4.tar.xz frr-upstream/8.4.4.zip |
Adding upstream version 8.4.4.upstream/8.4.4upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | lib/if_rmap.c | 332 |
1 files changed, 332 insertions, 0 deletions
diff --git a/lib/if_rmap.c b/lib/if_rmap.c new file mode 100644 index 0000000..bd66ffa --- /dev/null +++ b/lib/if_rmap.c @@ -0,0 +1,332 @@ +/* route-map for interface. + * Copyright (C) 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 "command.h" +#include "memory.h" +#include "if.h" +#include "if_rmap.h" + +DEFINE_MTYPE_STATIC(LIB, IF_RMAP_CTX, "Interface route map container"); +DEFINE_MTYPE_STATIC(LIB, IF_RMAP_CTX_NAME, + "Interface route map container name"); +DEFINE_MTYPE_STATIC(LIB, IF_RMAP, "Interface route map"); +DEFINE_MTYPE_STATIC(LIB, IF_RMAP_NAME, "I.f. route map name"); + +static struct list *if_rmap_ctx_list; + +static struct if_rmap *if_rmap_new(void) +{ + struct if_rmap *new; + + new = XCALLOC(MTYPE_IF_RMAP, sizeof(struct if_rmap)); + + return new; +} + +static void if_rmap_free(struct if_rmap *if_rmap) +{ + XFREE(MTYPE_IF_RMAP_NAME, if_rmap->ifname); + + XFREE(MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_IN]); + XFREE(MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_OUT]); + + XFREE(MTYPE_IF_RMAP, if_rmap); +} + +struct if_rmap *if_rmap_lookup(struct if_rmap_ctx *ctx, const char *ifname) +{ + struct if_rmap key; + struct if_rmap *if_rmap; + + /* temporary copy */ + key.ifname = (ifname) ? XSTRDUP(MTYPE_IF_RMAP_NAME, ifname) : NULL; + + if_rmap = hash_lookup(ctx->ifrmaphash, &key); + + XFREE(MTYPE_IF_RMAP_NAME, key.ifname); + + return if_rmap; +} + +void if_rmap_hook_add(struct if_rmap_ctx *ctx, + void (*func)(struct if_rmap_ctx *ctx, + struct if_rmap *)) +{ + ctx->if_rmap_add_hook = func; +} + +void if_rmap_hook_delete(struct if_rmap_ctx *ctx, + void (*func)(struct if_rmap_ctx *ctx, + struct if_rmap *)) +{ + ctx->if_rmap_delete_hook = func; +} + +static void *if_rmap_hash_alloc(void *arg) +{ + struct if_rmap *ifarg = (struct if_rmap *)arg; + struct if_rmap *if_rmap; + + if_rmap = if_rmap_new(); + if_rmap->ifname = XSTRDUP(MTYPE_IF_RMAP_NAME, ifarg->ifname); + + return if_rmap; +} + +static struct if_rmap *if_rmap_get(struct if_rmap_ctx *ctx, const char *ifname) +{ + struct if_rmap key; + struct if_rmap *ret; + + /* temporary copy */ + key.ifname = (ifname) ? XSTRDUP(MTYPE_IF_RMAP_NAME, ifname) : NULL; + + ret = hash_get(ctx->ifrmaphash, &key, if_rmap_hash_alloc); + + XFREE(MTYPE_IF_RMAP_NAME, key.ifname); + + return ret; +} + +static unsigned int if_rmap_hash_make(const void *data) +{ + const struct if_rmap *if_rmap = data; + + return string_hash_make(if_rmap->ifname); +} + +static bool if_rmap_hash_cmp(const void *arg1, const void *arg2) +{ + const struct if_rmap *if_rmap1 = arg1; + const struct if_rmap *if_rmap2 = arg2; + + return strcmp(if_rmap1->ifname, if_rmap2->ifname) == 0; +} + +static struct if_rmap *if_rmap_set(struct if_rmap_ctx *ctx, + const char *ifname, enum if_rmap_type type, + const char *routemap_name) +{ + struct if_rmap *if_rmap; + + if_rmap = if_rmap_get(ctx, ifname); + + if (type == IF_RMAP_IN) { + XFREE(MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_IN]); + if_rmap->routemap[IF_RMAP_IN] = + XSTRDUP(MTYPE_IF_RMAP_NAME, routemap_name); + } + if (type == IF_RMAP_OUT) { + XFREE(MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_OUT]); + if_rmap->routemap[IF_RMAP_OUT] = + XSTRDUP(MTYPE_IF_RMAP_NAME, routemap_name); + } + + if (ctx->if_rmap_add_hook) + (ctx->if_rmap_add_hook)(ctx, if_rmap); + + return if_rmap; +} + +static int if_rmap_unset(struct if_rmap_ctx *ctx, + const char *ifname, enum if_rmap_type type, + const char *routemap_name) +{ + struct if_rmap *if_rmap; + + if_rmap = if_rmap_lookup(ctx, ifname); + if (!if_rmap) + return 0; + + if (type == IF_RMAP_IN) { + if (!if_rmap->routemap[IF_RMAP_IN]) + return 0; + if (strcmp(if_rmap->routemap[IF_RMAP_IN], routemap_name) != 0) + return 0; + + XFREE(MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_IN]); + } + + if (type == IF_RMAP_OUT) { + if (!if_rmap->routemap[IF_RMAP_OUT]) + return 0; + if (strcmp(if_rmap->routemap[IF_RMAP_OUT], routemap_name) != 0) + return 0; + + XFREE(MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_OUT]); + } + + if (ctx->if_rmap_delete_hook) + ctx->if_rmap_delete_hook(ctx, if_rmap); + + if (if_rmap->routemap[IF_RMAP_IN] == NULL + && if_rmap->routemap[IF_RMAP_OUT] == NULL) { + hash_release(ctx->ifrmaphash, if_rmap); + if_rmap_free(if_rmap); + } + + return 1; +} + +DEFUN (if_rmap, + if_rmap_cmd, + "route-map RMAP_NAME <in|out> IFNAME", + "Route map set\n" + "Route map name\n" + "Route map set for input filtering\n" + "Route map set for output filtering\n" + "Route map interface name\n") +{ + int idx_rmap_name = 1; + int idx_in_out = 2; + int idx_ifname = 3; + enum if_rmap_type type; + struct if_rmap_ctx *ctx = + (struct if_rmap_ctx *)listnode_head(if_rmap_ctx_list); + + if (strncmp(argv[idx_in_out]->text, "in", 1) == 0) + type = IF_RMAP_IN; + else if (strncmp(argv[idx_in_out]->text, "out", 1) == 0) + type = IF_RMAP_OUT; + else { + vty_out(vty, "route-map direction must be [in|out]\n"); + return CMD_WARNING_CONFIG_FAILED; + } + + if_rmap_set(ctx, argv[idx_ifname]->arg, + type, argv[idx_rmap_name]->arg); + + return CMD_SUCCESS; +} + +DEFUN (no_if_rmap, + no_if_rmap_cmd, + "no route-map ROUTEMAP_NAME <in|out> IFNAME", + NO_STR + "Route map unset\n" + "Route map name\n" + "Route map for input filtering\n" + "Route map for output filtering\n" + "Route map interface name\n") +{ + int idx_routemap_name = 2; + int idx_in_out = 3; + int idx_ifname = 4; + int ret; + enum if_rmap_type type; + struct if_rmap_ctx *ctx = + (struct if_rmap_ctx *)listnode_head(if_rmap_ctx_list); + + if (strncmp(argv[idx_in_out]->arg, "i", 1) == 0) + type = IF_RMAP_IN; + else if (strncmp(argv[idx_in_out]->arg, "o", 1) == 0) + type = IF_RMAP_OUT; + else { + vty_out(vty, "route-map direction must be [in|out]\n"); + return CMD_WARNING_CONFIG_FAILED; + } + + ret = if_rmap_unset(ctx, argv[idx_ifname]->arg, type, + argv[idx_routemap_name]->arg); + if (!ret) { + vty_out(vty, "route-map doesn't exist\n"); + return CMD_WARNING_CONFIG_FAILED; + } + return CMD_SUCCESS; +} + + +/* Configuration write function. */ +int config_write_if_rmap(struct vty *vty, + struct if_rmap_ctx *ctx) +{ + unsigned int i; + struct hash_bucket *mp; + int write = 0; + struct hash *ifrmaphash = ctx->ifrmaphash; + + for (i = 0; i < ifrmaphash->size; i++) + for (mp = ifrmaphash->index[i]; mp; mp = mp->next) { + struct if_rmap *if_rmap; + + if_rmap = mp->data; + + if (if_rmap->routemap[IF_RMAP_IN]) { + vty_out(vty, " route-map %s in %s\n", + if_rmap->routemap[IF_RMAP_IN], + if_rmap->ifname); + write++; + } + + if (if_rmap->routemap[IF_RMAP_OUT]) { + vty_out(vty, " route-map %s out %s\n", + if_rmap->routemap[IF_RMAP_OUT], + if_rmap->ifname); + write++; + } + } + return write; +} + +void if_rmap_ctx_delete(struct if_rmap_ctx *ctx) +{ + listnode_delete(if_rmap_ctx_list, ctx); + hash_clean(ctx->ifrmaphash, (void (*)(void *))if_rmap_free); + if (ctx->name) + XFREE(MTYPE_IF_RMAP_CTX_NAME, ctx->name); + XFREE(MTYPE_IF_RMAP_CTX, ctx); +} + +/* name is optional: either vrf name, or other */ +struct if_rmap_ctx *if_rmap_ctx_create(const char *name) +{ + struct if_rmap_ctx *ctx; + + ctx = XCALLOC(MTYPE_IF_RMAP_CTX, sizeof(struct if_rmap_ctx)); + + if (ctx->name) + ctx->name = XSTRDUP(MTYPE_IF_RMAP_CTX_NAME, name); + ctx->ifrmaphash = hash_create_size(4, if_rmap_hash_make, if_rmap_hash_cmp, + "Interface Route-Map Hash"); + if (!if_rmap_ctx_list) + if_rmap_ctx_list = list_new(); + listnode_add(if_rmap_ctx_list, ctx); + return ctx; +} + +void if_rmap_init(int node) +{ + if (node == RIPNG_NODE) { + } else if (node == RIP_NODE) { + install_element(RIP_NODE, &if_rmap_cmd); + install_element(RIP_NODE, &no_if_rmap_cmd); + } + if_rmap_ctx_list = list_new(); +} + +void if_rmap_terminate(void) +{ + if (!if_rmap_ctx_list) + return; + list_delete(&if_rmap_ctx_list); +} |