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                 val = htonl(val);
 801                 community_del_val(com, &val);
 802         }
 803
 804         return com;
 805 }
 806
 807 /* To avoid duplicated entry in the community-list, this function
 808    compares specified entry to existing entry.  */
 809 static int community_list_dup_check(struct community_list *list,
 810                                     struct community_entry *new)
 811 {
 812         struct community_entry *entry;
 813
 814         for (entry = list->head; entry; entry = entry->next) {
 815                 if (entry->style != new->style)
 816                         continue;
 817
 818                 if (entry->direct != new->direct)
 819                         continue;
 820
 821                 if (entry->any != new->any)
 822                         continue;
 823
 824                 if (entry->any)
 825                         return 1;
 826
 827                 switch (entry->style) {
 828                 case COMMUNITY_LIST_STANDARD:
 829                         if (community_cmp(entry->u.com, new->u.com))
 830                                 return 1;
 831                         break;
 832                 case LARGE_COMMUNITY_LIST_STANDARD:
 833                         if (lcommunity_cmp(entry->u.lcom, new->u.lcom))
 834                                 return 1;
 835                         break;
 836                 case EXTCOMMUNITY_LIST_STANDARD:
 837                         if (ecommunity_cmp(entry->u.ecom, new->u.ecom))
 838                                 return 1;
 839                         break;
 840                 case COMMUNITY_LIST_EXPANDED:
 841                 case EXTCOMMUNITY_LIST_EXPANDED:
 842                 case LARGE_COMMUNITY_LIST_EXPANDED:
 843                         if (strcmp(entry->config, new->config) == 0)
 844                                 return 1;
 845                         break;
 846                 default:
 847                         break;
 848                 }
 849         }
 850         return 0;
 851 }
 852
 853 /* Set community-list.  */
 854 int community_list_set(struct community_list_handler *ch, const char *name,
 855                        const char *str, int direct, int style)
 856 {
 857         struct community_entry *entry = NULL;
 858         struct community_list *list;
 859         struct community *com = NULL;
 860         regex_t *regex = NULL;
 861
 862         /* Get community list. */
 863         list = community_list_get(ch, name, COMMUNITY_LIST_MASTER);
 864
 865         /* When community-list already has entry, new entry should have same
 866            style.  If you want to have mixed style community-list, you can
 867            comment out this check.  */
 868         if (!community_list_empty_p(list)) {
 869                 struct community_entry *first;
 870
 871                 first = list->head;
 872
 873                 if (style != first->style) {
 874                         return (first->style == COMMUNITY_LIST_STANDARD
 875                                         ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
 876                                         : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
 877                 }
 878         }
 879
 880         if (str) {
 881                 if (style == COMMUNITY_LIST_STANDARD)
 882                         com = community_str2com(str);
 883                 else
 884                         regex = bgp_regcomp(str);
 885
 886                 if (!com && !regex)
 887                         return COMMUNITY_LIST_ERR_MALFORMED_VAL;
 888         }
 889
 890         entry = community_entry_new();
 891         entry->direct = direct;
 892         entry->style = style;
 893         entry->any = (str ? 0 : 1);
 894         entry->u.com = com;
 895         entry->reg = regex;
 896         entry->config =
 897                 (regex ? XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG, str) : NULL);
 898
 899         /* Do not put duplicated community entry.  */
 900         if (community_list_dup_check(list, entry))
 901                 community_entry_free(entry);
 902         else {
 903                 community_list_entry_add(list, entry);
 904                 route_map_notify_dependencies(name, RMAP_EVENT_CLIST_ADDED);
 905         }
 906
 907         return 0;
 908 }
 909
 910 /* Unset community-list */
 911 int community_list_unset(struct community_list_handler *ch, const char *name,
 912                          const char *str, int direct, int style)
 913 {
 914         struct community_list_master *cm = NULL;
 915         struct community_entry *entry = NULL;
 916         struct community_list *list;
 917         struct community *com = NULL;
 918
 919         /* Lookup community list.  */
 920         list = community_list_lookup(ch, name, 0, COMMUNITY_LIST_MASTER);
 921         if (list == NULL)
 922                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
 923
 924         cm = community_list_master_lookup(ch, COMMUNITY_LIST_MASTER);
 925         /* Delete all of entry belongs to this community-list.  */
 926         if (!str) {
 927                 community_list_delete(cm, list);
 928                 route_map_notify_dependencies(name, RMAP_EVENT_CLIST_DELETED);
 929                 return 0;
 930         }
 931
 932         if (style == COMMUNITY_LIST_STANDARD)
 933                 com = community_str2com(str);
 934
 935         if (com) {
 936                 entry = community_list_entry_lookup(list, com, direct);
 937                 community_free(&com);
 938         } else
 939                 entry = community_list_entry_lookup(list, str, direct);
 940
 941         if (!entry)
 942                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
 943
 944         community_list_entry_delete(cm, list, entry);
 945         route_map_notify_dependencies(name, RMAP_EVENT_CLIST_DELETED);
 946
 947         return 0;
 948 }
 949
 950 /* Delete all permitted large communities in the list from com.  */
 951 struct lcommunity *lcommunity_list_match_delete(struct lcommunity *lcom,
 952                                                 struct community_list *list)
 953 {
 954         struct community_entry *entry;
 955         uint32_t com_index_to_delete[lcom->size];
 956         uint8_t *ptr;
 957         int delete_index = 0;
 958         int i;
 959
 960         /* Loop over each lcommunity value and evaluate each against the
 961          * community-list.  If we need to delete a community value add its index
 962          * to com_index_to_delete.
 963          */
 964         for (i = 0; i < lcom->size; i++) {
 965                 ptr = lcom->val + (i * LCOMMUNITY_SIZE);
 966                 for (entry = list->head; entry; entry = entry->next) {
 967                         if (entry->any) {
 968                                 if (entry->direct == COMMUNITY_PERMIT) {
 969                                         com_index_to_delete[delete_index] = i;
 970                                         delete_index++;
 971                                 }
 972                                 break;
 973                         }
 974
 975                         else if ((entry->style == LARGE_COMMUNITY_LIST_STANDARD)
 976                                  && lcommunity_include(entry->u.lcom, ptr)) {
 977                                 if (entry->direct == COMMUNITY_PERMIT) {
 978                                         com_index_to_delete[delete_index] = i;
 979                                         delete_index++;
 980                                 }
 981                                 break;
 982                         }
 983
 984                         else if ((entry->style == LARGE_COMMUNITY_LIST_EXPANDED)
 985                                  && lcommunity_regexp_include(entry->reg, lcom,
 986                                                               i)) {
 987                                 if (entry->direct == COMMUNITY_PERMIT) {
 988                                         com_index_to_delete[delete_index] = i;
 989                                         delete_index++;
 990                                 }
 991                                 break;
 992                         }
 993                 }
 994         }
 995
 996         /* Delete all of the communities we flagged for deletion */
 997         for (i = delete_index - 1; i >= 0; i--) {
 998                 ptr = lcom->val + (com_index_to_delete[i] * LCOMMUNITY_SIZE);
 999                 lcommunity_del_val(lcom, ptr);
1000         }
1001
1002         return lcom;
1003 }
1004
1005 /* Helper to check if every octet do not exceed UINT_MAX */
1006 static int lcommunity_list_valid(const char *community)
1007 {
1008         int octets = 0;
1009         char **splits;
1010         int num;
1011
1012         frrstr_split(community, ":", &splits, &num);
1013
1014         for (int i = 0; i < num; i++) {
1015                 if (strtoul(splits[i], NULL, 10) > UINT_MAX)
1016                         return 0;
1017
1018                 if (strlen(splits[i]) == 0)
1019                         return 0;
1020
1021                 octets++;
1022                 XFREE(MTYPE_TMP, splits[i]);
1023         }
1024         XFREE(MTYPE_TMP, splits);
1025
1026         if (octets < 3)
1027                 return 0;
1028
1029         return 1;
1030 }
1031
1032 /* Set lcommunity-list.  */
1033 int lcommunity_list_set(struct community_list_handler *ch, const char *name,
1034                         const char *str, int direct, int style)
1035 {
1036         struct community_entry *entry = NULL;
1037         struct community_list *list;
1038         struct lcommunity *lcom = NULL;
1039         regex_t *regex = NULL;
1040
1041         /* Get community list. */
1042         list = community_list_get(ch, name, LARGE_COMMUNITY_LIST_MASTER);
1043
1044         /* When community-list already has entry, new entry should have same
1045            style.  If you want to have mixed style community-list, you can
1046            comment out this check.  */
1047         if (!community_list_empty_p(list)) {
1048                 struct community_entry *first;
1049
1050                 first = list->head;
1051
1052                 if (style != first->style) {
1053                         return (first->style == COMMUNITY_LIST_STANDARD
1054                                         ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
1055                                         : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
1056                 }
1057         }
1058
1059         if (str) {
1060                 if (!lcommunity_list_valid(str))
1061                         return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1062
1063                 if (style == LARGE_COMMUNITY_LIST_STANDARD)
1064                         lcom = lcommunity_str2com(str);
1065                 else
1066                         regex = bgp_regcomp(str);
1067
1068                 if (!lcom && !regex)
1069                         return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1070         }
1071
1072         entry = community_entry_new();
1073         entry->direct = direct;
1074         entry->style = style;
1075         entry->any = (str ? 0 : 1);
1076         entry->u.lcom = lcom;
1077         entry->reg = regex;
1078         entry->config =
1079                 (regex ? XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG, str) : NULL);
1080
1081         /* Do not put duplicated community entry.  */
1082         if (community_list_dup_check(list, entry))
1083                 community_entry_free(entry);
1084         else {
1085                 community_list_entry_add(list, entry);
1086                 route_map_notify_dependencies(name, RMAP_EVENT_LLIST_ADDED);
1087         }
1088
1089         return 0;
1090 }
1091
1092 /* Unset community-list.  When str is NULL, delete all of
1093    community-list entry belongs to the specified name.  */
1094 int lcommunity_list_unset(struct community_list_handler *ch, const char *name,
1095                           const char *str, int direct, int style)
1096 {
1097         struct community_list_master *cm = NULL;
1098         struct community_entry *entry = NULL;
1099         struct community_list *list;
1100         struct lcommunity *lcom = NULL;
1101         regex_t *regex = NULL;
1102
1103         /* Lookup community list.  */
1104         list = community_list_lookup(ch, name, 0, LARGE_COMMUNITY_LIST_MASTER);
1105         if (list == NULL)
1106                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
1107
1108         cm = community_list_master_lookup(ch, LARGE_COMMUNITY_LIST_MASTER);
1109         /* Delete all of entry belongs to this community-list.  */
1110         if (!str) {
1111                 community_list_delete(cm, list);
1112                 route_map_notify_dependencies(name, RMAP_EVENT_LLIST_DELETED);
1113                 return 0;
1114         }
1115
1116         if (style == LARGE_COMMUNITY_LIST_STANDARD)
1117                 lcom = lcommunity_str2com(str);
1118         else
1119                 regex = bgp_regcomp(str);
1120
1121         if (!lcom && !regex)
1122                 return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1123
1124         if (lcom)
1125                 entry = community_list_entry_lookup(list, lcom, direct);
1126         else
1127                 entry = community_list_entry_lookup(list, str, direct);
1128
1129         if (lcom)
1130                 lcommunity_free(&lcom);
1131         if (regex)
1132                 bgp_regex_free(regex);
1133
1134         if (!entry)
1135                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
1136
1137         community_list_entry_delete(cm, list, entry);
1138         route_map_notify_dependencies(name, RMAP_EVENT_LLIST_DELETED);
1139
1140         return 0;
1141 }
1142
1143 /* Set extcommunity-list.  */
1144 int extcommunity_list_set(struct community_list_handler *ch, const char *name,
1145                           const char *str, int direct, int style)
1146 {
1147         struct community_entry *entry = NULL;
1148         struct community_list *list;
1149         struct ecommunity *ecom = NULL;
1150         regex_t *regex = NULL;
1151
1152         if (str == NULL)
1153                 return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1154
1155         /* Get community list. */
1156         list = community_list_get(ch, name, EXTCOMMUNITY_LIST_MASTER);
1157
1158         /* When community-list already has entry, new entry should have same
1159            style.  If you want to have mixed style community-list, you can
1160            comment out this check.  */
1161         if (!community_list_empty_p(list)) {
1162                 struct community_entry *first;
1163
1164                 first = list->head;
1165
1166                 if (style != first->style) {
1167                         return (first->style == EXTCOMMUNITY_LIST_STANDARD
1168                                         ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
1169                                         : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
1170                 }
1171         }
1172
1173         if (style == EXTCOMMUNITY_LIST_STANDARD)
1174                 ecom = ecommunity_str2com(str, 0, 1);
1175         else
1176                 regex = bgp_regcomp(str);
1177
1178         if (!ecom && !regex)
1179                 return COMMUNITY_LIST_ERR_MALFORMED_VAL;
1180
1181         if (ecom)
1182                 ecom->str =
1183                         ecommunity_ecom2str(ecom, ECOMMUNITY_FORMAT_DISPLAY, 0);
1184
1185         entry = community_entry_new();
1186         entry->direct = direct;
1187         entry->style = style;
1188         entry->any = 0;
1189         if (ecom)
1190                 entry->config = ecommunity_ecom2str(
1191                         ecom, ECOMMUNITY_FORMAT_COMMUNITY_LIST, 0);
1192         else if (regex)
1193                 entry->config = XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG, str);
1194
1195         entry->u.ecom = ecom;
1196         entry->reg = regex;
1197
1198         /* Do not put duplicated community entry.  */
1199         if (community_list_dup_check(list, entry))
1200                 community_entry_free(entry);
1201         else {
1202                 community_list_entry_add(list, entry);
1203                 route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_ADDED);
1204         }
1205
1206         return 0;
1207 }
1208
1209 /* Unset extcommunity-list.
1210  *
1211  * When str is NULL, delete all extcommunity-list entries belonging to the
1212  * specified name.
1213  */
1214 int extcommunity_list_unset(struct community_list_handler *ch, const char *name,
1215                             const char *str, int direct, int style)
1216 {
1217         struct community_list_master *cm = NULL;
1218         struct community_entry *entry = NULL;
1219         struct community_list *list;
1220         struct ecommunity *ecom = NULL;
1221
1222         /* Lookup extcommunity list.  */
1223         list = community_list_lookup(ch, name, 0, EXTCOMMUNITY_LIST_MASTER);
1224         if (list == NULL)
1225                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
1226
1227         cm = community_list_master_lookup(ch, EXTCOMMUNITY_LIST_MASTER);
1228         /* Delete all of entry belongs to this extcommunity-list.  */
1229         if (!str) {
1230                 community_list_delete(cm, list);
1231                 route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_DELETED);
1232                 return 0;
1233         }
1234
1235         if (style == EXTCOMMUNITY_LIST_STANDARD)
1236                 ecom = ecommunity_str2com(str, 0, 1);
1237
1238         if (ecom) {
1239                 entry = community_list_entry_lookup(list, ecom, direct);
1240                 ecommunity_free(&ecom);
1241         } else
1242                 entry = community_list_entry_lookup(list, str, direct);
1243
1244         if (!entry)
1245                 return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
1246
1247         community_list_entry_delete(cm, list, entry);
1248         route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_DELETED);
1249
1250         return 0;
1251 }
1252
1253 /* Initializa community-list.  Return community-list handler.  */
1254 struct community_list_handler *community_list_init(void)
1255 {
1256         struct community_list_handler *ch;
1257         ch = XCALLOC(MTYPE_COMMUNITY_LIST_HANDLER,
1258                      sizeof(struct community_list_handler));
1259
1260         ch->community_list.hash =
1261                 hash_create_size(4, bgp_clist_hash_key_community_list,
1262                                  bgp_clist_hash_cmp_community_list,
1263                                  "Community List Number Quick Lookup");
1264
1265         ch->extcommunity_list.hash =
1266                 hash_create_size(4, bgp_clist_hash_key_community_list,
1267                                  bgp_clist_hash_cmp_community_list,
1268                                  "Extended Community List Quick Lookup");
1269
1270         ch->lcommunity_list.hash =
1271                 hash_create_size(4, bgp_clist_hash_key_community_list,
1272                                  bgp_clist_hash_cmp_community_list,
1273                                  "Large Community List Quick Lookup");
1274
1275         return ch;
1276 }
1277
1278 /* Terminate community-list.  */
1279 void community_list_terminate(struct community_list_handler *ch)
1280 {
1281         struct community_list_master *cm;
1282         struct community_list *list;
1283
1284         cm = &ch->community_list;
1285         while ((list = cm->num.head) != NULL)
1286                 community_list_delete(cm, list);
1287         while ((list = cm->str.head) != NULL)
1288                 community_list_delete(cm, list);
1289         hash_free(cm->hash);
1290
1291         cm = &ch->lcommunity_list;
1292         while ((list = cm->num.head) != NULL)
1293                 community_list_delete(cm, list);
1294         while ((list = cm->str.head) != NULL)
1295                 community_list_delete(cm, list);
1296         hash_free(cm->hash);
1297
1298         cm = &ch->extcommunity_list;
1299         while ((list = cm->num.head) != NULL)
1300                 community_list_delete(cm, list);
1301         while ((list = cm->str.head) != NULL)
1302                 community_list_delete(cm, list);
1303         hash_free(cm->hash);
1304
1305         XFREE(MTYPE_COMMUNITY_LIST_HANDLER, ch);
1306 }