/* BGP community-list and extcommunity-list.
* 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 "command.h"
#include "prefix.h"
#include "memory.h"
#include "queue.h"
#include "filter.h"
#include "stream.h"
#include "bgpd/bgpd.h"
#include "bgpd/bgp_community.h"
#include "bgpd/bgp_ecommunity.h"
#include "bgpd/bgp_lcommunity.h"
#include "bgpd/bgp_aspath.h"
#include "bgpd/bgp_regex.h"
#include "bgpd/bgp_clist.h"
/* Lookup master structure for community-list or
extcommunity-list. */
struct community_list_master *
community_list_master_lookup(struct community_list_handler *ch, int master)
{
if (ch)
switch (master) {
case COMMUNITY_LIST_MASTER:
return &ch->community_list;
case EXTCOMMUNITY_LIST_MASTER:
return &ch->extcommunity_list;
case LARGE_COMMUNITY_LIST_MASTER:
return &ch->lcommunity_list;
}
return NULL;
}
/* Allocate a new community list entry. */
static struct community_entry *community_entry_new(void)
{
return XCALLOC(MTYPE_COMMUNITY_LIST_ENTRY,
sizeof(struct community_entry));
}
/* Free community list entry. */
static void community_entry_free(struct community_entry *entry)
{
switch (entry->style) {
case COMMUNITY_LIST_STANDARD:
if (entry->u.com)
community_free(&entry->u.com);
break;
case LARGE_COMMUNITY_LIST_STANDARD:
if (entry->u.lcom)
lcommunity_free(&entry->u.lcom);
break;
case EXTCOMMUNITY_LIST_STANDARD:
/* In case of standard extcommunity-list, configuration string
is made by ecommunity_ecom2str(). */
if (entry->config)
XFREE(MTYPE_ECOMMUNITY_STR, entry->config);
if (entry->u.ecom)
ecommunity_free(&entry->u.ecom);
break;
case COMMUNITY_LIST_EXPANDED:
case EXTCOMMUNITY_LIST_EXPANDED:
case LARGE_COMMUNITY_LIST_EXPANDED:
if (entry->config)
XFREE(MTYPE_COMMUNITY_LIST_CONFIG, entry->config);
if (entry->reg)
bgp_regex_free(entry->reg);
default:
break;
}
XFREE(MTYPE_COMMUNITY_LIST_ENTRY, entry);
}
/* Allocate a new community-list. */
static struct community_list *community_list_new(void)
{
return XCALLOC(MTYPE_COMMUNITY_LIST, sizeof(struct community_list));
}
/* Free community-list. */
static void community_list_free(struct community_list *list)
{
if (list->name)
XFREE(MTYPE_COMMUNITY_LIST_NAME, list->name);
XFREE(MTYPE_COMMUNITY_LIST, list);
}
static struct community_list *
community_list_insert(struct community_list_handler *ch, const char *name,
int master)
{
size_t i;
long number;
struct community_list *new;
struct community_list *point;
struct community_list_list *list;
struct community_list_master *cm;
/* Lookup community-list master. */
cm = community_list_master_lookup(ch, master);
if (!cm)
return NULL;
/* Allocate new community_list and copy given name. */
new = community_list_new();
new->name = XSTRDUP(MTYPE_COMMUNITY_LIST_NAME, name);
/* If name is made by all digit character. We treat it as
number. */
for (number = 0, i = 0; i < strlen(name); i++) {
if (isdigit((int)name[i]))
number = (number * 10) + (name[i] - '0');
else
break;
}
/* In case of name is all digit character */
if (i == strlen(name)) {
new->sort = COMMUNITY_LIST_NUMBER;
/* Set access_list to number list. */
list = &cm->num;
for (point = list->head; point; point = point->next)
if (atol(point->name) >= number)
break;
} else {
new->sort = COMMUNITY_LIST_STRING;
/* Set access_list to string list. */
list = &cm->str;
/* Set point to insertion point. */
for (point = list->head; point; point = point->next)
if (strcmp(point->name, name) >= 0)
break;
}
/* Link to upper list. */
new->parent = list;
/* In case of this is the first element of master. */
if (list->head == NULL) {
list->head = list->tail = new;
return new;
}
/* In case of insertion is made at the tail of access_list. */
if (point == NULL) {
new->prev = list->tail;
list->tail->next = new;
list->tail = new;
return new;
}
/* In case of insertion is made at the head of access_list. */
if (point == list->head) {
new->next = list->head;
list->head->prev = new;
list->head = new;
return new;
}
/* Insertion is made at middle of the access_list. */
new->next = point;
new->prev = point->prev;
if (point->prev)
point->prev->next = new;
point->prev = new;
return new;
}
struct community_list *community_list_lookup(struct community_list_handler *ch,
const char *name, int master)
{
struct community_list *list;
struct community_list_master *cm;
if (!name)
return NULL;
cm = community_list_master_lookup(ch, master);
if (!cm)
return NULL;
for (list = cm->num.head; list; list = list->next)
if (strcmp(list->name, name) == 0)
return list;
for (list = cm->str.head; list; list = list->next)
if (strcmp(list->name, name) == 0)
return list;
return NULL;
}
static struct community_list *
community_list_get(struct community_list_handler *ch, const char *name,
int master)
{
struct community_list *list;
list = community_list_lookup(ch, name, master);
if (!list)
list = community_list_insert(ch, name, master);
return list;
}
static void community_list_delete(struct community_list *list)
{
struct community_list_list *clist;
struct community_entry *entry, *next;
for (entry = list->head; entry; entry = next) {
next = entry->next;
community_entry_free(entry);
}
clist = list->parent;
if (list->next)
list->next->prev = list->prev;
else
clist->tail = list->prev;
if (list->prev)
list->prev->next = list->next;
else
clist->head = list->next;
community_list_free(list);
}
static int community_list_empty_p(struct community_list *list)
{
return (list->head == NULL && list->tail == NULL) ? 1 : 0;
}
/* Add community-list entry to the list. */
static void community_list_entry_add(struct community_list *list,
struct community_entry *entry)
{
entry->next = NULL;
entry->prev = list->tail;
if (list->tail)
list->tail->next = entry;
else
list->head = entry;
list->tail = entry;
}
/* Delete community-list entry from the list. */
static void community_list_entry_delete(struct community_list *list,
struct community_entry *entry)
{
if (entry->next)
entry->next->prev = entry->prev;
else
list->tail = entry->prev;
if (entry->prev)
entry->prev->next = entry->next;
else
list->head = entry->next;
community_entry_free(entry);
if (community_list_empty_p(list))
community_list_delete(list);
}
/* Lookup community-list entry from the list. */
static struct community_entry *
community_list_entry_lookup(struct community_list *list, const void *arg,
int direct)
{
struct community_entry *entry;
for (entry = list->head; entry; entry = entry->next) {
switch (entry->style) {
case COMMUNITY_LIST_STANDARD:
if (entry->direct == direct
&& community_cmp(entry->u.com, arg))
return entry;
break;
case EXTCOMMUNITY_LIST_STANDARD:
if (entry->direct == direct
&& ecommunity_cmp(entry->u.ecom, arg))
return entry;
break;
case LARGE_COMMUNITY_LIST_STANDARD:
if (entry->direct == direct
&& lcommunity_cmp(entry->u.lcom, arg))
return entry;
break;
case COMMUNITY_LIST_EXPANDED:
case EXTCOMMUNITY_LIST_EXPANDED:
case LARGE_COMMUNITY_LIST_EXPANDED:
if (entry->direct == direct
&& strcmp(entry->config, arg) == 0)
return entry;
break;
default:
break;
}
}
return NULL;
}
static char *community_str_get(struct community *com, int i)
{
uint32_t comval;
uint16_t as;
uint16_t val;
char *str;
memcpy(&comval, com_nthval(com, i), sizeof(uint32_t));
comval = ntohl(comval);
switch (comval) {
case COMMUNITY_INTERNET:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "internet");
break;
case COMMUNITY_GSHUT:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "graceful-shutdown");
break;
case COMMUNITY_ACCEPT_OWN:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "accept-own");
break;
case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4:
str = XSTRDUP(MTYPE_COMMUNITY_STR,
"route-filter-translated-v4");
break;
case COMMUNITY_ROUTE_FILTER_v4:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "route-filter-v4");
break;
case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6:
str = XSTRDUP(MTYPE_COMMUNITY_STR,
"route-filter-translated-v6");
break;
case COMMUNITY_ROUTE_FILTER_v6:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "route-filter-v6");
break;
case COMMUNITY_LLGR_STALE:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "llgr-stale");
break;
case COMMUNITY_NO_LLGR:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "no-llgr");
break;
case COMMUNITY_ACCEPT_OWN_NEXTHOP:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "accept-own-nexthop");
break;
case COMMUNITY_BLACKHOLE:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "blackhole");
break;
case COMMUNITY_NO_EXPORT:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "no-export");
break;
case COMMUNITY_NO_ADVERTISE:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "no-advertise");
break;
case COMMUNITY_LOCAL_AS:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "local-AS");
break;
case COMMUNITY_NO_PEER:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "no-peer");
break;
default:
str = XSTRDUP(MTYPE_COMMUNITY_STR, "65536:65535");
as = (comval >> 16) & 0xFFFF;
val = comval & 0xFFFF;
snprintf(str, strlen(str), "%u:%d", as, val);
break;
}
return str;
}
/* Internal function to perform regular expression match for
* a single community. */
static int community_regexp_include(regex_t *reg, struct community *com, int i)
{
char *str;
int rv;
/* When there is no communities attribute it is treated as empty string.
*/
if (com == NULL || com->size == 0)
str = XSTRDUP(MTYPE_COMMUNITY_STR, "");
else
str = community_str_get(com, i);
/* Regular expression match. */
rv = regexec(reg, str, 0, NULL, 0);
XFREE(MTYPE_COMMUNITY_STR, str);
if (rv == 0)
return 1;
/* No match. */
return 0;
}
/* Internal function to perform regular expression match for community
attribute. */
static int community_regexp_match(struct community *com, regex_t *reg)
{
const char *str;
/* When there is no communities attribute it is treated as empty
string. */
if (com == NULL || com->size == 0)
str = "";
else
str = community_str(com, false);
/* Regular expression match. */
if (regexec(reg, str, 0, NULL, 0) == 0)
return 1;
/* No match. */
return 0;
}
static char *lcommunity_str_get(struct lcommunity *lcom, int i)
{
struct lcommunity_val lcomval;
uint32_t globaladmin;
uint32_t localdata1;
uint32_t localdata2;
char *str;
uint8_t *ptr;
char *pnt;
ptr = lcom->val + (i * LCOMMUNITY_SIZE);
memcpy(&lcomval, ptr, LCOMMUNITY_SIZE);
/* Allocate memory. 48 bytes taken off bgp_lcommunity.c */
str = pnt = XMALLOC(MTYPE_LCOMMUNITY_STR, 48);
ptr = (uint8_t *)lcomval.val;
ptr = ptr_get_be32(ptr, &globaladmin);
ptr = ptr_get_be32(ptr, &localdata1);
ptr = ptr_get_be32(ptr, &localdata2);
(void)ptr; /* consume value */
sprintf(pnt, "%u:%u:%u", globaladmin, localdata1, localdata2);
pnt += strlen(pnt);
*pnt = '\0';
return str;
}
/* Internal function to perform regular expression match for
* a single community. */
static int lcommunity_regexp_include(regex_t *reg, struct lcommunity *lcom,
int i)
{
char *str;
/* When there is no communities attribute it is treated as empty string.
*/
if (lcom == NULL || lcom->size == 0)
str = XSTRDUP(MTYPE_LCOMMUNITY_STR, "");
else
str = lcommunity_str_get(lcom, i);
/* Regular expression match. */
if (regexec(reg, str, 0, NULL, 0) == 0) {
XFREE(MTYPE_LCOMMUNITY_STR, str);
return 1;
}
XFREE(MTYPE_LCOMMUNITY_STR, str);
/* No match. */
return 0;
}
static int lcommunity_regexp_match(struct lcommunity *com, regex_t *reg)
{
const char *str;
/* When there is no communities attribute it is treated as empty
string. */
if (com == NULL || com->size == 0)
str = "";
else
str = lcommunity_str(com, false);
/* Regular expression match. */
if (regexec(reg, str, 0, NULL, 0) == 0)
return 1;
/* No match. */
return 0;
}
static int ecommunity_regexp_match(struct ecommunity *ecom, regex_t *reg)
{
const char *str;
/* When there is no communities attribute it is treated as empty
string. */
if (ecom == NULL || ecom->size == 0)
str = "";
else
str = ecommunity_str(ecom);
/* Regular expression match. */
if (regexec(reg, str, 0, NULL, 0) == 0)
return 1;
/* No match. */
return 0;
}
#if 0
/* Delete community attribute using regular expression match. Return
modified communites attribute. */
static struct community *
community_regexp_delete (struct community *com, regex_t * reg)
{
int i;
uint32_t comval;
/* Maximum is "65535:65535" + '\0'. */
char c[12];
const char *str;
if (!com)
return NULL;
i = 0;
while (i < com->size)
{
memcpy (&comval, com_nthval (com, i), sizeof (uint32_t));
comval = ntohl (comval);
switch (comval) {
case COMMUNITY_INTERNET:
str = "internet";
break;
case COMMUNITY_ACCEPT_OWN:
str = "accept-own";
break;
case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4:
str = "route-filter-translated-v4";
break;
case COMMUNITY_ROUTE_FILTER_v4:
str = "route-filter-v4";
break;
case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6:
str = "route-filter-translated-v6";
break;
case COMMUNITY_ROUTE_FILTER_v6:
str = "route-filter-v6";
break;
case COMMUNITY_LLGR_STALE:
str = "llgr-stale";
break;
case COMMUNITY_NO_LLGR:
str = "no-llgr";
break;
case COMMUNITY_ACCEPT_OWN_NEXTHOP:
str = "accept-own-nexthop";
break;
case COMMUNITY_BLACKHOLE:
str = "blackhole";
break;
case COMMUNITY_NO_EXPORT:
str = "no-export";
break;
case COMMUNITY_NO_ADVERTISE:
str = "no-advertise";
break;
case COMMUNITY_LOCAL_AS:
str = "local-AS";
break;
case COMMUNITY_NO_PEER:
str = "no-peer";
break;
default:
sprintf (c, "%d:%d", (comval >> 16) & 0xFFFF,
comval & 0xFFFF);
str = c;
break;
}
if (regexec (reg, str, 0, NULL, 0) == 0)
community_del_val (com, com_nthval (com, i));
else
i++;
}
return com;
}
#endif
/* When given community attribute matches to the community-list return
1 else return 0. */
int community_list_match(struct community *com, struct community_list *list)
{
struct community_entry *entry;
for (entry = list->head; entry; entry = entry->next) {
if (entry->any)
return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
if (entry->style == COMMUNITY_LIST_STANDARD) {
if (community_include(entry->u.com, COMMUNITY_INTERNET))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
if (community_match(com, entry->u.com))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
} else if (entry->style == COMMUNITY_LIST_EXPANDED) {
if (community_regexp_match(com, entry->reg))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
}
}
return 0;
}
int lcommunity_list_match(struct lcommunity *lcom, struct community_list *list)
{
struct community_entry *entry;
for (entry = list->head; entry; entry = entry->next) {
if (entry->any)
return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
if (entry->style == LARGE_COMMUNITY_LIST_STANDARD) {
if (lcommunity_match(lcom, entry->u.lcom))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
} else if (entry->style == LARGE_COMMUNITY_LIST_EXPANDED) {
if (lcommunity_regexp_match(lcom, entry->reg))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
}
}
return 0;
}
int ecommunity_list_match(struct ecommunity *ecom, struct community_list *list)
{
struct community_entry *entry;
for (entry = list->head; entry; entry = entry->next) {
if (entry->any)
return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
if (entry->style == EXTCOMMUNITY_LIST_STANDARD) {
if (ecommunity_match(ecom, entry->u.ecom))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
} else if (entry->style == EXTCOMMUNITY_LIST_EXPANDED) {
if (ecommunity_regexp_match(ecom, entry->reg))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
}
}
return 0;
}
/* Perform exact matching. In case of expanded community-list, do
same thing as community_list_match(). */
int community_list_exact_match(struct community *com,
struct community_list *list)
{
struct community_entry *entry;
for (entry = list->head; entry; entry = entry->next) {
if (entry->any)
return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
if (entry->style == COMMUNITY_LIST_STANDARD) {
if (community_include(entry->u.com, COMMUNITY_INTERNET))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
if (community_cmp(com, entry->u.com))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
} else if (entry->style == COMMUNITY_LIST_EXPANDED) {
if (community_regexp_match(com, entry->reg))
return entry->direct == COMMUNITY_PERMIT ? 1
: 0;
}
}
return 0;
}
/* Delete all permitted communities in the list from com. */
struct community *community_list_match_delete(struct community *com,
struct community_list *list)
{
struct community_entry *entry;
uint32_t val;
uint32_t com_index_to_delete[com->size];
int delete_index = 0;
int i;
/* Loop over each community value and evaluate each against the
* community-list. If we need to delete a community value add its index
* to com_index_to_delete.
*/
for (i = 0; i < com->size; i++) {
val = community_val_get(com, i);
for (entry = list->head; entry; entry = entry->next) {
if (entry->any) {
if (entry->direct == COMMUNITY_PERMIT) {
com_index_to_delete[delete_index] = i;
delete_index++;
}
break;
}
else if ((entry->style == COMMUNITY_LIST_STANDARD)
&& (community_include(entry->u.com,
COMMUNITY_INTERNET)
|| community_include(entry->u.com, val))) {
if (entry->direct == COMMUNITY_PERMIT) {
com_index_to_delete[delete_index] = i;
delete_index++;
}
break;
}
else if ((entry->style == COMMUNITY_LIST_EXPANDED)
&& community_regexp_include(entry->reg, com,
i)) {
if (entry->direct == COMMUNITY_PERMIT) {
com_index_to_delete[delete_index] = i;
delete_index++;
}
break;
}
}
}
/* Delete all of the communities we flagged for deletion */
for (i = delete_index - 1; i >= 0; i--) {
val = community_val_get(com, com_index_to_delete[i]);
community_del_val(com, &val);
}
return com;
}
/* To avoid duplicated entry in the community-list, this function
compares specified entry to existing entry. */
static int community_list_dup_check(struct community_list *list,
struct community_entry *new)
{
struct community_entry *entry;
for (entry = list->head; entry; entry = entry->next) {
if (entry->style != new->style)
continue;
if (entry->direct != new->direct)
continue;
if (entry->any != new->any)
continue;
if (entry->any)
return 1;
switch (entry->style) {
case COMMUNITY_LIST_STANDARD:
if (community_cmp(entry->u.com, new->u.com))
return 1;
break;
case LARGE_COMMUNITY_LIST_STANDARD:
if (lcommunity_cmp(entry->u.lcom, new->u.lcom))
return 1;
break;
case EXTCOMMUNITY_LIST_STANDARD:
if (ecommunity_cmp(entry->u.ecom, new->u.ecom))
return 1;
break;
case COMMUNITY_LIST_EXPANDED:
case EXTCOMMUNITY_LIST_EXPANDED:
case LARGE_COMMUNITY_LIST_EXPANDED:
if (strcmp(entry->config, new->config) == 0)
return 1;
break;
default:
break;
}
}
return 0;
}
/* Set community-list. */
int community_list_set(struct community_list_handler *ch, const char *name,
const char *str, int direct, int style)
{
struct community_entry *entry = NULL;
struct community_list *list;
struct community *com = NULL;
regex_t *regex = NULL;
/* Get community list. */
list = community_list_get(ch, name, COMMUNITY_LIST_MASTER);
/* When community-list already has entry, new entry should have same
style. If you want to have mixed style community-list, you can
comment out this check. */
if (!community_list_empty_p(list)) {
struct community_entry *first;
first = list->head;
if (style != first->style) {
return (first->style == COMMUNITY_LIST_STANDARD
? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
: COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
}
}
if (str) {
if (style == COMMUNITY_LIST_STANDARD)
com = community_str2com(str);
else
regex = bgp_regcomp(str);
if (!com && !regex)
return COMMUNITY_LIST_ERR_MALFORMED_VAL;
}
entry = community_entry_new();
entry->direct = direct;
entry->style = style;
entry->any = (str ? 0 : 1);
entry->u.com = com;
entry->reg = regex;
entry->config =
(regex ? XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG, str) : NULL);
/* Do not put duplicated community entry. */
if (community_list_dup_check(list, entry))
community_entry_free(entry);
else {
community_list_entry_add(list, entry);
route_map_notify_dependencies(name, RMAP_EVENT_CLIST_ADDED);
}
return 0;
}
/* Unset community-list */
int community_list_unset(struct community_list_handler *ch, const char *name,
const char *str, int direct, int style)
{
struct community_entry *entry = NULL;
struct community_list *list;
struct community *com = NULL;
/* Lookup community list. */
list = community_list_lookup(ch, name, COMMUNITY_LIST_MASTER);
if (list == NULL)
return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
/* Delete all of entry belongs to this community-list. */
if (!str) {
community_list_delete(list);
route_map_notify_dependencies(name, RMAP_EVENT_CLIST_DELETED);
return 0;
}
if (style == COMMUNITY_LIST_STANDARD)
com = community_str2com(str);
if (com) {
entry = community_list_entry_lookup(list, com, direct);
community_free(&com);
} else
entry = community_list_entry_lookup(list, str, direct);
if (!entry)
return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
community_list_entry_delete(list, entry);
route_map_notify_dependencies(name, RMAP_EVENT_CLIST_DELETED);
return 0;
}
/* Delete all permitted large communities in the list from com. */
struct lcommunity *lcommunity_list_match_delete(struct lcommunity *lcom,
struct community_list *list)
{
struct community_entry *entry;
uint32_t com_index_to_delete[lcom->size];
uint8_t *ptr;
int delete_index = 0;
int i;
/* Loop over each lcommunity value and evaluate each against the
* community-list. If we need to delete a community value add its index
* to com_index_to_delete.
*/
for (i = 0; i < lcom->size; i++) {
ptr = lcom->val + (i * LCOMMUNITY_SIZE);
for (entry = list->head; entry; entry = entry->next) {
if (entry->any) {
if (entry->direct == COMMUNITY_PERMIT) {
com_index_to_delete[delete_index] = i;
delete_index++;
}
break;
}
else if ((entry->style == LARGE_COMMUNITY_LIST_STANDARD)
&& lcommunity_include(entry->u.lcom, ptr)) {
if (entry->direct == COMMUNITY_PERMIT) {
com_index_to_delete[delete_index] = i;
delete_index++;
}
break;
}
else if ((entry->style == LARGE_COMMUNITY_LIST_EXPANDED)
&& lcommunity_regexp_include(entry->reg, lcom,
i)) {
if (entry->direct == COMMUNITY_PERMIT) {
com_index_to_delete[delete_index] = i;
delete_index++;
}
break;
}
}
}
/* Delete all of the communities we flagged for deletion */
for (i = delete_index - 1; i >= 0; i--) {
ptr = lcom->val + (com_index_to_delete[i] * LCOMMUNITY_SIZE);
lcommunity_del_val(lcom, ptr);
}
return lcom;
}
/* Set lcommunity-list. */
int lcommunity_list_set(struct community_list_handler *ch, const char *name,
const char *str, int direct, int style)
{
struct community_entry *entry = NULL;
struct community_list *list;
struct lcommunity *lcom = NULL;
regex_t *regex = NULL;
/* Get community list. */
list = community_list_get(ch, name, LARGE_COMMUNITY_LIST_MASTER);
/* When community-list already has entry, new entry should have same
style. If you want to have mixed style community-list, you can
comment out this check. */
if (!community_list_empty_p(list)) {
struct community_entry *first;
first = list->head;
if (style != first->style) {
return (first->style == COMMUNITY_LIST_STANDARD
? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
: COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
}
}
if (str) {
if (style == LARGE_COMMUNITY_LIST_STANDARD)
lcom = lcommunity_str2com(str);
else
regex = bgp_regcomp(str);
if (!lcom && !regex)
return COMMUNITY_LIST_ERR_MALFORMED_VAL;
}
entry = community_entry_new();
entry->direct = direct;
entry->style = style;
entry->any = (str ? 0 : 1);
entry->u.lcom = lcom;
entry->reg = regex;
entry->config =
(regex ? XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG, str) : NULL);
/* Do not put duplicated community entry. */
if (community_list_dup_check(list, entry))
community_entry_free(entry);
else
community_list_entry_add(list, entry);
return 0;
}
/* Unset community-list. When str is NULL, delete all of
community-list entry belongs to the specified name. */
int lcommunity_list_unset(struct community_list_handler *ch, const char *name,
const char *str, int direct, int style)
{
struct community_entry *entry = NULL;
struct community_list *list;
struct lcommunity *lcom = NULL;
regex_t *regex = NULL;
/* Lookup community list. */
list = community_list_lookup(ch, name, LARGE_COMMUNITY_LIST_MASTER);
if (list == NULL)
return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
/* Delete all of entry belongs to this community-list. */
if (!str) {
community_list_delete(list);
return 0;
}
if (style == LARGE_COMMUNITY_LIST_STANDARD)
lcom = lcommunity_str2com(str);
else
regex = bgp_regcomp(str);
if (!lcom && !regex)
return COMMUNITY_LIST_ERR_MALFORMED_VAL;
if (lcom)
entry = community_list_entry_lookup(list, lcom, direct);
else
entry = community_list_entry_lookup(list, str, direct);
if (lcom)
lcommunity_free(&lcom);
if (regex)
bgp_regex_free(regex);
if (!entry)
return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
community_list_entry_delete(list, entry);
return 0;
}
/* Set extcommunity-list. */
int extcommunity_list_set(struct community_list_handler *ch, const char *name,
const char *str, int direct, int style)
{
struct community_entry *entry = NULL;
struct community_list *list;
struct ecommunity *ecom = NULL;
regex_t *regex = NULL;
if (str == NULL)
return COMMUNITY_LIST_ERR_MALFORMED_VAL;
/* Get community list. */
list = community_list_get(ch, name, EXTCOMMUNITY_LIST_MASTER);
/* When community-list already has entry, new entry should have same
style. If you want to have mixed style community-list, you can
comment out this check. */
if (!community_list_empty_p(list)) {
struct community_entry *first;
first = list->head;
if (style != first->style) {
return (first->style == EXTCOMMUNITY_LIST_STANDARD
? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
: COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
}
}
if (style == EXTCOMMUNITY_LIST_STANDARD)
ecom = ecommunity_str2com(str, 0, 1);
else
regex = bgp_regcomp(str);
if (!ecom && !regex)
return COMMUNITY_LIST_ERR_MALFORMED_VAL;
if (ecom)
ecom->str =
ecommunity_ecom2str(ecom, ECOMMUNITY_FORMAT_DISPLAY, 0);
entry = community_entry_new();
entry->direct = direct;
entry->style = style;
entry->any = 0;
if (ecom)
entry->config = ecommunity_ecom2str(
ecom, ECOMMUNITY_FORMAT_COMMUNITY_LIST, 0);
else if (regex)
entry->config = XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG, str);
entry->u.ecom = ecom;
entry->reg = regex;
/* Do not put duplicated community entry. */
if (community_list_dup_check(list, entry))
community_entry_free(entry);
else {
community_list_entry_add(list, entry);
route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_ADDED);
}
return 0;
}
/* Unset extcommunity-list.
*
* When str is NULL, delete all extcommunity-list entries belonging to the
* specified name.
*/
int extcommunity_list_unset(struct community_list_handler *ch, const char *name,
const char *str, int direct, int style)
{
struct community_entry *entry = NULL;
struct community_list *list;
struct ecommunity *ecom = NULL;
/* Lookup extcommunity list. */
list = community_list_lookup(ch, name, EXTCOMMUNITY_LIST_MASTER);
if (list == NULL)
return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
/* Delete all of entry belongs to this extcommunity-list. */
if (!str) {
community_list_delete(list);
route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_DELETED);
return 0;
}
if (style == EXTCOMMUNITY_LIST_STANDARD)
ecom = ecommunity_str2com(str, 0, 1);
if (ecom) {
entry = community_list_entry_lookup(list, ecom, direct);
ecommunity_free(&ecom);
} else
entry = community_list_entry_lookup(list, str, direct);
if (!entry)
return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
community_list_entry_delete(list, entry);
route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_DELETED);
return 0;
}
/* Initializa community-list. Return community-list handler. */
struct community_list_handler *community_list_init(void)
{
struct community_list_handler *ch;
ch = XCALLOC(MTYPE_COMMUNITY_LIST_HANDLER,
sizeof(struct community_list_handler));
return ch;
}
/* Terminate community-list. */
void community_list_terminate(struct community_list_handler *ch)
{
struct community_list_master *cm;
struct community_list *list;
cm = &ch->community_list;
while ((list = cm->num.head) != NULL)
community_list_delete(list);
while ((list = cm->str.head) != NULL)
community_list_delete(list);
cm = &ch->lcommunity_list;
while ((list = cm->num.head) != NULL)
community_list_delete(list);
while ((list = cm->str.head) != NULL)
community_list_delete(list);
cm = &ch->extcommunity_list;
while ((list = cm->num.head) != NULL)
community_list_delete(list);
while ((list = cm->str.head) != NULL)
community_list_delete(list);
XFREE(MTYPE_COMMUNITY_LIST_HANDLER, ch);
}