1 /* BGP community-list and extcommunity-list.
2 * Copyright (C) 1999 Kunihiro Ishiguro
4 * This file is part of GNU Zebra.
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
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.
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
30 #include "bgpd/bgpd.h"
31 #include "bgpd/bgp_community.h"
32 #include "bgpd/bgp_ecommunity.h"
33 #include "bgpd/bgp_lcommunity.h"
34 #include "bgpd/bgp_aspath.h"
35 #include "bgpd/bgp_regex.h"
36 #include "bgpd/bgp_clist.h"
38 /* Lookup master structure for community-list or
40 struct community_list_master
*
41 community_list_master_lookup(struct community_list_handler
*ch
, int master
)
45 case COMMUNITY_LIST_MASTER
:
46 return &ch
->community_list
;
47 case EXTCOMMUNITY_LIST_MASTER
:
48 return &ch
->extcommunity_list
;
49 case LARGE_COMMUNITY_LIST_MASTER
:
50 return &ch
->lcommunity_list
;
55 /* Allocate a new community list entry. */
56 static struct community_entry
*community_entry_new(void)
58 return XCALLOC(MTYPE_COMMUNITY_LIST_ENTRY
,
59 sizeof(struct community_entry
));
62 /* Free community list entry. */
63 static void community_entry_free(struct community_entry
*entry
)
65 switch (entry
->style
) {
66 case COMMUNITY_LIST_STANDARD
:
68 community_free(entry
->u
.com
);
70 case LARGE_COMMUNITY_LIST_STANDARD
:
72 lcommunity_free(&entry
->u
.lcom
);
74 case EXTCOMMUNITY_LIST_STANDARD
:
75 /* In case of standard extcommunity-list, configuration string
76 is made by ecommunity_ecom2str(). */
78 XFREE(MTYPE_ECOMMUNITY_STR
, entry
->config
);
80 ecommunity_free(&entry
->u
.ecom
);
82 case COMMUNITY_LIST_EXPANDED
:
83 case EXTCOMMUNITY_LIST_EXPANDED
:
84 case LARGE_COMMUNITY_LIST_EXPANDED
:
86 XFREE(MTYPE_COMMUNITY_LIST_CONFIG
, entry
->config
);
88 bgp_regex_free(entry
->reg
);
92 XFREE(MTYPE_COMMUNITY_LIST_ENTRY
, entry
);
95 /* Allocate a new community-list. */
96 static struct community_list
*community_list_new(void)
98 return XCALLOC(MTYPE_COMMUNITY_LIST
, sizeof(struct community_list
));
101 /* Free community-list. */
102 static void community_list_free(struct community_list
*list
)
105 XFREE(MTYPE_COMMUNITY_LIST_NAME
, list
->name
);
106 XFREE(MTYPE_COMMUNITY_LIST
, list
);
109 static struct community_list
*
110 community_list_insert(struct community_list_handler
*ch
, const char *name
,
115 struct community_list
*new;
116 struct community_list
*point
;
117 struct community_list_list
*list
;
118 struct community_list_master
*cm
;
120 /* Lookup community-list master. */
121 cm
= community_list_master_lookup(ch
, master
);
125 /* Allocate new community_list and copy given name. */
126 new = community_list_new();
127 new->name
= XSTRDUP(MTYPE_COMMUNITY_LIST_NAME
, name
);
129 /* If name is made by all digit character. We treat it as
131 for (number
= 0, i
= 0; i
< strlen(name
); i
++) {
132 if (isdigit((int)name
[i
]))
133 number
= (number
* 10) + (name
[i
] - '0');
138 /* In case of name is all digit character */
139 if (i
== strlen(name
)) {
140 new->sort
= COMMUNITY_LIST_NUMBER
;
142 /* Set access_list to number list. */
145 for (point
= list
->head
; point
; point
= point
->next
)
146 if (atol(point
->name
) >= number
)
149 new->sort
= COMMUNITY_LIST_STRING
;
151 /* Set access_list to string list. */
154 /* Set point to insertion point. */
155 for (point
= list
->head
; point
; point
= point
->next
)
156 if (strcmp(point
->name
, name
) >= 0)
160 /* Link to upper list. */
163 /* In case of this is the first element of master. */
164 if (list
->head
== NULL
) {
165 list
->head
= list
->tail
= new;
169 /* In case of insertion is made at the tail of access_list. */
171 new->prev
= list
->tail
;
172 list
->tail
->next
= new;
177 /* In case of insertion is made at the head of access_list. */
178 if (point
== list
->head
) {
179 new->next
= list
->head
;
180 list
->head
->prev
= new;
185 /* Insertion is made at middle of the access_list. */
187 new->prev
= point
->prev
;
190 point
->prev
->next
= new;
196 struct community_list
*community_list_lookup(struct community_list_handler
*ch
,
197 const char *name
, int master
)
199 struct community_list
*list
;
200 struct community_list_master
*cm
;
205 cm
= community_list_master_lookup(ch
, master
);
209 for (list
= cm
->num
.head
; list
; list
= list
->next
)
210 if (strcmp(list
->name
, name
) == 0)
212 for (list
= cm
->str
.head
; list
; list
= list
->next
)
213 if (strcmp(list
->name
, name
) == 0)
219 static struct community_list
*
220 community_list_get(struct community_list_handler
*ch
, const char *name
,
223 struct community_list
*list
;
225 list
= community_list_lookup(ch
, name
, master
);
227 list
= community_list_insert(ch
, name
, master
);
231 static void community_list_delete(struct community_list
*list
)
233 struct community_list_list
*clist
;
234 struct community_entry
*entry
, *next
;
236 for (entry
= list
->head
; entry
; entry
= next
) {
238 community_entry_free(entry
);
241 clist
= list
->parent
;
244 list
->next
->prev
= list
->prev
;
246 clist
->tail
= list
->prev
;
249 list
->prev
->next
= list
->next
;
251 clist
->head
= list
->next
;
253 community_list_free(list
);
256 static int community_list_empty_p(struct community_list
*list
)
258 return (list
->head
== NULL
&& list
->tail
== NULL
) ? 1 : 0;
261 /* Add community-list entry to the list. */
262 static void community_list_entry_add(struct community_list
*list
,
263 struct community_entry
*entry
)
266 entry
->prev
= list
->tail
;
269 list
->tail
->next
= entry
;
275 /* Delete community-list entry from the list. */
276 static void community_list_entry_delete(struct community_list
*list
,
277 struct community_entry
*entry
)
280 entry
->next
->prev
= entry
->prev
;
282 list
->tail
= entry
->prev
;
285 entry
->prev
->next
= entry
->next
;
287 list
->head
= entry
->next
;
289 community_entry_free(entry
);
291 if (community_list_empty_p(list
))
292 community_list_delete(list
);
295 /* Lookup community-list entry from the list. */
296 static struct community_entry
*
297 community_list_entry_lookup(struct community_list
*list
, const void *arg
,
300 struct community_entry
*entry
;
302 for (entry
= list
->head
; entry
; entry
= entry
->next
) {
303 switch (entry
->style
) {
304 case COMMUNITY_LIST_STANDARD
:
305 if (entry
->direct
== direct
306 && community_cmp(entry
->u
.com
, arg
))
309 case EXTCOMMUNITY_LIST_STANDARD
:
310 if (entry
->direct
== direct
311 && ecommunity_cmp(entry
->u
.ecom
, arg
))
314 case LARGE_COMMUNITY_LIST_STANDARD
:
315 if (entry
->direct
== direct
316 && lcommunity_cmp(entry
->u
.lcom
, arg
))
319 case COMMUNITY_LIST_EXPANDED
:
320 case EXTCOMMUNITY_LIST_EXPANDED
:
321 case LARGE_COMMUNITY_LIST_EXPANDED
:
322 if (entry
->direct
== direct
323 && strcmp(entry
->config
, arg
) == 0)
333 static char *community_str_get(struct community
*com
, int i
)
342 memcpy(&comval
, com_nthval(com
, i
), sizeof(uint32_t));
343 comval
= ntohl(comval
);
346 case COMMUNITY_INTERNET
:
347 len
= strlen(" internet");
349 case COMMUNITY_GSHUT
:
350 len
= strlen(" graceful-shutdown");
352 case COMMUNITY_ACCEPT_OWN
:
353 len
= strlen(" accept-own");
355 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4
:
356 len
= strlen(" route-filter-translated-v4");
358 case COMMUNITY_ROUTE_FILTER_v4
:
359 len
= strlen(" route-filter-v4");
361 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6
:
362 len
= strlen(" route-filter-translated-v6");
364 case COMMUNITY_ROUTE_FILTER_v6
:
365 len
= strlen(" route-filter-v6");
367 case COMMUNITY_LLGR_STALE
:
368 len
= strlen(" llgr-stale");
370 case COMMUNITY_NO_LLGR
:
371 len
= strlen(" no-llgr");
373 case COMMUNITY_ACCEPT_OWN_NEXTHOP
:
374 len
= strlen(" accept-own-nexthop");
376 case COMMUNITY_BLACKHOLE
:
377 len
= strlen(" blackhole");
379 case COMMUNITY_NO_EXPORT
:
380 len
= strlen(" no-export");
382 case COMMUNITY_NO_ADVERTISE
:
383 len
= strlen(" no-advertise");
385 case COMMUNITY_LOCAL_AS
:
386 len
= strlen(" local-AS");
388 case COMMUNITY_NO_PEER
:
389 len
= strlen(" no-peer");
392 len
= strlen(" 65536:65535");
396 /* Allocate memory. */
397 str
= pnt
= XMALLOC(MTYPE_COMMUNITY_STR
, len
);
400 case COMMUNITY_INTERNET
:
401 strcpy(pnt
, "internet");
402 pnt
+= strlen("internet");
404 case COMMUNITY_GSHUT
:
405 strcpy(pnt
, "graceful-shutdown");
406 pnt
+= strlen("graceful-shutdown");
408 case COMMUNITY_ACCEPT_OWN
:
409 strcpy(pnt
, "accept-own");
410 pnt
+= strlen("accept-own");
412 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4
:
413 strcpy(pnt
, "route-filter-translated-v4");
414 pnt
+= strlen("route-filter-translated-v4");
416 case COMMUNITY_ROUTE_FILTER_v4
:
417 strcpy(pnt
, "route-filter-v4");
418 pnt
+= strlen("route-filter-v4");
420 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6
:
421 strcpy(pnt
, "route-filter-translated-v6");
422 pnt
+= strlen("route-filter-translated-v6");
424 case COMMUNITY_ROUTE_FILTER_v6
:
425 strcpy(pnt
, "route-filter-v6");
426 pnt
+= strlen("route-filter-v6");
428 case COMMUNITY_LLGR_STALE
:
429 strcpy(pnt
, "llgr-stale");
430 pnt
+= strlen("llgr-stale");
432 case COMMUNITY_NO_LLGR
:
433 strcpy(pnt
, "no-llgr");
434 pnt
+= strlen("no-llgr");
436 case COMMUNITY_ACCEPT_OWN_NEXTHOP
:
437 strcpy(pnt
, "accept-own-nexthop");
438 pnt
+= strlen("accept-own-nexthop");
440 case COMMUNITY_BLACKHOLE
:
441 strcpy(pnt
, "blackhole");
442 pnt
+= strlen("blackhole");
444 case COMMUNITY_NO_EXPORT
:
445 strcpy(pnt
, "no-export");
446 pnt
+= strlen("no-export");
448 case COMMUNITY_NO_ADVERTISE
:
449 strcpy(pnt
, "no-advertise");
450 pnt
+= strlen("no-advertise");
452 case COMMUNITY_LOCAL_AS
:
453 strcpy(pnt
, "local-AS");
454 pnt
+= strlen("local-AS");
456 case COMMUNITY_NO_PEER
:
457 strcpy(pnt
, "no-peer");
458 pnt
+= strlen("no-peer");
461 as
= (comval
>> 16) & 0xFFFF;
462 val
= comval
& 0xFFFF;
463 sprintf(pnt
, "%u:%d", as
, val
);
473 /* Internal function to perform regular expression match for
474 * a single community. */
475 static int community_regexp_include(regex_t
*reg
, struct community
*com
, int i
)
480 /* When there is no communities attribute it is treated as empty string.
482 if (com
== NULL
|| com
->size
== 0)
483 str
= XSTRDUP(MTYPE_COMMUNITY_STR
, "");
485 str
= community_str_get(com
, i
);
487 /* Regular expression match. */
488 rv
= regexec(reg
, str
, 0, NULL
, 0);
490 XFREE(MTYPE_COMMUNITY_STR
, str
);
499 /* Internal function to perform regular expression match for community
501 static int community_regexp_match(struct community
*com
, regex_t
*reg
)
505 /* When there is no communities attribute it is treated as empty
507 if (com
== NULL
|| com
->size
== 0)
510 str
= community_str(com
, false);
512 /* Regular expression match. */
513 if (regexec(reg
, str
, 0, NULL
, 0) == 0)
520 static char *lcommunity_str_get(struct lcommunity
*lcom
, int i
)
522 struct lcommunity_val lcomval
;
523 uint32_t globaladmin
;
530 ptr
= lcom
->val
+ (i
* LCOMMUNITY_SIZE
);
532 memcpy(&lcomval
, ptr
, LCOMMUNITY_SIZE
);
534 /* Allocate memory. 48 bytes taken off bgp_lcommunity.c */
535 str
= pnt
= XMALLOC(MTYPE_LCOMMUNITY_STR
, 48);
537 ptr
= (uint8_t *)lcomval
.val
;
538 ptr
= ptr_get_be32(ptr
, &globaladmin
);
539 ptr
= ptr_get_be32(ptr
, &localdata1
);
540 ptr
= ptr_get_be32(ptr
, &localdata2
);
541 (void)ptr
; /* consume value */
543 sprintf(pnt
, "%u:%u:%u", globaladmin
, localdata1
, localdata2
);
550 /* Internal function to perform regular expression match for
551 * a single community. */
552 static int lcommunity_regexp_include(regex_t
*reg
, struct lcommunity
*lcom
,
557 /* When there is no communities attribute it is treated as empty string.
559 if (lcom
== NULL
|| lcom
->size
== 0)
560 str
= XSTRDUP(MTYPE_LCOMMUNITY_STR
, "");
562 str
= lcommunity_str_get(lcom
, i
);
564 /* Regular expression match. */
565 if (regexec(reg
, str
, 0, NULL
, 0) == 0) {
566 XFREE(MTYPE_LCOMMUNITY_STR
, str
);
570 XFREE(MTYPE_LCOMMUNITY_STR
, str
);
575 static int lcommunity_regexp_match(struct lcommunity
*com
, regex_t
*reg
)
579 /* When there is no communities attribute it is treated as empty
581 if (com
== NULL
|| com
->size
== 0)
584 str
= lcommunity_str(com
, false);
586 /* Regular expression match. */
587 if (regexec(reg
, str
, 0, NULL
, 0) == 0)
595 static int ecommunity_regexp_match(struct ecommunity
*ecom
, regex_t
*reg
)
599 /* When there is no communities attribute it is treated as empty
601 if (ecom
== NULL
|| ecom
->size
== 0)
604 str
= ecommunity_str(ecom
);
606 /* Regular expression match. */
607 if (regexec(reg
, str
, 0, NULL
, 0) == 0)
615 /* Delete community attribute using regular expression match. Return
616 modified communites attribute. */
617 static struct community
*
618 community_regexp_delete (struct community
*com
, regex_t
* reg
)
622 /* Maximum is "65535:65535" + '\0'. */
630 while (i
< com
->size
)
632 memcpy (&comval
, com_nthval (com
, i
), sizeof (uint32_t));
633 comval
= ntohl (comval
);
636 case COMMUNITY_INTERNET
:
639 case COMMUNITY_ACCEPT_OWN
:
642 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4
:
643 str
= "route-filter-translated-v4";
645 case COMMUNITY_ROUTE_FILTER_v4
:
646 str
= "route-filter-v4";
648 case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6
:
649 str
= "route-filter-translated-v6";
651 case COMMUNITY_ROUTE_FILTER_v6
:
652 str
= "route-filter-v6";
654 case COMMUNITY_LLGR_STALE
:
657 case COMMUNITY_NO_LLGR
:
660 case COMMUNITY_ACCEPT_OWN_NEXTHOP
:
661 str
= "accept-own-nexthop";
663 case COMMUNITY_BLACKHOLE
:
666 case COMMUNITY_NO_EXPORT
:
669 case COMMUNITY_NO_ADVERTISE
:
670 str
= "no-advertise";
672 case COMMUNITY_LOCAL_AS
:
675 case COMMUNITY_NO_PEER
:
679 sprintf (c
, "%d:%d", (comval
>> 16) & 0xFFFF,
685 if (regexec (reg
, str
, 0, NULL
, 0) == 0)
686 community_del_val (com
, com_nthval (com
, i
));
694 /* When given community attribute matches to the community-list return
696 int community_list_match(struct community
*com
, struct community_list
*list
)
698 struct community_entry
*entry
;
700 for (entry
= list
->head
; entry
; entry
= entry
->next
) {
702 return entry
->direct
== COMMUNITY_PERMIT
? 1 : 0;
704 if (entry
->style
== COMMUNITY_LIST_STANDARD
) {
705 if (community_include(entry
->u
.com
, COMMUNITY_INTERNET
))
706 return entry
->direct
== COMMUNITY_PERMIT
? 1
709 if (community_match(com
, entry
->u
.com
))
710 return entry
->direct
== COMMUNITY_PERMIT
? 1
712 } else if (entry
->style
== COMMUNITY_LIST_EXPANDED
) {
713 if (community_regexp_match(com
, entry
->reg
))
714 return entry
->direct
== COMMUNITY_PERMIT
? 1
721 int lcommunity_list_match(struct lcommunity
*lcom
, struct community_list
*list
)
723 struct community_entry
*entry
;
725 for (entry
= list
->head
; entry
; entry
= entry
->next
) {
727 return entry
->direct
== COMMUNITY_PERMIT
? 1 : 0;
729 if (entry
->style
== LARGE_COMMUNITY_LIST_STANDARD
) {
730 if (lcommunity_match(lcom
, entry
->u
.lcom
))
731 return entry
->direct
== COMMUNITY_PERMIT
? 1
733 } else if (entry
->style
== LARGE_COMMUNITY_LIST_EXPANDED
) {
734 if (lcommunity_regexp_match(lcom
, entry
->reg
))
735 return entry
->direct
== COMMUNITY_PERMIT
? 1
742 int ecommunity_list_match(struct ecommunity
*ecom
, struct community_list
*list
)
744 struct community_entry
*entry
;
746 for (entry
= list
->head
; entry
; entry
= entry
->next
) {
748 return entry
->direct
== COMMUNITY_PERMIT
? 1 : 0;
750 if (entry
->style
== EXTCOMMUNITY_LIST_STANDARD
) {
751 if (ecommunity_match(ecom
, entry
->u
.ecom
))
752 return entry
->direct
== COMMUNITY_PERMIT
? 1
754 } else if (entry
->style
== EXTCOMMUNITY_LIST_EXPANDED
) {
755 if (ecommunity_regexp_match(ecom
, entry
->reg
))
756 return entry
->direct
== COMMUNITY_PERMIT
? 1
763 /* Perform exact matching. In case of expanded community-list, do
764 same thing as community_list_match(). */
765 int community_list_exact_match(struct community
*com
,
766 struct community_list
*list
)
768 struct community_entry
*entry
;
770 for (entry
= list
->head
; entry
; entry
= entry
->next
) {
772 return entry
->direct
== COMMUNITY_PERMIT
? 1 : 0;
774 if (entry
->style
== COMMUNITY_LIST_STANDARD
) {
775 if (community_include(entry
->u
.com
, COMMUNITY_INTERNET
))
776 return entry
->direct
== COMMUNITY_PERMIT
? 1
779 if (community_cmp(com
, entry
->u
.com
))
780 return entry
->direct
== COMMUNITY_PERMIT
? 1
782 } else if (entry
->style
== COMMUNITY_LIST_EXPANDED
) {
783 if (community_regexp_match(com
, entry
->reg
))
784 return entry
->direct
== COMMUNITY_PERMIT
? 1
791 /* Delete all permitted communities in the list from com. */
792 struct community
*community_list_match_delete(struct community
*com
,
793 struct community_list
*list
)
795 struct community_entry
*entry
;
797 uint32_t com_index_to_delete
[com
->size
];
798 int delete_index
= 0;
801 /* Loop over each community value and evaluate each against the
802 * community-list. If we need to delete a community value add its index
803 * to com_index_to_delete.
805 for (i
= 0; i
< com
->size
; i
++) {
806 val
= community_val_get(com
, i
);
808 for (entry
= list
->head
; entry
; entry
= entry
->next
) {
810 if (entry
->direct
== COMMUNITY_PERMIT
) {
811 com_index_to_delete
[delete_index
] = i
;
817 else if ((entry
->style
== COMMUNITY_LIST_STANDARD
)
818 && (community_include(entry
->u
.com
,
820 || community_include(entry
->u
.com
, val
))) {
821 if (entry
->direct
== COMMUNITY_PERMIT
) {
822 com_index_to_delete
[delete_index
] = i
;
828 else if ((entry
->style
== COMMUNITY_LIST_EXPANDED
)
829 && community_regexp_include(entry
->reg
, com
,
831 if (entry
->direct
== COMMUNITY_PERMIT
) {
832 com_index_to_delete
[delete_index
] = i
;
840 /* Delete all of the communities we flagged for deletion */
841 for (i
= delete_index
- 1; i
>= 0; i
--) {
842 val
= community_val_get(com
, com_index_to_delete
[i
]);
843 community_del_val(com
, &val
);
849 /* To avoid duplicated entry in the community-list, this function
850 compares specified entry to existing entry. */
851 static int community_list_dup_check(struct community_list
*list
,
852 struct community_entry
*new)
854 struct community_entry
*entry
;
856 for (entry
= list
->head
; entry
; entry
= entry
->next
) {
857 if (entry
->style
!= new->style
)
860 if (entry
->direct
!= new->direct
)
863 if (entry
->any
!= new->any
)
869 switch (entry
->style
) {
870 case COMMUNITY_LIST_STANDARD
:
871 if (community_cmp(entry
->u
.com
, new->u
.com
))
874 case LARGE_COMMUNITY_LIST_STANDARD
:
875 if (lcommunity_cmp(entry
->u
.lcom
, new->u
.lcom
))
878 case EXTCOMMUNITY_LIST_STANDARD
:
879 if (ecommunity_cmp(entry
->u
.ecom
, new->u
.ecom
))
882 case COMMUNITY_LIST_EXPANDED
:
883 case EXTCOMMUNITY_LIST_EXPANDED
:
884 case LARGE_COMMUNITY_LIST_EXPANDED
:
885 if (strcmp(entry
->config
, new->config
) == 0)
895 /* Set community-list. */
896 int community_list_set(struct community_list_handler
*ch
, const char *name
,
897 const char *str
, int direct
, int style
)
899 struct community_entry
*entry
= NULL
;
900 struct community_list
*list
;
901 struct community
*com
= NULL
;
902 regex_t
*regex
= NULL
;
904 /* Get community list. */
905 list
= community_list_get(ch
, name
, COMMUNITY_LIST_MASTER
);
907 /* When community-list already has entry, new entry should have same
908 style. If you want to have mixed style community-list, you can
909 comment out this check. */
910 if (!community_list_empty_p(list
)) {
911 struct community_entry
*first
;
915 if (style
!= first
->style
) {
916 return (first
->style
== COMMUNITY_LIST_STANDARD
917 ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
918 : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT
);
923 if (style
== COMMUNITY_LIST_STANDARD
)
924 com
= community_str2com(str
);
926 regex
= bgp_regcomp(str
);
929 return COMMUNITY_LIST_ERR_MALFORMED_VAL
;
932 entry
= community_entry_new();
933 entry
->direct
= direct
;
934 entry
->style
= style
;
935 entry
->any
= (str
? 0 : 1);
939 (regex
? XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG
, str
) : NULL
);
941 /* Do not put duplicated community entry. */
942 if (community_list_dup_check(list
, entry
))
943 community_entry_free(entry
);
945 community_list_entry_add(list
, entry
);
946 route_map_notify_dependencies(name
, RMAP_EVENT_CLIST_ADDED
);
952 /* Unset community-list */
953 int community_list_unset(struct community_list_handler
*ch
, const char *name
,
954 const char *str
, int direct
, int style
)
956 struct community_entry
*entry
= NULL
;
957 struct community_list
*list
;
958 struct community
*com
= NULL
;
960 /* Lookup community list. */
961 list
= community_list_lookup(ch
, name
, COMMUNITY_LIST_MASTER
);
963 return COMMUNITY_LIST_ERR_CANT_FIND_LIST
;
965 /* Delete all of entry belongs to this community-list. */
967 community_list_delete(list
);
968 route_map_notify_dependencies(name
, RMAP_EVENT_CLIST_DELETED
);
972 if (style
== COMMUNITY_LIST_STANDARD
)
973 com
= community_str2com(str
);
976 entry
= community_list_entry_lookup(list
, com
, direct
);
979 entry
= community_list_entry_lookup(list
, str
, direct
);
982 return COMMUNITY_LIST_ERR_CANT_FIND_LIST
;
984 community_list_entry_delete(list
, entry
);
985 route_map_notify_dependencies(name
, RMAP_EVENT_CLIST_DELETED
);
990 /* Delete all permitted large communities in the list from com. */
991 struct lcommunity
*lcommunity_list_match_delete(struct lcommunity
*lcom
,
992 struct community_list
*list
)
994 struct community_entry
*entry
;
995 uint32_t com_index_to_delete
[lcom
->size
];
997 int delete_index
= 0;
1000 /* Loop over each lcommunity value and evaluate each against the
1001 * community-list. If we need to delete a community value add its index
1002 * to com_index_to_delete.
1004 for (i
= 0; i
< lcom
->size
; i
++) {
1005 ptr
= lcom
->val
+ (i
* LCOMMUNITY_SIZE
);
1006 for (entry
= list
->head
; entry
; entry
= entry
->next
) {
1008 if (entry
->direct
== COMMUNITY_PERMIT
) {
1009 com_index_to_delete
[delete_index
] = i
;
1015 else if ((entry
->style
== LARGE_COMMUNITY_LIST_STANDARD
)
1016 && lcommunity_include(entry
->u
.lcom
, ptr
)) {
1017 if (entry
->direct
== COMMUNITY_PERMIT
) {
1018 com_index_to_delete
[delete_index
] = i
;
1024 else if ((entry
->style
== LARGE_COMMUNITY_LIST_EXPANDED
)
1025 && lcommunity_regexp_include(entry
->reg
, lcom
,
1027 if (entry
->direct
== COMMUNITY_PERMIT
) {
1028 com_index_to_delete
[delete_index
] = i
;
1036 /* Delete all of the communities we flagged for deletion */
1037 for (i
= delete_index
- 1; i
>= 0; i
--) {
1038 ptr
= lcom
->val
+ (com_index_to_delete
[i
] * LCOMMUNITY_SIZE
);
1039 lcommunity_del_val(lcom
, ptr
);
1045 /* Set lcommunity-list. */
1046 int lcommunity_list_set(struct community_list_handler
*ch
, const char *name
,
1047 const char *str
, int direct
, int style
)
1049 struct community_entry
*entry
= NULL
;
1050 struct community_list
*list
;
1051 struct lcommunity
*lcom
= NULL
;
1052 regex_t
*regex
= NULL
;
1054 /* Get community list. */
1055 list
= community_list_get(ch
, name
, LARGE_COMMUNITY_LIST_MASTER
);
1057 /* When community-list already has entry, new entry should have same
1058 style. If you want to have mixed style community-list, you can
1059 comment out this check. */
1060 if (!community_list_empty_p(list
)) {
1061 struct community_entry
*first
;
1065 if (style
!= first
->style
) {
1066 return (first
->style
== COMMUNITY_LIST_STANDARD
1067 ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
1068 : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT
);
1073 if (style
== LARGE_COMMUNITY_LIST_STANDARD
)
1074 lcom
= lcommunity_str2com(str
);
1076 regex
= bgp_regcomp(str
);
1078 if (!lcom
&& !regex
)
1079 return COMMUNITY_LIST_ERR_MALFORMED_VAL
;
1082 entry
= community_entry_new();
1083 entry
->direct
= direct
;
1084 entry
->style
= style
;
1085 entry
->any
= (str
? 0 : 1);
1086 entry
->u
.lcom
= lcom
;
1089 (regex
? XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG
, str
) : NULL
);
1091 /* Do not put duplicated community entry. */
1092 if (community_list_dup_check(list
, entry
))
1093 community_entry_free(entry
);
1095 community_list_entry_add(list
, entry
);
1100 /* Unset community-list. When str is NULL, delete all of
1101 community-list entry belongs to the specified name. */
1102 int lcommunity_list_unset(struct community_list_handler
*ch
, const char *name
,
1103 const char *str
, int direct
, int style
)
1105 struct community_entry
*entry
= NULL
;
1106 struct community_list
*list
;
1107 struct lcommunity
*lcom
= NULL
;
1108 regex_t
*regex
= NULL
;
1110 /* Lookup community list. */
1111 list
= community_list_lookup(ch
, name
, LARGE_COMMUNITY_LIST_MASTER
);
1113 return COMMUNITY_LIST_ERR_CANT_FIND_LIST
;
1115 /* Delete all of entry belongs to this community-list. */
1117 community_list_delete(list
);
1121 if (style
== LARGE_COMMUNITY_LIST_STANDARD
)
1122 lcom
= lcommunity_str2com(str
);
1124 regex
= bgp_regcomp(str
);
1126 if (!lcom
&& !regex
)
1127 return COMMUNITY_LIST_ERR_MALFORMED_VAL
;
1130 entry
= community_list_entry_lookup(list
, lcom
, direct
);
1132 entry
= community_list_entry_lookup(list
, str
, direct
);
1135 lcommunity_free(&lcom
);
1137 bgp_regex_free(regex
);
1140 return COMMUNITY_LIST_ERR_CANT_FIND_LIST
;
1142 community_list_entry_delete(list
, entry
);
1147 /* Set extcommunity-list. */
1148 int extcommunity_list_set(struct community_list_handler
*ch
, const char *name
,
1149 const char *str
, int direct
, int style
)
1151 struct community_entry
*entry
= NULL
;
1152 struct community_list
*list
;
1153 struct ecommunity
*ecom
= NULL
;
1154 regex_t
*regex
= NULL
;
1157 return COMMUNITY_LIST_ERR_MALFORMED_VAL
;
1159 /* Get community list. */
1160 list
= community_list_get(ch
, name
, EXTCOMMUNITY_LIST_MASTER
);
1162 /* When community-list already has entry, new entry should have same
1163 style. If you want to have mixed style community-list, you can
1164 comment out this check. */
1165 if (!community_list_empty_p(list
)) {
1166 struct community_entry
*first
;
1170 if (style
!= first
->style
) {
1171 return (first
->style
== EXTCOMMUNITY_LIST_STANDARD
1172 ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
1173 : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT
);
1177 if (style
== EXTCOMMUNITY_LIST_STANDARD
)
1178 ecom
= ecommunity_str2com(str
, 0, 1);
1180 regex
= bgp_regcomp(str
);
1182 if (!ecom
&& !regex
)
1183 return COMMUNITY_LIST_ERR_MALFORMED_VAL
;
1187 ecommunity_ecom2str(ecom
, ECOMMUNITY_FORMAT_DISPLAY
, 0);
1189 entry
= community_entry_new();
1190 entry
->direct
= direct
;
1191 entry
->style
= style
;
1194 entry
->config
= ecommunity_ecom2str(
1195 ecom
, ECOMMUNITY_FORMAT_COMMUNITY_LIST
, 0);
1197 entry
->config
= XSTRDUP(MTYPE_COMMUNITY_LIST_CONFIG
, str
);
1199 entry
->u
.ecom
= ecom
;
1202 /* Do not put duplicated community entry. */
1203 if (community_list_dup_check(list
, entry
))
1204 community_entry_free(entry
);
1206 community_list_entry_add(list
, entry
);
1207 route_map_notify_dependencies(name
, RMAP_EVENT_ECLIST_ADDED
);
1213 /* Unset extcommunity-list.
1215 * When str is NULL, delete all extcommunity-list entries belonging to the
1218 int extcommunity_list_unset(struct community_list_handler
*ch
, const char *name
,
1219 const char *str
, int direct
, int style
)
1221 struct community_entry
*entry
= NULL
;
1222 struct community_list
*list
;
1223 struct ecommunity
*ecom
= NULL
;
1225 /* Lookup extcommunity list. */
1226 list
= community_list_lookup(ch
, name
, EXTCOMMUNITY_LIST_MASTER
);
1228 return COMMUNITY_LIST_ERR_CANT_FIND_LIST
;
1230 /* Delete all of entry belongs to this extcommunity-list. */
1232 community_list_delete(list
);
1233 route_map_notify_dependencies(name
, RMAP_EVENT_ECLIST_DELETED
);
1237 if (style
== EXTCOMMUNITY_LIST_STANDARD
)
1238 ecom
= ecommunity_str2com(str
, 0, 1);
1241 entry
= community_list_entry_lookup(list
, ecom
, direct
);
1242 ecommunity_free(&ecom
);
1244 entry
= community_list_entry_lookup(list
, str
, direct
);
1247 return COMMUNITY_LIST_ERR_CANT_FIND_LIST
;
1249 community_list_entry_delete(list
, entry
);
1250 route_map_notify_dependencies(name
, RMAP_EVENT_ECLIST_DELETED
);
1255 /* Initializa community-list. Return community-list handler. */
1256 struct community_list_handler
*community_list_init(void)
1258 struct community_list_handler
*ch
;
1259 ch
= XCALLOC(MTYPE_COMMUNITY_LIST_HANDLER
,
1260 sizeof(struct community_list_handler
));
1264 /* Terminate community-list. */
1265 void community_list_terminate(struct community_list_handler
*ch
)
1267 struct community_list_master
*cm
;
1268 struct community_list
*list
;
1270 cm
= &ch
->community_list
;
1271 while ((list
= cm
->num
.head
) != NULL
)
1272 community_list_delete(list
);
1273 while ((list
= cm
->str
.head
) != NULL
)
1274 community_list_delete(list
);
1276 cm
= &ch
->lcommunity_list
;
1277 while ((list
= cm
->num
.head
) != NULL
)
1278 community_list_delete(list
);
1279 while ((list
= cm
->str
.head
) != NULL
)
1280 community_list_delete(list
);
1282 cm
= &ch
->extcommunity_list
;
1283 while ((list
= cm
->num
.head
) != NULL
)
1284 community_list_delete(list
);
1285 while ((list
= cm
->str
.head
) != NULL
)
1286 community_list_delete(list
);
1288 XFREE(MTYPE_COMMUNITY_LIST_HANDLER
, ch
);