bgpd/bgp_clist.c

   1 /* BGP community-list and extcommunity-list.
   2  * Copyright (C) 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 it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * 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  *
  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
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "command.h"
  24 #include "prefix.h"
  25 #include "memory.h"
  26 #include "queue.h"
  27 #include "filter.h"
  28 #include "stream.h"
  29 #include "jhash.h"
  30 #include "frrstr.h"
  31
  32 #include "bgpd/bgpd.h"
  33 #include "bgpd/bgp_community.h"
  34 #include "bgpd/bgp_ecommunity.h"
  35 #include "bgpd/bgp_lcommunity.h"
  36 #include "bgpd/bgp_aspath.h"
  37 #include "bgpd/bgp_regex.h"
  38 #include "bgpd/bgp_clist.h"
  39
  40 static uint32_t bgp_clist_hash_key_community_list(void *data)
  41 {
  42         struct community_list *cl = data;
  43
  44         if (cl->name_hash)
  45                 return cl->name_hash;
  46
  47         cl->name_hash = bgp_clist_hash_key(cl->name);
  48         return cl->name_hash;
  49 }
  50
  51 static bool bgp_clist_hash_cmp_community_list(const void *a1, const void *a2)
  52 {
  53         const struct community_list *cl1 = a1;
  54         const struct community_list *cl2 = a2;
  55
  56         if (cl1->name_hash != cl2->name_hash)
  57                 return false;
  58
  59         if (strcmp(cl1->name, cl2->name) == 0)
  60                 return true;
  61
  62         return false;
  63 }
  64
  65 /* Lookup master structure for community-list or
  66    extcommunity-list.  */
  67 struct community_list_master *
  68 community_list_master_lookup(struct community_list_handler *ch, int master)
  69 {
  70         if (ch)
  71                 switch (master) {
  72                 case COMMUNITY_LIST_MASTER:
  73                         return &ch->community_list;
  74                 case EXTCOMMUNITY_LIST_MASTER:
  75                         return &ch->extcommunity_list;
  76                 case LARGE_COMMUNITY_LIST_MASTER:
  77                         return &ch->lcommunity_list;
  78                 }
  79         return NULL;
  80 }
  81
  82 /* Allocate a new community list entry.  */
  83 static struct community_entry *community_entry_new(void)
  84 {
  85         return XCALLOC(MTYPE_COMMUNITY_LIST_ENTRY,
  86                        sizeof(struct community_entry));
  87 }
  88
  89 /* Free community list entry.  */
  90 static void community_entry_free(struct community_entry *entry)
  91 {
  92         switch (entry->style) {
  93         case COMMUNITY_LIST_STANDARD:
  94                 if (entry->u.com)
  95                         community_free(&entry->u.com);
  96                 break;
  97         case LARGE_COMMUNITY_LIST_STANDARD:
  98                 if (entry->u.lcom)
  99                         lcommunity_free(&entry->u.lcom);
 100                 break;
 101         case EXTCOMMUNITY_LIST_STANDARD:
 102                 /* In case of standard extcommunity-list, configuration string
 103                    is made by ecommunity_ecom2str().  */
 104                 XFREE(MTYPE_ECOMMUNITY_STR, entry->config);
 105                 if (entry->u.ecom)
 106                         ecommunity_free(&entry->u.ecom);
 107                 break;
 108         case COMMUNITY_LIST_EXPANDED:
 109         case EXTCOMMUNITY_LIST_EXPANDED:
 110         case LARGE_COMMUNITY_LIST_EXPANDED:
 111                 XFREE(MTYPE_COMMUNITY_LIST_CONFIG, entry->config);
 112                 if (entry->reg)
 113                         bgp_regex_free(entry->reg);
 114         default:
 115                 break;
 116         }
 117         XFREE(MTYPE_COMMUNITY_LIST_ENTRY, entry);
 118 }
 119
 120 /* Allocate a new community-list.  */
 121 static struct community_list *community_list_new(void)
 122 {
 123         return XCALLOC(MTYPE_COMMUNITY_LIST, sizeof(struct community_list));
 124 }
 125
 126 /* Free community-list.  */
 127 static void community_list_free(struct community_list *list)
 128 {
 129         XFREE(MTYPE_COMMUNITY_LIST_NAME, list->name);
 130         XFREE(MTYPE_COMMUNITY_LIST, list);
 131 }
 132
 133 static struct community_list *
 134 community_list_insert(struct community_list_handler *ch, const char *name,
 135                       int master)
 136 {
 137         size_t i;
 138         long number;
 139         struct community_list *new;
 140         struct community_list *point;
 141         struct community_list_list *list;
 142         struct community_list_master *cm;
 143
 144         /* Lookup community-list master.  */
 145         cm = community_list_master_lookup(ch, master);
 146         if (!cm)
 147                 return NULL;
 148
 149         /* Allocate new community_list and copy given name. */
 150         new = community_list_new();
 151         new->name = XSTRDUP(MTYPE_COMMUNITY_LIST_NAME, name);
 152         new->name_hash = bgp_clist_hash_key_community_list(new);
 153
 154         /* Save for later */
 155         hash_get(cm->hash, new, hash_alloc_intern);
 156
 157         /* If name is made by all digit character.  We treat it as
 158            number. */
 159         for (number = 0, i = 0; i < strlen(name); i++) {
 160                 if (isdigit((int)name[i]))
 161                         number = (number * 10) + (name[i] - '0');
 162                 else
 163                         break;
 164         }
 165
 166         /* In case of name is all digit character */
 167         if (i == strlen(name)) {
 168                 new->sort = COMMUNITY_LIST_NUMBER;
 169
 170                 /* Set access_list to number list. */
 171                 list = &cm->num;
 172
 173                 for (point = list->head; point; point = point->next)
 174                         if (atol(point->name) >= number)
 175                                 break;
 176         } else {
 177                 new->sort = COMMUNITY_LIST_STRING;
 178
 179                 /* Set access_list to string list. */
 180                 list = &cm->str;
 181
 182                 /* Set point to insertion point. */
 183                 for (point = list->head; point; point = point->next)
 184                         if (strcmp(point->name, name) >= 0)
 185                                 break;
 186         }
 187
 188         /* Link to upper list.  */
 189         new->parent = list;
 190
 191         /* In case of this is the first element of master. */
 192         if (list->head == NULL) {
 193                 list->head = list->tail = new;
 194                 return new;
 195         }
 196
 197         /* In case of insertion is made at the tail of access_list. */
 198         if (point == NULL) {
 199                 new->prev = list->tail;
 200                 list->tail->next = new;
 201                 list->tail = new;
 202                 return new;
 203         }
 204
 205         /* In case of insertion is made at the head of access_list. */
 206         if (point == list->head) {
 207                 new->next = list->head;
 208                 list->head->prev = new;
 209                 list->head = new;
 210                 return new;
 211         }
 212
 213         /* Insertion is made at middle of the access_list. */
 214         new->next = point;
 215         new->prev = point->prev;
 216
 217         if (point->prev)
 218                 point->prev->next = new;
 219         point->prev = new;
 220
 221         return new;
 222 }
 223
 224 struct community_list *community_list_lookup(struct community_list_handler *ch,
 225                                              const char *name,
 226                                              uint32_t name_hash,
 227                                              int master)
 228 {
 229         struct community_list lookup;
 230         struct community_list_master *cm;
 231
 232         if (!name)
 233                 return NULL;
 234
 235         cm = community_list_master_lookup(ch, master);
 236         if (!cm)
 237                 return NULL;
 238
 239         lookup.name = (char *)name;
 240         lookup.name_hash = name_hash;
 241         return hash_get(cm->hash, &lookup, NULL);
 242 }
 243
 244 static struct community_list *
 245 community_list_get(struct community_list_handler *ch, const char *name,
 246                    int master)
 247 {
 248         struct community_list *list;
 249
 250         list = community_list_lookup(ch, name, 0, master);
 251         if (!list)
 252                 list = community_list_insert(ch, name, master);
 253         return list;
 254 }
 255
 256 static void community_list_delete(struct community_list_master *cm,
 257                                   struct community_list *list)
 258 {
 259         struct community_list_list *clist;
 260         struct community_entry *entry, *next;
 261
 262         for (entry = list->head; entry; entry = next) {
 263                 next = entry->next;
 264                 community_entry_free(entry);
 265         }
 266
 267         clist = list->parent;
 268
 269         if (list->next)
 270                 list->next->prev = list->prev;
 271         else
 272                 clist->tail = list->prev;
 273
 274         if (list->prev)
 275                 list->prev->next = list->next;
 276         else
 277                 clist->head = list->next;
 278
 279         hash_release(cm->hash, list);
 280         community_list_free(list);
 281 }
 282
 283 static int community_list_empty_p(struct community_list *list)
 284 {
 285         return (list->head == NULL && list->tail == NULL) ? 1 : 0;
 286 }
 287
 288 /* Add community-list entry to the list.  */
 289 static void community_list_entry_add(struct community_list *list,
 290                                      struct community_entry *entry)
 291 {
 292         entry->next = NULL;
 293         entry->prev = list->tail;
 294
 295         if (list->tail)
 296                 list->tail->next = entry;
 297         else
 298                 list->head = entry;
 299         list->tail = entry;
 300 }
 301
 302 /* Delete community-list entry from the list.  */
 303 static void community_list_entry_delete(struct community_list_master *cm,
 304                                         struct community_list *list,
 305                                         struct community_entry *entry)
 306 {
 307         if (entry->next)
 308                 entry->next->prev = entry->prev;
 309         else
 310                 list->tail = entry->prev;
 311
 312         if (entry->prev)
 313                 entry->prev->next = entry->next;
 314         else
 315                 list->head = entry->next;
 316
 317         community_entry_free(entry);
 318
 319         if (community_list_empty_p(list))
 320                 community_list_delete(cm, list);
 321 }
 322
 323 /* Lookup community-list entry from the list.  */
 324 static struct community_entry *
 325 community_list_entry_lookup(struct community_list *list, const void *arg,
 326                             int direct)
 327 {
 328         struct community_entry *entry;
 329
 330         for (entry = list->head; entry; entry = entry->next) {
 331                 switch (entry->style) {
 332                 case COMMUNITY_LIST_STANDARD:
 333                         if (entry->direct == direct
 334                             && community_cmp(entry->u.com, arg))
 335                                 return entry;
 336                         break;
 337                 case EXTCOMMUNITY_LIST_STANDARD:
 338                         if (entry->direct == direct
 339                             && ecommunity_cmp(entry->u.ecom, arg))
 340                                 return entry;
 341                         break;
 342                 case LARGE_COMMUNITY_LIST_STANDARD:
 343                         if (entry->direct == direct
 344                             && lcommunity_cmp(entry->u.lcom, arg))
 345                                 return entry;
 346                         break;
 347                 case COMMUNITY_LIST_EXPANDED:
 348                 case EXTCOMMUNITY_LIST_EXPANDED:
 349                 case LARGE_COMMUNITY_LIST_EXPANDED:
 350                         if (entry->direct == direct
 351                             && strcmp(entry->config, arg) == 0)
 352                                 return entry;
 353                         break;
 354                 default:
 355                         break;
 356                 }
 357         }
 358         return NULL;
 359 }
 360
 361 static char *community_str_get(struct community *com, int i)
 362 {
 363         uint32_t comval;
 364         uint16_t as;
 365         uint16_t val;
 366         char *str;
 367
 368         memcpy(&comval, com_nthval(com, i), sizeof(uint32_t));
 369         comval = ntohl(comval);
 370
 371         switch (comval) {
 372         case COMMUNITY_INTERNET:
 373                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "internet");
 374                 break;
 375         case COMMUNITY_GSHUT:
 376                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "graceful-shutdown");
 377                 break;
 378         case COMMUNITY_ACCEPT_OWN:
 379                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "accept-own");
 380                 break;
 381         case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4:
 382                 str = XSTRDUP(MTYPE_COMMUNITY_STR,
 383                               "route-filter-translated-v4");
 384                 break;
 385         case COMMUNITY_ROUTE_FILTER_v4:
 386                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "route-filter-v4");
 387                 break;
 388         case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6:
 389                 str = XSTRDUP(MTYPE_COMMUNITY_STR,
 390                               "route-filter-translated-v6");
 391                 break;
 392         case COMMUNITY_ROUTE_FILTER_v6:
 393                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "route-filter-v6");
 394                 break;
 395         case COMMUNITY_LLGR_STALE:
 396                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "llgr-stale");
 397                 break;
 398         case COMMUNITY_NO_LLGR:
 399                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "no-llgr");
 400                 break;
 401         case COMMUNITY_ACCEPT_OWN_NEXTHOP:
 402                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "accept-own-nexthop");
 403                 break;
 404         case COMMUNITY_BLACKHOLE:
 405                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "blackhole");
 406                 break;
 407         case COMMUNITY_NO_EXPORT:
 408                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "no-export");
 409                 break;
 410         case COMMUNITY_NO_ADVERTISE:
 411                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "no-advertise");
 412                 break;
 413         case COMMUNITY_LOCAL_AS:
 414                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "local-AS");
 415                 break;
 416         case COMMUNITY_NO_PEER:
 417                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "no-peer");
 418                 break;
 419         default:
 420                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "65536:65535");
 421                 as = (comval >> 16) & 0xFFFF;
 422                 val = comval & 0xFFFF;
 423                 snprintf(str, strlen(str), "%u:%d", as, val);
 424                 break;
 425         }
 426
 427         return str;
 428 }
 429
 430 /* Internal function to perform regular expression match for
 431  * a single community. */
 432 static int community_regexp_include(regex_t *reg, struct community *com, int i)
 433 {
 434         char *str;
 435         int rv;
 436
 437         /* When there is no communities attribute it is treated as empty string.
 438          */
 439         if (com == NULL || com->size == 0)
 440                 str = XSTRDUP(MTYPE_COMMUNITY_STR, "");
 441         else
 442                 str = community_str_get(com, i);
 443
 444         /* Regular expression match.  */
 445         rv = regexec(reg, str, 0, NULL, 0);
 446
 447         XFREE(MTYPE_COMMUNITY_STR, str);
 448
 449         if (rv == 0)
 450                 return 1;
 451
 452         /* No match.  */
 453         return 0;
 454 }
 455
 456 /* Internal function to perform regular expression match for community
 457    attribute.  */
 458 static int community_regexp_match(struct community *com, regex_t *reg)
 459 {
 460         const char *str;
 461
 462         /* When there is no communities attribute it is treated as empty
 463            string.  */
 464         if (com == NULL || com->size == 0)
 465                 str = "";
 466         else
 467                 str = community_str(com, false);
 468
 469         /* Regular expression match.  */
 470         if (regexec(reg, str, 0, NULL, 0) == 0)
 471                 return 1;
 472
 473         /* No match.  */
 474         return 0;
 475 }
 476
 477 static char *lcommunity_str_get(struct lcommunity *lcom, int i)
 478 {
 479         struct lcommunity_val lcomval;
 480         uint32_t globaladmin;
 481         uint32_t localdata1;
 482         uint32_t localdata2;
 483         char *str;
 484         uint8_t *ptr;
 485         char *pnt;
 486
 487         ptr = lcom->val + (i * LCOMMUNITY_SIZE);
 488
 489         memcpy(&lcomval, ptr, LCOMMUNITY_SIZE);
 490
 491         /* Allocate memory.  48 bytes taken off bgp_lcommunity.c */
 492         str = pnt = XMALLOC(MTYPE_LCOMMUNITY_STR, 48);
 493
 494         ptr = (uint8_t *)lcomval.val;
 495         ptr = ptr_get_be32(ptr, &globaladmin);
 496         ptr = ptr_get_be32(ptr, &localdata1);
 497         ptr = ptr_get_be32(ptr, &localdata2);
 498         (void)ptr; /* consume value */
 499
 500         sprintf(pnt, "%u:%u:%u", globaladmin, localdata1, localdata2);
 501         pnt += strlen(pnt);
 502         *pnt = '\0';
 503
 504         return str;
 505 }
 506
 507 /* Internal function to perform regular expression match for
 508  * a single community. */
 509 static int lcommunity_regexp_include(regex_t *reg, struct lcommunity *lcom,
 510                                      int i)
 511 {
 512         char *str;
 513
 514         /* When there is no communities attribute it is treated as empty string.
 515          */
 516         if (lcom == NULL || lcom->size == 0)
 517                 str = XSTRDUP(MTYPE_LCOMMUNITY_STR, "");
 518         else
 519                 str = lcommunity_str_get(lcom, i);
 520
 521         /* Regular expression match.  */
 522         if (regexec(reg, str, 0, NULL, 0) == 0) {
 523                 XFREE(MTYPE_LCOMMUNITY_STR, str);
 524                 return 1;
 525         }
 526
 527         XFREE(MTYPE_LCOMMUNITY_STR, str);
 528         /* No match.  */
 529         return 0;
 530 }
 531
 532 static int lcommunity_regexp_match(struct lcommunity *com, regex_t *reg)
 533 {
 534         const char *str;
 535
 536         /* When there is no communities attribute it is treated as empty
 537            string.  */
 538         if (com == NULL || com->size == 0)
 539                 str = "";
 540         else
 541                 str = lcommunity_str(com, false);
 542
 543         /* Regular expression match.  */
 544         if (regexec(reg, str, 0, NULL, 0) == 0)
 545                 return 1;
 546
 547         /* No match.  */
 548         return 0;
 549 }
 550
 551
 552 static int ecommunity_regexp_match(struct ecommunity *ecom, regex_t *reg)
 553 {
 554         const char *str;
 555
 556         /* When there is no communities attribute it is treated as empty
 557            string.  */
 558         if (ecom == NULL || ecom->size == 0)
 559                 str = "";
 560         else
 561                 str = ecommunity_str(ecom);
 562
 563         /* Regular expression match.  */
 564         if (regexec(reg, str, 0, NULL, 0) == 0)
 565                 return 1;
 566
 567         /* No match.  */
 568         return 0;
 569 }
 570
 571 #if 0
 572 /* Delete community attribute using regular expression match.  Return
 573    modified communites attribute.  */
 574 static struct community *
 575 community_regexp_delete (struct community *com, regex_t * reg)
 576 {
 577         int i;
 578         uint32_t comval;
 579         /* Maximum is "65535:65535" + '\0'. */
 580         char c[12];
 581         const char *str;
 582
 583         if (!com)
 584                 return NULL;
 585
 586         i = 0;
 587         while (i < com->size)
 588         {
 589                 memcpy (&comval, com_nthval (com, i), sizeof (uint32_t));
 590                 comval = ntohl (comval);
 591
 592                 switch (comval) {
 593                 case COMMUNITY_INTERNET:
 594                         str = "internet";
 595                         break;
 596                 case COMMUNITY_ACCEPT_OWN:
 597                         str = "accept-own";
 598                         break;
 599                 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4:
 600                         str = "route-filter-translated-v4";
 601                         break;
 602                 case COMMUNITY_ROUTE_FILTER_v4:
 603                         str = "route-filter-v4";
 604                         break;
 605                 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6:
 606                         str = "route-filter-translated-v6";
 607                         break;
 608                 case COMMUNITY_ROUTE_FILTER_v6:
 609                         str = "route-filter-v6";
 610                         break;
 611                 case COMMUNITY_LLGR_STALE:
 612                         str = "llgr-stale";
 613                         break;
 614                 case COMMUNITY_NO_LLGR:
 615                         str = "no-llgr";
 616                         break;
 617                 case COMMUNITY_ACCEPT_OWN_NEXTHOP:
 618                         str = "accept-own-nexthop";
 619                         break;
 620                 case COMMUNITY_BLACKHOLE:
 621                         str = "blackhole";
 622                         break;
 623                 case COMMUNITY_NO_EXPORT:
 624                         str = "no-export";
 625                         break;
 626                 case COMMUNITY_NO_ADVERTISE:
 627                         str = "no-advertise";
 628                         break;
 629                 case COMMUNITY_LOCAL_AS:
 630                         str = "local-AS";
 631                         break;
 632                 case COMMUNITY_NO_PEER:
 633                         str = "no-peer";
 634                         break;
 635                 default:
 636                         sprintf (c, "%d:%d", (comval >> 16) & 0xFFFF,
 637                          comval & 0xFFFF);
 638                         str = c;
 639                         break;
 640                 }
 641
 642                 if (regexec (reg, str, 0, NULL, 0) == 0)
 643                         community_del_val (com, com_nthval (com, i));
 644                 else
 645                         i++;
 646         }
 647         return com;
 648 }
 649 #endif
 650
 651 /* When given community attribute matches to the community-list return
 652    1 else return 0.  */
 653 int community_list_match(struct community *com, struct community_list *list)
 654 {
 655         struct community_entry *entry;
 656
 657         for (entry = list->head; entry; entry = entry->next) {
 658                 if (entry->any)
 659                         return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
 660
 661                 if (entry->style == COMMUNITY_LIST_STANDARD) {
 662                         if (community_include(entry->u.com, COMMUNITY_INTERNET))
 663                                 return entry->direct == COMMUNITY_PERMIT ? 1
 664                                                                          : 0;
 665
 666                         if (community_match(com, entry->u.com))
 667                                 return entry->direct == COMMUNITY_PERMIT ? 1
 668                                                                          : 0;
 669                 } else if (entry->style == COMMUNITY_LIST_EXPANDED) {
 670                         if (community_regexp_match(com, entry->reg))
 671                                 return entry->direct == COMMUNITY_PERMIT ? 1
 672                                                                          : 0;
 673                 }
 674         }
 675         return 0;
 676 }
 677
 678 int lcommunity_list_match(struct lcommunity *lcom, struct community_list *list)
 679 {
 680         struct community_entry *entry;
 681
 682         for (entry = list->head; entry; entry = entry->next) {
 683                 if (entry->any)
 684                         return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
 685
 686                 if (entry->style == LARGE_COMMUNITY_LIST_STANDARD) {
 687                         if (lcommunity_match(lcom, entry->u.lcom))
 688                                 return entry->direct == COMMUNITY_PERMIT ? 1
 689                                                                          : 0;
 690                 } else if (entry->style == LARGE_COMMUNITY_LIST_EXPANDED) {
 691                         if (lcommunity_regexp_match(lcom, entry->reg))
 692                                 return entry->direct == COMMUNITY_PERMIT ? 1
 693                                                                          : 0;
 694                 }
 695         }
 696         return 0;
 697 }
 698
 699 int ecommunity_list_match(struct ecommunity *ecom, struct community_list *list)
 700 {
 701         struct community_entry *entry;
 702
 703         for (entry = list->head; entry; entry = entry->next) {
 704                 if (entry->any)
 705                         return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
 706
 707                 if (entry->style == EXTCOMMUNITY_LIST_STANDARD) {
 708                         if (ecommunity_match(ecom, entry->u.ecom))
 709                                 return entry->direct == COMMUNITY_PERMIT ? 1
 710                                                                          : 0;
 711                 } else if (entry->style == EXTCOMMUNITY_LIST_EXPANDED) {
 712                         if (ecommunity_regexp_match(ecom, entry->reg))
 713                                 return entry->direct == COMMUNITY_PERMIT ? 1
 714                                                                          : 0;
 715                 }
 716         }
 717         return 0;
 718 }
 719
 720 /* Perform exact matching.  In case of expanded community-list, do
 721    same thing as community_list_match().  */
 722 int community_list_exact_match(struct community *com,
 723                                struct community_list *list)
 724 {
 725         struct community_entry *entry;
 726
 727         for (entry = list->head; entry; entry = entry->next) {
 728                 if (entry->any)
 729                         return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
 730
 731                 if (entry->style == COMMUNITY_LIST_STANDARD) {
 732                         if (community_include(entry->u.com, COMMUNITY_INTERNET))
 733                                 return entry->direct == COMMUNITY_PERMIT ? 1
 734                                                                          : 0;
 735
 736                         if (community_cmp(com, entry->u.com))
 737                                 return entry->direct == COMMUNITY_PERMIT ? 1
 738                                                                          : 0;
 739                 } else if (entry->style == COMMUNITY_LIST_EXPANDED) {
 740                         if (community_regexp_match(com, entry->reg))
 741                                 return entry->direct == COMMUNITY_PERMIT ? 1
 742                                                                          : 0;
 743                 }
 744         }
 745         return 0;
 746 }
 747
 748 /* Delete all permitted communities in the list from com.  */
 749 struct community *community_list_match_delete(struct community *com,
 750                                               struct community_list *list)
 751 {
 752         struct community_entry *entry;
 753         uint32_t val;
 754         uint32_t com_index_to_delete[com->size];
 755         int delete_index = 0;
 756         int i;
 757
 758         /* Loop over each community value and evaluate each against the
 759          * community-list.  If we need to delete a community value add its index
 760          * to com_index_to_delete.
 761          */
 762         for (i = 0; i < com->size; i++) {
 763                 val = community_val_get(com, i);
 764
 765                 for (entry = list->head; entry; entry = entry->next) {
 766                         if (entry->any) {
 767                                 if (entry->direct == COMMUNITY_PERMIT) {
 768                                         com_index_to_delete[delete_index] = i;
 769                                         delete_index++;
 770                                 }
 771                                 break;
 772                         }
 773
 774                         else if ((entry->style == COMMUNITY_LIST_STANDARD)
 775                                  && (community_include(entry->u.com,
 776                                                        COMMUNITY_INTERNET)
 777                                      || community_include(entry->u.com, val))) {
 778                                 if (entry->direct == COMMUNITY_PERMIT) {
 779                                         com_index_to_delete[delete_index] = i;
 780                                         delete_index++;
 781                                 }
 782                                 break;
 783                         }
 784
 785                         else if ((entry->style == COMMUNITY_LIST_EXPANDED)
 786                                  && community_regexp_include(entry->reg, com,
 787                                                              i)) {
 788                                 if (entry->direct == COMMUNITY_PERMIT) {
 789                                         com_index_to_delete[delete_index] = i;
 790                                         delete_index++;
 791                                 }
 792                                 break;
 793                         }
 794                 }
 795         }
 796
 797         /* Delete all of the communities we flagged for deletion */
 798         for (i = delete_index - 1; i >= 0; i--) {
 799                 val = community_val_get(com, com_index_to_delete[i]);
 800                 community_del_val(com, &val);
 801         }
 802
 803         return com;
 804 }
 805
 806 /* To avoid duplicated entry in the community-list, this function
 807    compares specified entry to existing entry.  */
 808 static int community_list_dup_check(struct community_list *list,
 809                                     struct community_entry *new)
 810 {
 811         struct community_entry *entry;
 812
 813         for (entry = list->head; entry; entry = entry->next) {
 814                 if (entry->style != new->style)
 815                         continue;
 816
 817                 if (entry->direct != new->direct)
 818                         continue;
 819
 820                 if (entry->any != new->any)
 821                         continue;
 822
 823                 if (entry->any)
 824                         return 1;
 825
 826                 switch (entry->style) {
 827                 case COMMUNITY_LIST_STANDARD:
 828                         if (community_cmp(entry->u.com, new->u.com))
 829                                 return 1;
 830                         break;
 831                 case LARGE_COMMUNITY_LIST_STANDARD:
 832                         if (lcommunity_cmp(entry->u.lcom, new->u.lcom))
 833                                 return 1;
 834                         break;
 835                 case EXTCOMMUNITY_LIST_STANDARD:
 836                         if (ecommunity_cmp(entry->u.ecom, new->u.ecom))
 837                                 return 1;
 838                         break;
 839                 case COMMUNITY_LIST_EXPANDED:
 840                 case EXTCOMMUNITY_LIST_EXPANDED:
 841                 case LARGE_COMMUNITY_LIST_EXPANDED:
 842                         if (strcmp(entry->config, new->config) == 0)
 843                                 return 1;
 844                         break;
 845                 default:
 846                         break;
 847                 }
 848         }
 849         return 0;
 850 }
 851
 852 /* Set community-list.  */
 853 int community_list_set(struct community_list_handler *ch, const char *name,
 854                        const char *str, int direct, int style)
 855 {
 856         struct community_entry *entry = NULL;
 857         struct community_list *list;
 858         struct community *com = NULL;
 859         regex_t *regex = NULL;
 860
 861         /* Get community list. */
 862         list = community_list_get(ch, name, COMMUNITY_LIST_MASTER);
 863
 864         /* When community-list already has entry, new entry should have same
 865            style.  If you want to have mixed style community-list, you can
 866            comment out this check.  */
 867         if (!community_list_empty_p(list)) {
 868                 struct community_entry *first;
 869
 870                 first = list->head;
 871
 872                 if (style != first->style) {
 873                         return (first->style == COMMUNITY_LIST_STANDARD
 874                                         ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
 875                                         : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
 876                 }
 877         }
 878
 879         if (str) {
 880                 if (style == COMMUNITY_LIST_STANDARD)
 881                         com = community_str2com(str);
 882                 else
 883                         regex = bgp_regcomp(str);
 884
 885                 if (!com && !regex)
 886                         return COMMUNITY_LIST_ERR_MALFORMED_VAL;
 887         }
 888
 889         entry = community_entry_new();
 890         entry->direct = direct;
 891         entry->style = style;
 892         entry->any = (str ? 0 : 1);
 893         entry->u.com = com;
 894         entry->reg = regex;
 895         entry->config =
 896                 (regex ? XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG, str) : NULL);
 897
 898         /* Do not put duplicated community entry.  */
 899         if (community_list_dup_check(list, entry))
 900                 community_entry_free(entry);
 901         else {
 902                 community_list_entry_add(list, entry);
 903                 route_map_notify_dependencies(name, RMAP_EVENT_CLIST_ADDED);
 904         }
 905
 906         return 0;
 907 }
 908
 909 /* Unset community-list */
 910 int community_list_unset(struct community_list_handler *ch, const char *name,
 911                          const char *str, int direct, int style)
 912 {
 913         struct community_list_master *cm = NULL;
 914         struct community_entry *entry = NULL;
 915         struct community_list *list;
 916         struct community *com = NULL;
 917
 918         /* Lookup community list.  */
 919         list = community_list_lookup(ch, name, 0, COMMUNITY_LIST_MASTER);
 920         if (list == NULL)
 921                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
 922
 923         cm = community_list_master_lookup(ch, COMMUNITY_LIST_MASTER);
 924         /* Delete all of entry belongs to this community-list.  */
 925         if (!str) {
 926                 community_list_delete(cm, list);
 927                 route_map_notify_dependencies(name, RMAP_EVENT_CLIST_DELETED);
 928                 return 0;
 929         }
 930
 931         if (style == COMMUNITY_LIST_STANDARD)
 932                 com = community_str2com(str);
 933
 934         if (com) {
 935                 entry = community_list_entry_lookup(list, com, direct);
 936                 community_free(&com);
 937         } else
 938                 entry = community_list_entry_lookup(list, str, direct);
 939
 940         if (!entry)
 941                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
 942
 943         community_list_entry_delete(cm, list, entry);
 944         route_map_notify_dependencies(name, RMAP_EVENT_CLIST_DELETED);
 945
 946         return 0;
 947 }
 948
 949 /* Delete all permitted large communities in the list from com.  */
 950 struct lcommunity *lcommunity_list_match_delete(struct lcommunity *lcom,
 951                                                 struct community_list *list)
 952 {
 953         struct community_entry *entry;
 954         uint32_t com_index_to_delete[lcom->size];
 955         uint8_t *ptr;
 956         int delete_index = 0;
 957         int i;
 958
 959         /* Loop over each lcommunity value and evaluate each against the
 960          * community-list.  If we need to delete a community value add its index
 961          * to com_index_to_delete.
 962          */
 963         for (i = 0; i < lcom->size; i++) {
 964                 ptr = lcom->val + (i * LCOMMUNITY_SIZE);
 965                 for (entry = list->head; entry; entry = entry->next) {
 966                         if (entry->any) {
 967                                 if (entry->direct == COMMUNITY_PERMIT) {
 968                                         com_index_to_delete[delete_index] = i;
 969                                         delete_index++;
 970                                 }
 971                                 break;
 972                         }
 973
 974                         else if ((entry->style == LARGE_COMMUNITY_LIST_STANDARD)
 975                                  && lcommunity_include(entry->u.lcom, ptr)) {
 976                                 if (entry->direct == COMMUNITY_PERMIT) {
 977                                         com_index_to_delete[delete_index] = i;
 978                                         delete_index++;
 979                                 }
 980                                 break;
 981                         }
 982
 983                         else if ((entry->style == LARGE_COMMUNITY_LIST_EXPANDED)
 984                                  && lcommunity_regexp_include(entry->reg, lcom,
 985                                                               i)) {
 986                                 if (entry->direct == COMMUNITY_PERMIT) {
 987                                         com_index_to_delete[delete_index] = i;
 988                                         delete_index++;
 989                                 }
 990                                 break;
 991                         }
 992                 }
 993         }
 994
 995         /* Delete all of the communities we flagged for deletion */
 996         for (i = delete_index - 1; i >= 0; i--) {
 997                 ptr = lcom->val + (com_index_to_delete[i] * LCOMMUNITY_SIZE);
 998                 lcommunity_del_val(lcom, ptr);
 999         }
1000
1001         return lcom;
1002 }
1003
1004 /* Helper to check if every octet do not exceed UINT_MAX */
1005 static int lcommunity_list_valid(const char *community)
1006 {
1007         int octets = 0;
1008         char **splits;
1009         int num;
1010
1011         frrstr_split(community, ":", &splits, &num);
1012
1013         for (int i = 0; i < num; i++) {
1014                 if (strtoul(splits[i], NULL, 10) > UINT_MAX)
1015                         return 0;
1016
1017                 if (strlen(splits[i]) == 0)
1018                         return 0;
1019
1020                 octets++;
1021                 XFREE(MTYPE_TMP, splits[i]);
1022         }
1023         XFREE(MTYPE_TMP, splits);
1024
1025         if (octets < 3)
1026                 return 0;
1027
1028         return 1;
1029 }
1030
1031 /* Set lcommunity-list.  */
1032 int lcommunity_list_set(struct community_list_handler *ch, const char *name,
1033                         const char *str, int direct, int style)
1034 {
1035         struct community_entry *entry = NULL;
1036         struct community_list *list;
1037         struct lcommunity *lcom = NULL;
1038         regex_t *regex = NULL;
1039
1040         /* Get community list. */
1041         list = community_list_get(ch, name, LARGE_COMMUNITY_LIST_MASTER);
1042
1043         /* When community-list already has entry, new entry should have same
1044            style.  If you want to have mixed style community-list, you can
1045            comment out this check.  */
1046         if (!community_list_empty_p(list)) {
1047                 struct community_entry *first;
1048
1049                 first = list->head;
1050
1051                 if (style != first->style) {
1052                         return (first->style == COMMUNITY_LIST_STANDARD
1053                                         ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
1054                                         : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
1055                 }
1056         }
1057
1058         if (str) {
1059                 if (!lcommunity_list_valid(str))
1060                         return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1061
1062                 if (style == LARGE_COMMUNITY_LIST_STANDARD)
1063                         lcom = lcommunity_str2com(str);
1064                 else
1065                         regex = bgp_regcomp(str);
1066
1067                 if (!lcom && !regex)
1068                         return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1069         }
1070
1071         entry = community_entry_new();
1072         entry->direct = direct;
1073         entry->style = style;
1074         entry->any = (str ? 0 : 1);
1075         entry->u.lcom = lcom;
1076         entry->reg = regex;
1077         entry->config =
1078                 (regex ? XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG, str) : NULL);
1079
1080         /* Do not put duplicated community entry.  */
1081         if (community_list_dup_check(list, entry))
1082                 community_entry_free(entry);
1083         else {
1084                 community_list_entry_add(list, entry);
1085                 route_map_notify_dependencies(name, RMAP_EVENT_LLIST_ADDED);
1086         }
1087
1088         return 0;
1089 }
1090
1091 /* Unset community-list.  When str is NULL, delete all of
1092    community-list entry belongs to the specified name.  */
1093 int lcommunity_list_unset(struct community_list_handler *ch, const char *name,
1094                           const char *str, int direct, int style)
1095 {
1096         struct community_list_master *cm = NULL;
1097         struct community_entry *entry = NULL;
1098         struct community_list *list;
1099         struct lcommunity *lcom = NULL;
1100         regex_t *regex = NULL;
1101
1102         /* Lookup community list.  */
1103         list = community_list_lookup(ch, name, 0, LARGE_COMMUNITY_LIST_MASTER);
1104         if (list == NULL)
1105                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
1106
1107         cm = community_list_master_lookup(ch, LARGE_COMMUNITY_LIST_MASTER);
1108         /* Delete all of entry belongs to this community-list.  */
1109         if (!str) {
1110                 community_list_delete(cm, list);
1111                 route_map_notify_dependencies(name, RMAP_EVENT_LLIST_DELETED);
1112                 return 0;
1113         }
1114
1115         if (style == LARGE_COMMUNITY_LIST_STANDARD)
1116                 lcom = lcommunity_str2com(str);
1117         else
1118                 regex = bgp_regcomp(str);
1119
1120         if (!lcom && !regex)
1121                 return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1122
1123         if (lcom)
1124                 entry = community_list_entry_lookup(list, lcom, direct);
1125         else
1126                 entry = community_list_entry_lookup(list, str, direct);
1127
1128         if (lcom)
1129                 lcommunity_free(&lcom);
1130         if (regex)
1131                 bgp_regex_free(regex);
1132
1133         if (!entry)
1134                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
1135
1136         community_list_entry_delete(cm, list, entry);
1137         route_map_notify_dependencies(name, RMAP_EVENT_LLIST_DELETED);
1138
1139         return 0;
1140 }
1141
1142 /* Set extcommunity-list.  */
1143 int extcommunity_list_set(struct community_list_handler *ch, const char *name,
1144                           const char *str, int direct, int style)
1145 {
1146         struct community_entry *entry = NULL;
1147         struct community_list *list;
1148         struct ecommunity *ecom = NULL;
1149         regex_t *regex = NULL;
1150
1151         if (str == NULL)
1152                 return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1153
1154         /* Get community list. */
1155         list = community_list_get(ch, name, EXTCOMMUNITY_LIST_MASTER);
1156
1157         /* When community-list already has entry, new entry should have same
1158            style.  If you want to have mixed style community-list, you can
1159            comment out this check.  */
1160         if (!community_list_empty_p(list)) {
1161                 struct community_entry *first;
1162
1163                 first = list->head;
1164
1165                 if (style != first->style) {
1166                         return (first->style == EXTCOMMUNITY_LIST_STANDARD
1167                                         ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
1168                                         : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
1169                 }
1170         }
1171
1172         if (style == EXTCOMMUNITY_LIST_STANDARD)
1173                 ecom = ecommunity_str2com(str, 0, 1);
1174         else
1175                 regex = bgp_regcomp(str);
1176
1177         if (!ecom && !regex)
1178                 return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1179
1180         if (ecom)
1181                 ecom->str =
1182                         ecommunity_ecom2str(ecom, ECOMMUNITY_FORMAT_DISPLAY, 0);
1183
1184         entry = community_entry_new();
1185         entry->direct = direct;
1186         entry->style = style;
1187         entry->any = 0;
1188         if (ecom)
1189                 entry->config = ecommunity_ecom2str(
1190                         ecom, ECOMMUNITY_FORMAT_COMMUNITY_LIST, 0);
1191         else if (regex)
1192                 entry->config = XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG, str);
1193
1194         entry->u.ecom = ecom;
1195         entry->reg = regex;
1196
1197         /* Do not put duplicated community entry.  */
1198         if (community_list_dup_check(list, entry))
1199                 community_entry_free(entry);
1200         else {
1201                 community_list_entry_add(list, entry);
1202                 route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_ADDED);
1203         }
1204
1205         return 0;
1206 }
1207
1208 /* Unset extcommunity-list.
1209  *
1210  * When str is NULL, delete all extcommunity-list entries belonging to the
1211  * specified name.
1212  */
1213 int extcommunity_list_unset(struct community_list_handler *ch, const char *name,
1214                             const char *str, int direct, int style)
1215 {
1216         struct community_list_master *cm = NULL;
1217         struct community_entry *entry = NULL;
1218         struct community_list *list;
1219         struct ecommunity *ecom = NULL;
1220
1221         /* Lookup extcommunity list.  */
1222         list = community_list_lookup(ch, name, 0, EXTCOMMUNITY_LIST_MASTER);
1223         if (list == NULL)
1224                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
1225
1226         cm = community_list_master_lookup(ch, EXTCOMMUNITY_LIST_MASTER);
1227         /* Delete all of entry belongs to this extcommunity-list.  */
1228         if (!str) {
1229                 community_list_delete(cm, list);
1230                 route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_DELETED);
1231                 return 0;
1232         }
1233
1234         if (style == EXTCOMMUNITY_LIST_STANDARD)
1235                 ecom = ecommunity_str2com(str, 0, 1);
1236
1237         if (ecom) {
1238                 entry = community_list_entry_lookup(list, ecom, direct);
1239                 ecommunity_free(&ecom);
1240         } else
1241                 entry = community_list_entry_lookup(list, str, direct);
1242
1243         if (!entry)
1244                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
1245
1246         community_list_entry_delete(cm, list, entry);
1247         route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_DELETED);
1248
1249         return 0;
1250 }
1251
1252 /* Initializa community-list.  Return community-list handler.  */
1253 struct community_list_handler *community_list_init(void)
1254 {
1255         struct community_list_handler *ch;
1256         ch = XCALLOC(MTYPE_COMMUNITY_LIST_HANDLER,
1257                      sizeof(struct community_list_handler));
1258
1259         ch->community_list.hash =
1260                 hash_create_size(4, bgp_clist_hash_key_community_list,
1261                                  bgp_clist_hash_cmp_community_list,
1262                                  "Community List Number Quick Lookup");
1263
1264         ch->extcommunity_list.hash =
1265                 hash_create_size(4, bgp_clist_hash_key_community_list,
1266                                  bgp_clist_hash_cmp_community_list,
1267                                  "Extended Community List Quick Lookup");
1268
1269         ch->lcommunity_list.hash =
1270                 hash_create_size(4, bgp_clist_hash_key_community_list,
1271                                  bgp_clist_hash_cmp_community_list,
1272                                  "Large Community List Quick Lookup");
1273
1274         return ch;
1275 }
1276
1277 /* Terminate community-list.  */
1278 void community_list_terminate(struct community_list_handler *ch)
1279 {
1280         struct community_list_master *cm;
1281         struct community_list *list;
1282
1283         cm = &ch->community_list;
1284         while ((list = cm->num.head) != NULL)
1285                 community_list_delete(cm, list);
1286         while ((list = cm->str.head) != NULL)
1287                 community_list_delete(cm, list);
1288         hash_free(cm->hash);
1289
1290         cm = &ch->lcommunity_list;
1291         while ((list = cm->num.head) != NULL)
1292                 community_list_delete(cm, list);
1293         while ((list = cm->str.head) != NULL)
1294                 community_list_delete(cm, list);
1295         hash_free(cm->hash);
1296
1297         cm = &ch->extcommunity_list;
1298         while ((list = cm->num.head) != NULL)
1299                 community_list_delete(cm, list);
1300         while ((list = cm->str.head) != NULL)
1301                 community_list_delete(cm, list);
1302         hash_free(cm->hash);
1303
1304         XFREE(MTYPE_COMMUNITY_LIST_HANDLER, ch);
1305 }