bgpd/bgp_community.c

   1 /* Community attribute related functions.
   2  * Copyright (C) 1998, 2001 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 "hash.h"
  25 #include "memory.h"
  26 #include "jhash.h"
  27 #include "frrstr.h"
  28
  29 #include "bgpd/bgp_memory.h"
  30 #include "bgpd/bgp_community.h"
  31 #include "bgpd/bgp_community_alias.h"
  32
  33 /* Hash of community attribute. */
  34 static struct hash *comhash;
  35
  36 /* Allocate a new communities value.  */
  37 static struct community *community_new(void)
  38 {
  39         return XCALLOC(MTYPE_COMMUNITY, sizeof(struct community));
  40 }
  41
  42 /* Free communities value.  */
  43 void community_free(struct community **com)
  44 {
  45         if (!(*com))
  46                 return;
  47
  48         XFREE(MTYPE_COMMUNITY_VAL, (*com)->val);
  49         XFREE(MTYPE_COMMUNITY_STR, (*com)->str);
  50
  51         if ((*com)->json) {
  52                 json_object_free((*com)->json);
  53                 (*com)->json = NULL;
  54         }
  55
  56         XFREE(MTYPE_COMMUNITY, (*com));
  57 }
  58
  59 /* Add one community value to the community. */
  60 void community_add_val(struct community *com, uint32_t val)
  61 {
  62         com->size++;
  63         com->val = XREALLOC(MTYPE_COMMUNITY_VAL, com->val, com_length(com));
  64
  65         val = htonl(val);
  66         memcpy(com_lastval(com), &val, sizeof(uint32_t));
  67 }
  68
  69 /* Delete one community. */
  70 void community_del_val(struct community *com, uint32_t *val)
  71 {
  72         int i = 0;
  73         int c = 0;
  74
  75         if (!com->val)
  76                 return;
  77
  78         while (i < com->size) {
  79                 if (memcmp(com->val + i, val, sizeof(uint32_t)) == 0) {
  80                         c = com->size - i - 1;
  81
  82                         if (c > 0)
  83                                 memmove(com->val + i, com->val + (i + 1),
  84                                         c * sizeof(*val));
  85
  86                         com->size--;
  87
  88                         if (com->size > 0)
  89                                 com->val = XREALLOC(MTYPE_COMMUNITY_VAL,
  90                                                     com->val, com_length(com));
  91                         else {
  92                                 XFREE(MTYPE_COMMUNITY_VAL, com->val);
  93                         }
  94                         return;
  95                 }
  96                 i++;
  97         }
  98 }
  99
 100 /* Delete all communities listed in com2 from com1 */
 101 struct community *community_delete(struct community *com1,
 102                                    struct community *com2)
 103 {
 104         int i = 0;
 105
 106         while (i < com2->size) {
 107                 community_del_val(com1, com2->val + i);
 108                 i++;
 109         }
 110
 111         return com1;
 112 }
 113
 114 /* Callback function from qsort(). */
 115 static int community_compare(const void *a1, const void *a2)
 116 {
 117         uint32_t v1;
 118         uint32_t v2;
 119
 120         memcpy(&v1, a1, sizeof(uint32_t));
 121         memcpy(&v2, a2, sizeof(uint32_t));
 122         v1 = ntohl(v1);
 123         v2 = ntohl(v2);
 124
 125         if (v1 < v2)
 126                 return -1;
 127         if (v1 > v2)
 128                 return 1;
 129         return 0;
 130 }
 131
 132 bool community_include(struct community *com, uint32_t val)
 133 {
 134         int i;
 135
 136         val = htonl(val);
 137
 138         for (i = 0; i < com->size; i++)
 139                 if (memcmp(&val, com_nthval(com, i), sizeof(uint32_t)) == 0)
 140                         return true;
 141         return false;
 142 }
 143
 144 uint32_t community_val_get(struct community *com, int i)
 145 {
 146         uint8_t *p;
 147         uint32_t val;
 148
 149         p = (uint8_t *)com->val;
 150         p += (i * COMMUNITY_SIZE);
 151
 152         memcpy(&val, p, sizeof(uint32_t));
 153
 154         return ntohl(val);
 155 }
 156
 157 /* Sort and uniq given community. */
 158 struct community *community_uniq_sort(struct community *com)
 159 {
 160         int i;
 161         struct community *new;
 162         uint32_t val;
 163
 164         if (!com)
 165                 return NULL;
 166
 167         new = community_new();
 168         new->json = NULL;
 169
 170         for (i = 0; i < com->size; i++) {
 171                 val = community_val_get(com, i);
 172
 173                 if (!community_include(new, val))
 174                         community_add_val(new, val);
 175         }
 176
 177         qsort(new->val, new->size, sizeof(uint32_t), community_compare);
 178
 179         return new;
 180 }
 181
 182 /* Convert communities attribute to string.
 183
 184    For Well-known communities value, below keyword is used.
 185
 186    0x0             "internet"
 187    0xFFFF0000      "graceful-shutdown"
 188    0xFFFF0001      "accept-own"
 189    0xFFFF0002      "route-filter-translated-v4"
 190    0xFFFF0003      "route-filter-v4"
 191    0xFFFF0004      "route-filter-translated-v6"
 192    0xFFFF0005      "route-filter-v6"
 193    0xFFFF0006      "llgr-stale"
 194    0xFFFF0007      "no-llgr"
 195    0xFFFF0008      "accept-own-nexthop"
 196    0xFFFF029A      "blackhole"
 197    0xFFFFFF01      "no-export"
 198    0xFFFFFF02      "no-advertise"
 199    0xFFFFFF03      "local-AS"
 200    0xFFFFFF04      "no-peer"
 201
 202    For other values, "AS:VAL" format is used.  */
 203 static void set_community_string(struct community *com, bool make_json)
 204 {
 205         int i;
 206         char *str;
 207         int len;
 208         int first;
 209         uint32_t comval;
 210         uint16_t as;
 211         uint16_t val;
 212         json_object *json_community_list = NULL;
 213         json_object *json_string = NULL;
 214
 215         if (!com)
 216                 return;
 217
 218         if (make_json) {
 219                 com->json = json_object_new_object();
 220                 json_community_list = json_object_new_array();
 221         }
 222
 223         /* When communities attribute is empty.  */
 224         if (com->size == 0) {
 225                 str = XMALLOC(MTYPE_COMMUNITY_STR, 1);
 226                 str[0] = '\0';
 227
 228                 if (make_json) {
 229                         json_object_string_add(com->json, "string", "");
 230                         json_object_object_add(com->json, "list",
 231                                                json_community_list);
 232                 }
 233                 com->str = str;
 234                 return;
 235         }
 236
 237         /* Memory allocation is time consuming work.  So we calculate
 238            required string length first.  */
 239         len = 0;
 240
 241         for (i = 0; i < com->size; i++) {
 242                 memcpy(&comval, com_nthval(com, i), sizeof(uint32_t));
 243                 comval = ntohl(comval);
 244
 245                 switch (comval) {
 246                 case COMMUNITY_INTERNET:
 247                         len += strlen(" internet");
 248                         break;
 249                 case COMMUNITY_GSHUT:
 250                         len += strlen(" graceful-shutdown");
 251                         break;
 252                 case COMMUNITY_ACCEPT_OWN:
 253                         len += strlen(" accept-own");
 254                         break;
 255                 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4:
 256                         len += strlen(" route-filter-translated-v4");
 257                         break;
 258                 case COMMUNITY_ROUTE_FILTER_v4:
 259                         len += strlen(" route-filter-v4");
 260                         break;
 261                 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6:
 262                         len += strlen(" route-filter-translated-v6");
 263                         break;
 264                 case COMMUNITY_ROUTE_FILTER_v6:
 265                         len += strlen(" route-filter-v6");
 266                         break;
 267                 case COMMUNITY_LLGR_STALE:
 268                         len += strlen(" llgr-stale");
 269                         break;
 270                 case COMMUNITY_NO_LLGR:
 271                         len += strlen(" no-llgr");
 272                         break;
 273                 case COMMUNITY_ACCEPT_OWN_NEXTHOP:
 274                         len += strlen(" accept-own-nexthop");
 275                         break;
 276                 case COMMUNITY_BLACKHOLE:
 277                         len += strlen(" blackhole");
 278                         break;
 279                 case COMMUNITY_NO_EXPORT:
 280                         len += strlen(" no-export");
 281                         break;
 282                 case COMMUNITY_NO_ADVERTISE:
 283                         len += strlen(" no-advertise");
 284                         break;
 285                 case COMMUNITY_LOCAL_AS:
 286                         len += strlen(" local-AS");
 287                         break;
 288                 case COMMUNITY_NO_PEER:
 289                         len += strlen(" no-peer");
 290                         break;
 291                 default:
 292                         len = BUFSIZ;
 293                         break;
 294                 }
 295         }
 296
 297         /* Allocate memory.  */
 298         str = XCALLOC(MTYPE_COMMUNITY_STR, len);
 299         first = 1;
 300
 301         /* Fill in string.  */
 302         for (i = 0; i < com->size; i++) {
 303                 memcpy(&comval, com_nthval(com, i), sizeof(uint32_t));
 304                 comval = ntohl(comval);
 305
 306                 if (first)
 307                         first = 0;
 308                 else
 309                         strlcat(str, " ", len);
 310
 311                 switch (comval) {
 312                 case COMMUNITY_INTERNET:
 313                         strlcat(str, "internet", len);
 314                         if (make_json) {
 315                                 json_string =
 316                                         json_object_new_string("internet");
 317                                 json_object_array_add(json_community_list,
 318                                                       json_string);
 319                         }
 320                         break;
 321                 case COMMUNITY_GSHUT:
 322                         strlcat(str, "graceful-shutdown", len);
 323                         if (make_json) {
 324                                 json_string = json_object_new_string(
 325                                         "gracefulShutdown");
 326                                 json_object_array_add(json_community_list,
 327                                                       json_string);
 328                         }
 329                         break;
 330                 case COMMUNITY_ACCEPT_OWN:
 331                         strlcat(str, "accept-own", len);
 332                         if (make_json) {
 333                                 json_string = json_object_new_string(
 334                                         "acceptown");
 335                                 json_object_array_add(json_community_list,
 336                                                       json_string);
 337                         }
 338                         break;
 339                 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4:
 340                         strlcat(str, "route-filter-translated-v4", len);
 341                         if (make_json) {
 342                                 json_string = json_object_new_string(
 343                                         "routeFilterTranslatedV4");
 344                                 json_object_array_add(json_community_list,
 345                                                       json_string);
 346                         }
 347                         break;
 348                 case COMMUNITY_ROUTE_FILTER_v4:
 349                         strlcat(str, "route-filter-v4", len);
 350                         if (make_json) {
 351                                 json_string = json_object_new_string(
 352                                         "routeFilterV4");
 353                                 json_object_array_add(json_community_list,
 354                                                       json_string);
 355                         }
 356                         break;
 357                 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6:
 358                         strlcat(str, "route-filter-translated-v6", len);
 359                         if (make_json) {
 360                                 json_string = json_object_new_string(
 361                                         "routeFilterTranslatedV6");
 362                                 json_object_array_add(json_community_list,
 363                                                       json_string);
 364                         }
 365                         break;
 366                 case COMMUNITY_ROUTE_FILTER_v6:
 367                         strlcat(str, "route-filter-v6", len);
 368                         if (make_json) {
 369                                 json_string = json_object_new_string(
 370                                         "routeFilterV6");
 371                                 json_object_array_add(json_community_list,
 372                                                       json_string);
 373                         }
 374                         break;
 375                 case COMMUNITY_LLGR_STALE:
 376                         strlcat(str, "llgr-stale", len);
 377                         if (make_json) {
 378                                 json_string = json_object_new_string(
 379                                         "llgrStale");
 380                                 json_object_array_add(json_community_list,
 381                                                       json_string);
 382                         }
 383                         break;
 384                 case COMMUNITY_NO_LLGR:
 385                         strlcat(str, "no-llgr", len);
 386                         if (make_json) {
 387                                 json_string = json_object_new_string(
 388                                         "noLlgr");
 389                                 json_object_array_add(json_community_list,
 390                                                       json_string);
 391                         }
 392                         break;
 393                 case COMMUNITY_ACCEPT_OWN_NEXTHOP:
 394                         strlcat(str, "accept-own-nexthop", len);
 395                         if (make_json) {
 396                                 json_string = json_object_new_string(
 397                                         "acceptownnexthop");
 398                                 json_object_array_add(json_community_list,
 399                                                       json_string);
 400                         }
 401                         break;
 402                 case COMMUNITY_BLACKHOLE:
 403                         strlcat(str, "blackhole", len);
 404                         if (make_json) {
 405                                 json_string = json_object_new_string(
 406                                         "blackhole");
 407                                 json_object_array_add(json_community_list,
 408                                                       json_string);
 409                         }
 410                         break;
 411                 case COMMUNITY_NO_EXPORT:
 412                         strlcat(str, "no-export", len);
 413                         if (make_json) {
 414                                 json_string =
 415                                         json_object_new_string("noExport");
 416                                 json_object_array_add(json_community_list,
 417                                                       json_string);
 418                         }
 419                         break;
 420                 case COMMUNITY_NO_ADVERTISE:
 421                         strlcat(str, "no-advertise", len);
 422                         if (make_json) {
 423                                 json_string =
 424                                         json_object_new_string("noAdvertise");
 425                                 json_object_array_add(json_community_list,
 426                                                       json_string);
 427                         }
 428                         break;
 429                 case COMMUNITY_LOCAL_AS:
 430                         strlcat(str, "local-AS", len);
 431                         if (make_json) {
 432                                 json_string = json_object_new_string("localAs");
 433                                 json_object_array_add(json_community_list,
 434                                                       json_string);
 435                         }
 436                         break;
 437                 case COMMUNITY_NO_PEER:
 438                         strlcat(str, "no-peer", len);
 439                         if (make_json) {
 440                                 json_string = json_object_new_string("noPeer");
 441                                 json_object_array_add(json_community_list,
 442                                                       json_string);
 443                         }
 444                         break;
 445                 default:
 446                         as = (comval >> 16) & 0xFFFF;
 447                         val = comval & 0xFFFF;
 448                         char buf[32];
 449                         snprintf(buf, sizeof(buf), "%u:%d", as, val);
 450                         const char *com2alias = bgp_community2alias(buf);
 451
 452                         strlcat(str, com2alias, len);
 453                         if (make_json) {
 454                                 json_string = json_object_new_string(com2alias);
 455                                 json_object_array_add(json_community_list,
 456                                                       json_string);
 457                         }
 458                         break;
 459                 }
 460         }
 461
 462         if (make_json) {
 463                 json_object_string_add(com->json, "string", str);
 464                 json_object_object_add(com->json, "list", json_community_list);
 465         }
 466         com->str = str;
 467 }
 468
 469 /* Intern communities attribute.  */
 470 struct community *community_intern(struct community *com)
 471 {
 472         struct community *find;
 473
 474         /* Assert this community structure is not interned. */
 475         assert(com->refcnt == 0);
 476
 477         /* Lookup community hash. */
 478         find = (struct community *)hash_get(comhash, com, hash_alloc_intern);
 479
 480         /* Arguemnt com is allocated temporary.  So when it is not used in
 481            hash, it should be freed.  */
 482         if (find != com)
 483                 community_free(&com);
 484
 485         /* Increment refrence counter.  */
 486         find->refcnt++;
 487
 488         /* Make string.  */
 489         if (!find->str)
 490                 set_community_string(find, false);
 491
 492         return find;
 493 }
 494
 495 /* Free community attribute. */
 496 void community_unintern(struct community **com)
 497 {
 498         struct community *ret;
 499
 500         if (!*com)
 501                 return;
 502
 503         if ((*com)->refcnt)
 504                 (*com)->refcnt--;
 505
 506         /* Pull off from hash.  */
 507         if ((*com)->refcnt == 0) {
 508                 /* Community value com must exist in hash. */
 509                 ret = (struct community *)hash_release(comhash, *com);
 510                 assert(ret != NULL);
 511
 512                 community_free(com);
 513         }
 514 }
 515
 516 /* Create new community attribute. */
 517 struct community *community_parse(uint32_t *pnt, unsigned short length)
 518 {
 519         struct community tmp;
 520         struct community *new;
 521
 522         /* If length is malformed return NULL. */
 523         if (length % COMMUNITY_SIZE)
 524                 return NULL;
 525
 526         /* Make temporary community for hash look up. */
 527         tmp.size = length / COMMUNITY_SIZE;
 528         tmp.val = pnt;
 529
 530         new = community_uniq_sort(&tmp);
 531
 532         return community_intern(new);
 533 }
 534
 535 struct community *community_dup(struct community *com)
 536 {
 537         struct community *new;
 538
 539         new = XCALLOC(MTYPE_COMMUNITY, sizeof(struct community));
 540         new->size = com->size;
 541         if (new->size) {
 542                 new->val = XMALLOC(MTYPE_COMMUNITY_VAL,
 543                                    com->size * COMMUNITY_SIZE);
 544                 memcpy(new->val, com->val, com->size * COMMUNITY_SIZE);
 545         } else
 546                 new->val = NULL;
 547         return new;
 548 }
 549
 550 /* Return string representation of communities attribute. */
 551 char *community_str(struct community *com, bool make_json)
 552 {
 553         if (!com)
 554                 return NULL;
 555
 556         if (make_json && !com->json && com->str)
 557                 XFREE(MTYPE_COMMUNITY_STR, com->str);
 558
 559         if (!com->str)
 560                 set_community_string(com, make_json);
 561         return com->str;
 562 }
 563
 564 /* Make hash value of community attribute. This function is used by
 565    hash package.*/
 566 unsigned int community_hash_make(const struct community *com)
 567 {
 568         uint32_t *pnt = com->val;
 569
 570         return jhash2(pnt, com->size, 0x43ea96c1);
 571 }
 572
 573 bool community_match(const struct community *com1, const struct community *com2)
 574 {
 575         int i = 0;
 576         int j = 0;
 577
 578         if (com1 == NULL && com2 == NULL)
 579                 return true;
 580
 581         if (com1 == NULL || com2 == NULL)
 582                 return false;
 583
 584         if (com1->size < com2->size)
 585                 return false;
 586
 587         /* Every community on com2 needs to be on com1 for this to match */
 588         while (i < com1->size && j < com2->size) {
 589                 if (memcmp(com1->val + i, com2->val + j, sizeof(uint32_t)) == 0)
 590                         j++;
 591                 i++;
 592         }
 593
 594         if (j == com2->size)
 595                 return true;
 596         else
 597                 return false;
 598 }
 599
 600 bool community_cmp(const struct community *com1, const struct community *com2)
 601 {
 602         if (com1 == NULL && com2 == NULL)
 603                 return true;
 604         if (com1 == NULL || com2 == NULL)
 605                 return false;
 606
 607         if (com1->size == com2->size)
 608                 if (memcmp(com1->val, com2->val, com1->size * COMMUNITY_SIZE)
 609                     == 0)
 610                         return true;
 611         return false;
 612 }
 613
 614 /* Add com2 to the end of com1. */
 615 struct community *community_merge(struct community *com1,
 616                                   struct community *com2)
 617 {
 618         com1->val = XREALLOC(MTYPE_COMMUNITY_VAL, com1->val,
 619                              (com1->size + com2->size) * COMMUNITY_SIZE);
 620
 621         memcpy(com1->val + com1->size, com2->val, com2->size * COMMUNITY_SIZE);
 622         com1->size += com2->size;
 623
 624         return com1;
 625 }
 626
 627 /* Community token enum. */
 628 enum community_token {
 629         community_token_val,
 630         community_token_gshut,
 631         community_token_accept_own,
 632         community_token_route_filter_translated_v4,
 633         community_token_route_filter_v4,
 634         community_token_route_filter_translated_v6,
 635         community_token_route_filter_v6,
 636         community_token_llgr_stale,
 637         community_token_no_llgr,
 638         community_token_accept_own_nexthop,
 639         community_token_blackhole,
 640         community_token_no_export,
 641         community_token_no_advertise,
 642         community_token_local_as,
 643         community_token_no_peer,
 644         community_token_unknown
 645 };
 646
 647 /* Helper to check if a given community is valid */
 648 static bool community_valid(const char *community)
 649 {
 650         int octets = 0;
 651         char **splits;
 652         int num;
 653         int invalid = 0;
 654
 655         frrstr_split(community, ":", &splits, &num);
 656
 657         for (int i = 0; i < num; i++) {
 658                 if (strtoul(splits[i], NULL, 10) > UINT16_MAX)
 659                         invalid++;
 660
 661                 if (strlen(splits[i]) == 0)
 662                         invalid++;
 663
 664                 octets++;
 665                 XFREE(MTYPE_TMP, splits[i]);
 666         }
 667         XFREE(MTYPE_TMP, splits);
 668
 669         return (octets < 2 || invalid) ? false : true;
 670 }
 671
 672 /* Get next community token from string. */
 673 static const char *
 674 community_gettoken(const char *buf, enum community_token *token, uint32_t *val)
 675 {
 676         const char *p = buf;
 677
 678         /* Skip white space. */
 679         while (isspace((unsigned char)*p))
 680                 p++;
 681
 682         /* Check the end of the line. */
 683         if (*p == '\0')
 684                 return NULL;
 685
 686         /* Well known community string check. */
 687         if (isalpha((unsigned char)*p)) {
 688                 if (strncmp(p, "internet", strlen("internet")) == 0) {
 689                         *val = COMMUNITY_INTERNET;
 690                         *token = community_token_no_export;
 691                         p += strlen("internet");
 692                         return p;
 693                 }
 694                 if (strncmp(p, "graceful-shutdown", strlen("graceful-shutdown"))
 695                     == 0) {
 696                         *val = COMMUNITY_GSHUT;
 697                         *token = community_token_gshut;
 698                         p += strlen("graceful-shutdown");
 699                         return p;
 700                 }
 701                 if (strncmp(p, "accept-own-nexthop",
 702                             strlen("accept-own-nexthop"))
 703                     == 0) {
 704                         *val = COMMUNITY_ACCEPT_OWN_NEXTHOP;
 705                         *token = community_token_accept_own_nexthop;
 706                         p += strlen("accept-own-nexthop");
 707                         return p;
 708                 }
 709                 if (strncmp(p, "accept-own", strlen("accept-own"))
 710                     == 0) {
 711                         *val = COMMUNITY_ACCEPT_OWN;
 712                         *token = community_token_accept_own;
 713                         p += strlen("accept-own");
 714                         return p;
 715                 }
 716                 if (strncmp(p, "route-filter-translated-v4",
 717                         strlen("route-filter-translated-v4"))
 718                     == 0) {
 719                         *val = COMMUNITY_ROUTE_FILTER_TRANSLATED_v4;
 720                         *token = community_token_route_filter_translated_v4;
 721                         p += strlen("route-filter-translated-v4");
 722                         return p;
 723                 }
 724                 if (strncmp(p, "route-filter-v4", strlen("route-filter-v4"))
 725                     == 0) {
 726                         *val = COMMUNITY_ROUTE_FILTER_v4;
 727                         *token = community_token_route_filter_v4;
 728                         p += strlen("route-filter-v4");
 729                         return p;
 730                 }
 731                 if (strncmp(p, "route-filter-translated-v6",
 732                         strlen("route-filter-translated-v6"))
 733                     == 0) {
 734                         *val = COMMUNITY_ROUTE_FILTER_TRANSLATED_v6;
 735                         *token = community_token_route_filter_translated_v6;
 736                         p += strlen("route-filter-translated-v6");
 737                         return p;
 738                 }
 739                 if (strncmp(p, "route-filter-v6", strlen("route-filter-v6"))
 740                     == 0) {
 741                         *val = COMMUNITY_ROUTE_FILTER_v6;
 742                         *token = community_token_route_filter_v6;
 743                         p += strlen("route-filter-v6");
 744                         return p;
 745                 }
 746                 if (strncmp(p, "llgr-stale", strlen("llgr-stale"))
 747                     == 0) {
 748                         *val = COMMUNITY_LLGR_STALE;
 749                         *token = community_token_llgr_stale;
 750                         p += strlen("llgr-stale");
 751                         return p;
 752                 }
 753                 if (strncmp(p, "no-llgr", strlen("no-llgr"))
 754                     == 0) {
 755                         *val = COMMUNITY_NO_LLGR;
 756                         *token = community_token_no_llgr;
 757                         p += strlen("no-llgr");
 758                         return p;
 759                 }
 760                 if (strncmp(p, "blackhole", strlen("blackhole"))
 761                     == 0) {
 762                         *val = COMMUNITY_BLACKHOLE;
 763                         *token = community_token_blackhole;
 764                         p += strlen("blackhole");
 765                         return p;
 766                 }
 767                 if (strncmp(p, "no-export", strlen("no-export")) == 0) {
 768                         *val = COMMUNITY_NO_EXPORT;
 769                         *token = community_token_no_export;
 770                         p += strlen("no-export");
 771                         return p;
 772                 }
 773                 if (strncmp(p, "no-advertise", strlen("no-advertise")) == 0) {
 774                         *val = COMMUNITY_NO_ADVERTISE;
 775                         *token = community_token_no_advertise;
 776                         p += strlen("no-advertise");
 777                         return p;
 778                 }
 779                 if (strncmp(p, "local-AS", strlen("local-AS")) == 0) {
 780                         *val = COMMUNITY_LOCAL_AS;
 781                         *token = community_token_local_as;
 782                         p += strlen("local-AS");
 783                         return p;
 784                 }
 785                 if (strncmp(p, "no-peer", strlen("no-peer")) == 0) {
 786                         *val = COMMUNITY_NO_PEER;
 787                         *token = community_token_no_peer;
 788                         p += strlen("no-peer");
 789                         return p;
 790                 }
 791
 792                 /* Unknown string. */
 793                 *token = community_token_unknown;
 794                 return NULL;
 795         }
 796
 797         /* Community value. */
 798         if (isdigit((unsigned char)*p)) {
 799                 int separator = 0;
 800                 int digit = 0;
 801                 uint32_t community_low = 0;
 802                 uint32_t community_high = 0;
 803
 804                 if (!community_valid(p)) {
 805                         *token = community_token_unknown;
 806                         return NULL;
 807                 }
 808
 809                 while (isdigit((unsigned char)*p) || *p == ':') {
 810                         if (*p == ':') {
 811                                 if (separator) {
 812                                         *token = community_token_unknown;
 813                                         return NULL;
 814                                 } else {
 815                                         separator = 1;
 816                                         digit = 0;
 817
 818                                         if (community_low > UINT16_MAX) {
 819                                                 *token =
 820                                                         community_token_unknown;
 821                                                 return NULL;
 822                                         }
 823
 824                                         community_high = community_low << 16;
 825                                         community_low = 0;
 826                                 }
 827                         } else {
 828                                 digit = 1;
 829                                 community_low *= 10;
 830                                 community_low += (*p - '0');
 831                         }
 832                         p++;
 833                 }
 834                 if (!digit) {
 835                         *token = community_token_unknown;
 836                         return NULL;
 837                 }
 838
 839                 *val = community_high + community_low;
 840                 *token = community_token_val;
 841                 return p;
 842         }
 843         *token = community_token_unknown;
 844         return NULL;
 845 }
 846
 847 /* convert string to community structure */
 848 struct community *community_str2com(const char *str)
 849 {
 850         struct community *com = NULL;
 851         struct community *com_sort = NULL;
 852         uint32_t val = 0;
 853         enum community_token token = community_token_unknown;
 854
 855         do {
 856                 str = community_gettoken(str, &token, &val);
 857
 858                 switch (token) {
 859                 case community_token_val:
 860                 case community_token_gshut:
 861                 case community_token_accept_own:
 862                 case community_token_route_filter_translated_v4:
 863                 case community_token_route_filter_v4:
 864                 case community_token_route_filter_translated_v6:
 865                 case community_token_route_filter_v6:
 866                 case community_token_llgr_stale:
 867                 case community_token_no_llgr:
 868                 case community_token_accept_own_nexthop:
 869                 case community_token_blackhole:
 870                 case community_token_no_export:
 871                 case community_token_no_advertise:
 872                 case community_token_local_as:
 873                 case community_token_no_peer:
 874                         if (com == NULL) {
 875                                 com = community_new();
 876                                 com->json = NULL;
 877                         }
 878                         community_add_val(com, val);
 879                         break;
 880                 case community_token_unknown:
 881                         if (com)
 882                                 community_free(&com);
 883                         return NULL;
 884                 }
 885         } while (str);
 886
 887         com_sort = community_uniq_sort(com);
 888         community_free(&com);
 889
 890         return com_sort;
 891 }
 892
 893 /* Return communities hash entry count.  */
 894 unsigned long community_count(void)
 895 {
 896         return comhash->count;
 897 }
 898
 899 /* Return communities hash.  */
 900 struct hash *community_hash(void)
 901 {
 902         return comhash;
 903 }
 904
 905 /* Initialize comminity related hash. */
 906 void community_init(void)
 907 {
 908         comhash =
 909                 hash_create((unsigned int (*)(const void *))community_hash_make,
 910                             (bool (*)(const void *, const void *))community_cmp,
 911                             "BGP Community Hash");
 912 }
 913
 914 void community_finish(void)
 915 {
 916         hash_free(comhash);
 917         comhash = NULL;
 918 }
 919
 920 static struct community *bgp_aggr_community_lookup(
 921                                                 struct bgp_aggregate *aggregate,
 922                                                 struct community *community)
 923 {
 924         return hash_lookup(aggregate->community_hash, community);
 925 }
 926
 927 static void *bgp_aggr_community_hash_alloc(void *p)
 928 {
 929         struct community *ref = (struct community *)p;
 930         struct community *community = NULL;
 931
 932         community = community_dup(ref);
 933         return community;
 934 }
 935
 936 static void bgp_aggr_community_prepare(struct hash_bucket *hb, void *arg)
 937 {
 938         struct community *hb_community = hb->data;
 939         struct community **aggr_community = arg;
 940
 941         if (*aggr_community)
 942                 *aggr_community = community_merge(*aggr_community,
 943                                                   hb_community);
 944         else
 945                 *aggr_community = community_dup(hb_community);
 946 }
 947
 948 void bgp_aggr_community_remove(void *arg)
 949 {
 950         struct community *community = arg;
 951
 952         community_free(&community);
 953 }
 954
 955 void bgp_compute_aggregate_community(struct bgp_aggregate *aggregate,
 956                                      struct community *community)
 957 {
 958         bgp_compute_aggregate_community_hash(aggregate, community);
 959         bgp_compute_aggregate_community_val(aggregate);
 960 }
 961
 962
 963 void bgp_compute_aggregate_community_hash(struct bgp_aggregate *aggregate,
 964                                           struct community *community)
 965 {
 966         struct community *aggr_community = NULL;
 967
 968         if ((aggregate == NULL) || (community == NULL))
 969                 return;
 970
 971         /* Create hash if not already created.
 972          */
 973         if (aggregate->community_hash == NULL)
 974                 aggregate->community_hash = hash_create(
 975                         (unsigned int (*)(const void *))community_hash_make,
 976                         (bool (*)(const void *, const void *))community_cmp,
 977                         "BGP Aggregator community hash");
 978
 979         aggr_community = bgp_aggr_community_lookup(aggregate, community);
 980         if (aggr_community == NULL) {
 981                 /* Insert community into hash.
 982                  */
 983                 aggr_community = hash_get(aggregate->community_hash, community,
 984                                           bgp_aggr_community_hash_alloc);
 985         }
 986
 987         /* Increment reference counter.
 988          */
 989         aggr_community->refcnt++;
 990 }
 991
 992 void bgp_compute_aggregate_community_val(struct bgp_aggregate *aggregate)
 993 {
 994         struct community *commerge = NULL;
 995
 996         if (aggregate == NULL)
 997                 return;
 998
 999         /* Re-compute aggregate's community.
1000          */
1001         if (aggregate->community)
1002                 community_free(&aggregate->community);
1003         if (aggregate->community_hash &&
1004             aggregate->community_hash->count) {
1005                 hash_iterate(aggregate->community_hash,
1006                              bgp_aggr_community_prepare,
1007                              &aggregate->community);
1008                 commerge = aggregate->community;
1009                 aggregate->community = community_uniq_sort(commerge);
1010                 if (commerge)
1011                         community_free(&commerge);
1012         }
1013 }
1014
1015
1016
1017 void bgp_remove_community_from_aggregate(struct bgp_aggregate *aggregate,
1018                                          struct community *community)
1019 {
1020         struct community *aggr_community = NULL;
1021         struct community *ret_comm = NULL;
1022
1023         if ((!aggregate)
1024             || (!aggregate->community_hash)
1025             || (!community))
1026                 return;
1027
1028         /* Look-up the community in the hash.
1029          */
1030         aggr_community = bgp_aggr_community_lookup(aggregate, community);
1031         if (aggr_community) {
1032                 aggr_community->refcnt--;
1033
1034                 if (aggr_community->refcnt == 0) {
1035                         ret_comm = hash_release(aggregate->community_hash,
1036                                                 aggr_community);
1037                         community_free(&ret_comm);
1038
1039                         bgp_compute_aggregate_community_val(aggregate);
1040                 }
1041         }
1042 }
1043
1044 void bgp_remove_comm_from_aggregate_hash(struct bgp_aggregate *aggregate,
1045                 struct community *community)
1046 {
1047
1048         struct community *aggr_community = NULL;
1049         struct community *ret_comm = NULL;
1050
1051         if ((!aggregate)
1052             || (!aggregate->community_hash)
1053             || (!community))
1054                 return;
1055
1056         /* Look-up the community in the hash.
1057          */
1058         aggr_community = bgp_aggr_community_lookup(aggregate, community);
1059         if (aggr_community) {
1060                 aggr_community->refcnt--;
1061
1062                 if (aggr_community->refcnt == 0) {
1063                         ret_comm = hash_release(aggregate->community_hash,
1064                                                 aggr_community);
1065                         community_free(&ret_comm);
1066                 }
1067         }
1068 }