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
17: along with GNU Zebra; see the file COPYING. If not, write to the Free
18: Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19: 02111-1307, USA. */
20:
21: #include <zebra.h>
22:
23: #include "command.h"
24: #include "prefix.h"
25: #include "memory.h"
26:
27: #include "bgpd/bgpd.h"
28: #include "bgpd/bgp_community.h"
29: #include "bgpd/bgp_ecommunity.h"
30: #include "bgpd/bgp_aspath.h"
31: #include "bgpd/bgp_regex.h"
32: #include "bgpd/bgp_clist.h"
33:
34: /* Lookup master structure for community-list or
35: extcommunity-list. */
36: struct community_list_master *
37: community_list_master_lookup (struct community_list_handler *ch, int master)
38: {
39: if (ch)
40: switch (master)
41: {
42: case COMMUNITY_LIST_MASTER:
43: return &ch->community_list;
44: case EXTCOMMUNITY_LIST_MASTER:
45: return &ch->extcommunity_list;
46: }
47: return NULL;
48: }
49:
50: /* Allocate a new community list entry. */
51: static struct community_entry *
52: community_entry_new (void)
53: {
54: return XCALLOC (MTYPE_COMMUNITY_LIST_ENTRY, sizeof (struct community_entry));
55: }
56:
57: /* Free community list entry. */
58: static void
59: community_entry_free (struct community_entry *entry)
60: {
61: switch (entry->style)
62: {
63: case COMMUNITY_LIST_STANDARD:
64: if (entry->u.com)
65: community_free (entry->u.com);
66: break;
67: case EXTCOMMUNITY_LIST_STANDARD:
68: /* In case of standard extcommunity-list, configuration string
69: is made by ecommunity_ecom2str(). */
70: if (entry->config)
71: XFREE (MTYPE_ECOMMUNITY_STR, entry->config);
72: if (entry->u.ecom)
73: ecommunity_free (&entry->u.ecom);
74: break;
75: case COMMUNITY_LIST_EXPANDED:
76: case EXTCOMMUNITY_LIST_EXPANDED:
77: if (entry->config)
78: XFREE (MTYPE_COMMUNITY_LIST_CONFIG, entry->config);
79: if (entry->reg)
80: bgp_regex_free (entry->reg);
81: default:
82: break;
83: }
84: XFREE (MTYPE_COMMUNITY_LIST_ENTRY, entry);
85: }
86:
87: /* Allocate a new community-list. */
88: static struct community_list *
89: community_list_new (void)
90: {
91: return XCALLOC (MTYPE_COMMUNITY_LIST, sizeof (struct community_list));
92: }
93:
94: /* Free community-list. */
95: static void
96: community_list_free (struct community_list *list)
97: {
98: if (list->name)
99: XFREE (MTYPE_COMMUNITY_LIST_NAME, list->name);
100: XFREE (MTYPE_COMMUNITY_LIST, list);
101: }
102:
103: static struct community_list *
104: community_list_insert (struct community_list_handler *ch,
105: const char *name, int master)
106: {
107: size_t i;
108: long number;
109: struct community_list *new;
110: struct community_list *point;
111: struct community_list_list *list;
112: struct community_list_master *cm;
113:
114: /* Lookup community-list master. */
115: cm = community_list_master_lookup (ch, master);
116: if (!cm)
117: return NULL;
118:
119: /* Allocate new community_list and copy given name. */
120: new = community_list_new ();
121: new->name = XSTRDUP (MTYPE_COMMUNITY_LIST_NAME, name);
122:
123: /* If name is made by all digit character. We treat it as
124: number. */
125: for (number = 0, i = 0; i < strlen (name); i++)
126: {
127: if (isdigit ((int) name[i]))
128: number = (number * 10) + (name[i] - '0');
129: else
130: break;
131: }
132:
133: /* In case of name is all digit character */
134: if (i == strlen (name))
135: {
136: new->sort = COMMUNITY_LIST_NUMBER;
137:
138: /* Set access_list to number list. */
139: list = &cm->num;
140:
141: for (point = list->head; point; point = point->next)
142: if (atol (point->name) >= number)
143: break;
144: }
145: else
146: {
147: new->sort = COMMUNITY_LIST_STRING;
148:
149: /* Set access_list to string list. */
150: list = &cm->str;
151:
152: /* Set point to insertion point. */
153: for (point = list->head; point; point = point->next)
154: if (strcmp (point->name, name) >= 0)
155: break;
156: }
157:
158: /* Link to upper list. */
159: new->parent = list;
160:
161: /* In case of this is the first element of master. */
162: if (list->head == NULL)
163: {
164: list->head = list->tail = new;
165: return new;
166: }
167:
168: /* In case of insertion is made at the tail of access_list. */
169: if (point == NULL)
170: {
171: new->prev = list->tail;
172: list->tail->next = new;
173: list->tail = new;
174: return new;
175: }
176:
177: /* In case of insertion is made at the head of access_list. */
178: if (point == list->head)
179: {
180: new->next = list->head;
181: list->head->prev = new;
182: list->head = new;
183: return new;
184: }
185:
186: /* Insertion is made at middle of the access_list. */
187: new->next = point;
188: new->prev = point->prev;
189:
190: if (point->prev)
191: point->prev->next = new;
192: point->prev = new;
193:
194: return new;
195: }
196:
197: struct community_list *
198: community_list_lookup (struct community_list_handler *ch,
199: const char *name, int master)
200: {
201: struct community_list *list;
202: struct community_list_master *cm;
203:
204: if (!name)
205: return NULL;
206:
207: cm = community_list_master_lookup (ch, master);
208: if (!cm)
209: return NULL;
210:
211: for (list = cm->num.head; list; list = list->next)
212: if (strcmp (list->name, name) == 0)
213: return list;
214: for (list = cm->str.head; list; list = list->next)
215: if (strcmp (list->name, name) == 0)
216: return list;
217:
218: return NULL;
219: }
220:
221: static struct community_list *
222: community_list_get (struct community_list_handler *ch,
223: const char *name, int master)
224: {
225: struct community_list *list;
226:
227: list = community_list_lookup (ch, name, master);
228: if (!list)
229: list = community_list_insert (ch, name, master);
230: return list;
231: }
232:
233: static void
234: community_list_delete (struct community_list *list)
235: {
236: struct community_list_list *clist;
237: struct community_entry *entry, *next;
238:
239: for (entry = list->head; entry; entry = next)
240: {
241: next = entry->next;
242: community_entry_free (entry);
243: }
244:
245: clist = list->parent;
246:
247: if (list->next)
248: list->next->prev = list->prev;
249: else
250: clist->tail = list->prev;
251:
252: if (list->prev)
253: list->prev->next = list->next;
254: else
255: clist->head = list->next;
256:
257: community_list_free (list);
258: }
259:
260: static int
261: community_list_empty_p (struct community_list *list)
262: {
263: return (list->head == NULL && list->tail == NULL) ? 1 : 0;
264: }
265:
266: /* Add community-list entry to the list. */
267: static void
268: community_list_entry_add (struct community_list *list,
269: struct community_entry *entry)
270: {
271: entry->next = NULL;
272: entry->prev = list->tail;
273:
274: if (list->tail)
275: list->tail->next = entry;
276: else
277: list->head = entry;
278: list->tail = entry;
279: }
280:
281: /* Delete community-list entry from the list. */
282: static void
283: community_list_entry_delete (struct community_list *list,
284: struct community_entry *entry, int style)
285: {
286: if (entry->next)
287: entry->next->prev = entry->prev;
288: else
289: list->tail = entry->prev;
290:
291: if (entry->prev)
292: entry->prev->next = entry->next;
293: else
294: list->head = entry->next;
295:
296: community_entry_free (entry);
297:
298: if (community_list_empty_p (list))
299: community_list_delete (list);
300: }
301:
302: /* Lookup community-list entry from the list. */
303: static struct community_entry *
304: community_list_entry_lookup (struct community_list *list, const void *arg,
305: int direct)
306: {
307: struct community_entry *entry;
308:
309: for (entry = list->head; entry; entry = entry->next)
310: {
311: switch (entry->style)
312: {
313: case COMMUNITY_LIST_STANDARD:
314: if (community_cmp (entry->u.com, arg))
315: return entry;
316: break;
317: case EXTCOMMUNITY_LIST_STANDARD:
318: if (ecommunity_cmp (entry->u.ecom, arg))
319: return entry;
320: break;
321: case COMMUNITY_LIST_EXPANDED:
322: case EXTCOMMUNITY_LIST_EXPANDED:
323: if (strcmp (entry->config, arg) == 0)
324: return entry;
325: break;
326: default:
327: break;
328: }
329: }
330: return NULL;
331: }
332:
333: /* Internal function to perform regular expression match for community
334: attribute. */
335: static int
336: community_regexp_match (struct community *com, regex_t * reg)
337: {
338: const char *str;
339:
340: /* When there is no communities attribute it is treated as empty
341: string. */
342: if (com == NULL || com->size == 0)
343: str = "";
344: else
345: str = community_str (com);
346:
347: /* Regular expression match. */
348: if (regexec (reg, str, 0, NULL, 0) == 0)
349: return 1;
350:
351: /* No match. */
352: return 0;
353: }
354:
355: static int
356: ecommunity_regexp_match (struct ecommunity *ecom, regex_t * reg)
357: {
358: const char *str;
359:
360: /* When there is no communities attribute it is treated as empty
361: string. */
362: if (ecom == NULL || ecom->size == 0)
363: str = "";
364: else
365: str = ecommunity_str (ecom);
366:
367: /* Regular expression match. */
368: if (regexec (reg, str, 0, NULL, 0) == 0)
369: return 1;
370:
371: /* No match. */
372: return 0;
373: }
374:
375: /* Delete community attribute using regular expression match. Return
376: modified communites attribute. */
377: static struct community *
378: community_regexp_delete (struct community *com, regex_t * reg)
379: {
380: int i;
381: u_int32_t comval;
382: /* Maximum is "65535:65535" + '\0'. */
383: char c[12];
384: const char *str;
385:
386: if (!com)
387: return NULL;
388:
389: i = 0;
390: while (i < com->size)
391: {
392: memcpy (&comval, com_nthval (com, i), sizeof (u_int32_t));
393: comval = ntohl (comval);
394:
395: switch (comval)
396: {
397: case COMMUNITY_INTERNET:
398: str = "internet";
399: break;
400: case COMMUNITY_NO_EXPORT:
401: str = "no-export";
402: break;
403: case COMMUNITY_NO_ADVERTISE:
404: str = "no-advertise";
405: break;
406: case COMMUNITY_LOCAL_AS:
407: str = "local-AS";
408: break;
409: default:
410: sprintf (c, "%d:%d", (comval >> 16) & 0xFFFF, comval & 0xFFFF);
411: str = c;
412: break;
413: }
414:
415: if (regexec (reg, str, 0, NULL, 0) == 0)
416: community_del_val (com, com_nthval (com, i));
417: else
418: i++;
419: }
420: return com;
421: }
422:
423: /* When given community attribute matches to the community-list return
424: 1 else return 0. */
425: int
426: community_list_match (struct community *com, struct community_list *list)
427: {
428: struct community_entry *entry;
429:
430: for (entry = list->head; entry; entry = entry->next)
431: {
432: if (entry->any)
433: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
434:
435: if (entry->style == COMMUNITY_LIST_STANDARD)
436: {
437: if (community_include (entry->u.com, COMMUNITY_INTERNET))
438: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
439:
440: if (community_match (com, entry->u.com))
441: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
442: }
443: else if (entry->style == COMMUNITY_LIST_EXPANDED)
444: {
445: if (community_regexp_match (com, entry->reg))
446: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
447: }
448: }
449: return 0;
450: }
451:
452: int
453: ecommunity_list_match (struct ecommunity *ecom, struct community_list *list)
454: {
455: struct community_entry *entry;
456:
457: for (entry = list->head; entry; entry = entry->next)
458: {
459: if (entry->any)
460: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
461:
462: if (entry->style == EXTCOMMUNITY_LIST_STANDARD)
463: {
464: if (ecommunity_match (ecom, entry->u.ecom))
465: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
466: }
467: else if (entry->style == EXTCOMMUNITY_LIST_EXPANDED)
468: {
469: if (ecommunity_regexp_match (ecom, entry->reg))
470: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
471: }
472: }
473: return 0;
474: }
475:
476: /* Perform exact matching. In case of expanded community-list, do
477: same thing as community_list_match(). */
478: int
479: community_list_exact_match (struct community *com,
480: struct community_list *list)
481: {
482: struct community_entry *entry;
483:
484: for (entry = list->head; entry; entry = entry->next)
485: {
486: if (entry->any)
487: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
488:
489: if (entry->style == COMMUNITY_LIST_STANDARD)
490: {
491: if (community_include (entry->u.com, COMMUNITY_INTERNET))
492: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
493:
494: if (community_cmp (com, entry->u.com))
495: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
496: }
497: else if (entry->style == COMMUNITY_LIST_EXPANDED)
498: {
499: if (community_regexp_match (com, entry->reg))
500: return entry->direct == COMMUNITY_PERMIT ? 1 : 0;
501: }
502: }
503: return 0;
504: }
505:
506: /* Delete all permitted communities in the list from com. */
507: struct community *
508: community_list_match_delete (struct community *com,
509: struct community_list *list)
510: {
511: struct community_entry *entry;
512:
513: for (entry = list->head; entry; entry = entry->next)
514: {
515: if (entry->any)
516: {
517: if (entry->direct == COMMUNITY_PERMIT)
518: {
519: /* This is a tricky part. Currently only
520: * route_set_community_delete() uses this function. In the
521: * function com->size is zero, it free the community
522: * structure.
523: */
524: com->size = 0;
525: }
526: return com;
527: }
528:
529: if ((entry->style == COMMUNITY_LIST_STANDARD)
530: && (community_include (entry->u.com, COMMUNITY_INTERNET)
531: || community_match (com, entry->u.com) ))
532: {
533: if (entry->direct == COMMUNITY_PERMIT)
534: community_delete (com, entry->u.com);
535: else
536: break;
537: }
538: else if ((entry->style == COMMUNITY_LIST_EXPANDED)
539: && community_regexp_match (com, entry->reg))
540: {
541: if (entry->direct == COMMUNITY_PERMIT)
542: community_regexp_delete (com, entry->reg);
543: else
544: break;
545: }
546: }
547: return com;
548: }
549:
550: /* To avoid duplicated entry in the community-list, this function
551: compares specified entry to existing entry. */
552: static int
553: community_list_dup_check (struct community_list *list,
554: struct community_entry *new)
555: {
556: struct community_entry *entry;
557:
558: for (entry = list->head; entry; entry = entry->next)
559: {
560: if (entry->style != new->style)
561: continue;
562:
563: if (entry->direct != new->direct)
564: continue;
565:
566: if (entry->any != new->any)
567: continue;
568:
569: if (entry->any)
570: return 1;
571:
572: switch (entry->style)
573: {
574: case COMMUNITY_LIST_STANDARD:
575: if (community_cmp (entry->u.com, new->u.com))
576: return 1;
577: break;
578: case EXTCOMMUNITY_LIST_STANDARD:
579: if (ecommunity_cmp (entry->u.ecom, new->u.ecom))
580: return 1;
581: break;
582: case COMMUNITY_LIST_EXPANDED:
583: case EXTCOMMUNITY_LIST_EXPANDED:
584: if (strcmp (entry->config, new->config) == 0)
585: return 1;
586: break;
587: default:
588: break;
589: }
590: }
591: return 0;
592: }
593:
594: /* Set community-list. */
595: int
596: community_list_set (struct community_list_handler *ch,
597: const char *name, const char *str, int direct, int style)
598: {
599: struct community_entry *entry = NULL;
600: struct community_list *list;
601: struct community *com = NULL;
602: regex_t *regex = NULL;
603:
604: /* Get community list. */
605: list = community_list_get (ch, name, COMMUNITY_LIST_MASTER);
606:
607: /* When community-list already has entry, new entry should have same
608: style. If you want to have mixed style community-list, you can
609: comment out this check. */
610: if (!community_list_empty_p (list))
611: {
612: struct community_entry *first;
613:
614: first = list->head;
615:
616: if (style != first->style)
617: {
618: return (first->style == COMMUNITY_LIST_STANDARD
619: ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
620: : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
621: }
622: }
623:
624: if (str)
625: {
626: if (style == COMMUNITY_LIST_STANDARD)
627: com = community_str2com (str);
628: else
629: regex = bgp_regcomp (str);
630:
631: if (! com && ! regex)
632: return COMMUNITY_LIST_ERR_MALFORMED_VAL;
633: }
634:
635: entry = community_entry_new ();
636: entry->direct = direct;
637: entry->style = style;
638: entry->any = (str ? 0 : 1);
639: entry->u.com = com;
640: entry->reg = regex;
641: entry->config = (regex ? XSTRDUP (MTYPE_COMMUNITY_LIST_CONFIG, str) : NULL);
642:
643: /* Do not put duplicated community entry. */
644: if (community_list_dup_check (list, entry))
645: community_entry_free (entry);
646: else
647: community_list_entry_add (list, entry);
648:
649: return 0;
650: }
651:
652: /* Unset community-list. When str is NULL, delete all of
653: community-list entry belongs to the specified name. */
654: int
655: community_list_unset (struct community_list_handler *ch,
656: const char *name, const char *str,
657: int direct, int style)
658: {
659: struct community_entry *entry = NULL;
660: struct community_list *list;
661: struct community *com = NULL;
662: regex_t *regex = NULL;
663:
664: /* Lookup community list. */
665: list = community_list_lookup (ch, name, COMMUNITY_LIST_MASTER);
666: if (list == NULL)
667: return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
668:
669: /* Delete all of entry belongs to this community-list. */
670: if (!str)
671: {
672: community_list_delete (list);
673: return 0;
674: }
675:
676: if (style == COMMUNITY_LIST_STANDARD)
677: com = community_str2com (str);
678: else
679: regex = bgp_regcomp (str);
680:
681: if (! com && ! regex)
682: return COMMUNITY_LIST_ERR_MALFORMED_VAL;
683:
684: if (com)
685: entry = community_list_entry_lookup (list, com, direct);
686: else
687: entry = community_list_entry_lookup (list, str, direct);
688:
689: if (com)
690: community_free (com);
691: if (regex)
692: bgp_regex_free (regex);
693:
694: if (!entry)
695: return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
696:
697: community_list_entry_delete (list, entry, style);
698:
699: return 0;
700: }
701:
702: /* Set extcommunity-list. */
703: int
704: extcommunity_list_set (struct community_list_handler *ch,
705: const char *name, const char *str,
706: int direct, int style)
707: {
708: struct community_entry *entry = NULL;
709: struct community_list *list;
710: struct ecommunity *ecom = NULL;
711: regex_t *regex = NULL;
712:
713: entry = NULL;
714:
715: /* Get community list. */
716: list = community_list_get (ch, name, EXTCOMMUNITY_LIST_MASTER);
717:
718: /* When community-list already has entry, new entry should have same
719: style. If you want to have mixed style community-list, you can
720: comment out this check. */
721: if (!community_list_empty_p (list))
722: {
723: struct community_entry *first;
724:
725: first = list->head;
726:
727: if (style != first->style)
728: {
729: return (first->style == EXTCOMMUNITY_LIST_STANDARD
730: ? COMMUNITY_LIST_ERR_STANDARD_CONFLICT
731: : COMMUNITY_LIST_ERR_EXPANDED_CONFLICT);
732: }
733: }
734:
735: if (str)
736: {
737: if (style == EXTCOMMUNITY_LIST_STANDARD)
738: ecom = ecommunity_str2com (str, 0, 1);
739: else
740: regex = bgp_regcomp (str);
741:
742: if (! ecom && ! regex)
743: return COMMUNITY_LIST_ERR_MALFORMED_VAL;
744: }
745:
746: if (ecom)
747: ecom->str = ecommunity_ecom2str (ecom, ECOMMUNITY_FORMAT_DISPLAY);
748:
749: entry = community_entry_new ();
750: entry->direct = direct;
751: entry->style = style;
752: entry->any = (str ? 0 : 1);
753: if (ecom)
754: entry->config = ecommunity_ecom2str (ecom, ECOMMUNITY_FORMAT_COMMUNITY_LIST);
755: else if (regex)
756: entry->config = XSTRDUP (MTYPE_COMMUNITY_LIST_CONFIG, str);
757: else
758: entry->config = NULL;
759: entry->u.ecom = ecom;
760: entry->reg = regex;
761:
762: /* Do not put duplicated community entry. */
763: if (community_list_dup_check (list, entry))
764: community_entry_free (entry);
765: else
766: community_list_entry_add (list, entry);
767:
768: return 0;
769: }
770:
771: /* Unset extcommunity-list. When str is NULL, delete all of
772: extcommunity-list entry belongs to the specified name. */
773: int
774: extcommunity_list_unset (struct community_list_handler *ch,
775: const char *name, const char *str,
776: int direct, int style)
777: {
778: struct community_entry *entry = NULL;
779: struct community_list *list;
780: struct ecommunity *ecom = NULL;
781: regex_t *regex = NULL;
782:
783: /* Lookup extcommunity list. */
784: list = community_list_lookup (ch, name, EXTCOMMUNITY_LIST_MASTER);
785: if (list == NULL)
786: return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
787:
788: /* Delete all of entry belongs to this extcommunity-list. */
789: if (!str)
790: {
791: community_list_delete (list);
792: return 0;
793: }
794:
795: if (style == EXTCOMMUNITY_LIST_STANDARD)
796: ecom = ecommunity_str2com (str, 0, 1);
797: else
798: regex = bgp_regcomp (str);
799:
800: if (! ecom && ! regex)
801: return COMMUNITY_LIST_ERR_MALFORMED_VAL;
802:
803: if (ecom)
804: entry = community_list_entry_lookup (list, ecom, direct);
805: else
806: entry = community_list_entry_lookup (list, str, direct);
807:
808: if (ecom)
809: ecommunity_free (&ecom);
810: if (regex)
811: bgp_regex_free (regex);
812:
813: if (!entry)
814: return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
815:
816: community_list_entry_delete (list, entry, style);
817:
818: return 0;
819: }
820:
821: /* Initializa community-list. Return community-list handler. */
822: struct community_list_handler *
823: community_list_init (void)
824: {
825: struct community_list_handler *ch;
826: ch = XCALLOC (MTYPE_COMMUNITY_LIST_HANDLER,
827: sizeof (struct community_list_handler));
828: return ch;
829: }
830:
831: /* Terminate community-list. */
832: void
833: community_list_terminate (struct community_list_handler *ch)
834: {
835: struct community_list_master *cm;
836: struct community_list *list;
837:
838: cm = &ch->community_list;
839: while ((list = cm->num.head) != NULL)
840: community_list_delete (list);
841: while ((list = cm->str.head) != NULL)
842: community_list_delete (list);
843:
844: cm = &ch->extcommunity_list;
845: while ((list = cm->num.head) != NULL)
846: community_list_delete (list);
847: while ((list = cm->str.head) != NULL)
848: community_list_delete (list);
849:
850: XFREE (MTYPE_COMMUNITY_LIST_HANDLER, ch);
851: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_clist.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / bgpd