1: /* BGP Extended Communities Attribute
2: Copyright (C) 2000 Kunihiro Ishiguro <kunihiro@zebra.org>
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 "hash.h"
24: #include "memory.h"
25: #include "prefix.h"
26: #include "command.h"
27: #include "filter.h"
28:
29: #include "bgpd/bgpd.h"
30: #include "bgpd/bgp_ecommunity.h"
31: #include "bgpd/bgp_aspath.h"
32:
33: /* Hash of community attribute. */
34: static struct hash *ecomhash;
35:
36: /* Allocate a new ecommunities. */
37: static struct ecommunity *
38: ecommunity_new (void)
39: {
40: return (struct ecommunity *) XCALLOC (MTYPE_ECOMMUNITY,
41: sizeof (struct ecommunity));
42: }
43:
44: /* Allocate ecommunities. */
45: void
46: ecommunity_free (struct ecommunity **ecom)
47: {
48: if ((*ecom)->val)
49: XFREE (MTYPE_ECOMMUNITY_VAL, (*ecom)->val);
50: if ((*ecom)->str)
51: XFREE (MTYPE_ECOMMUNITY_STR, (*ecom)->str);
52: XFREE (MTYPE_ECOMMUNITY, *ecom);
53: ecom = NULL;
54: }
55:
56: /* Add a new Extended Communities value to Extended Communities
57: Attribute structure. When the value is already exists in the
58: structure, we don't add the value. Newly added value is sorted by
59: numerical order. When the value is added to the structure return 1
60: else return 0. */
61: static int
62: ecommunity_add_val (struct ecommunity *ecom, struct ecommunity_val *eval)
63: {
64: u_int8_t *p;
65: int ret;
66: int c;
67:
68: /* When this is fist value, just add it. */
69: if (ecom->val == NULL)
70: {
71: ecom->size++;
72: ecom->val = XMALLOC (MTYPE_ECOMMUNITY_VAL, ecom_length (ecom));
73: memcpy (ecom->val, eval->val, ECOMMUNITY_SIZE);
74: return 1;
75: }
76:
77: /* If the value already exists in the structure return 0. */
78: c = 0;
79: for (p = ecom->val; c < ecom->size; p += ECOMMUNITY_SIZE, c++)
80: {
81: ret = memcmp (p, eval->val, ECOMMUNITY_SIZE);
82: if (ret == 0)
83: return 0;
84: if (ret > 0)
85: break;
86: }
87:
88: /* Add the value to the structure with numerical sorting. */
89: ecom->size++;
90: ecom->val = XREALLOC (MTYPE_ECOMMUNITY_VAL, ecom->val, ecom_length (ecom));
91:
92: memmove (ecom->val + (c + 1) * ECOMMUNITY_SIZE,
93: ecom->val + c * ECOMMUNITY_SIZE,
94: (ecom->size - 1 - c) * ECOMMUNITY_SIZE);
95: memcpy (ecom->val + c * ECOMMUNITY_SIZE, eval->val, ECOMMUNITY_SIZE);
96:
97: return 1;
98: }
99:
100: /* This function takes pointer to Extended Communites strucutre then
101: create a new Extended Communities structure by uniq and sort each
102: Extended Communities value. */
103: struct ecommunity *
104: ecommunity_uniq_sort (struct ecommunity *ecom)
105: {
106: int i;
107: struct ecommunity *new;
108: struct ecommunity_val *eval;
109:
110: if (! ecom)
111: return NULL;
112:
113: new = ecommunity_new ();
114:
115: for (i = 0; i < ecom->size; i++)
116: {
117: eval = (struct ecommunity_val *) (ecom->val + (i * ECOMMUNITY_SIZE));
118: ecommunity_add_val (new, eval);
119: }
120: return new;
121: }
122:
123: /* Parse Extended Communites Attribute in BGP packet. */
124: struct ecommunity *
125: ecommunity_parse (u_int8_t *pnt, u_short length)
126: {
127: struct ecommunity tmp;
128: struct ecommunity *new;
129:
130: /* Length check. */
131: if (length % ECOMMUNITY_SIZE)
132: return NULL;
133:
134: /* Prepare tmporary structure for making a new Extended Communities
135: Attribute. */
136: tmp.size = length / ECOMMUNITY_SIZE;
137: tmp.val = pnt;
138:
139: /* Create a new Extended Communities Attribute by uniq and sort each
140: Extended Communities value */
141: new = ecommunity_uniq_sort (&tmp);
142:
143: return ecommunity_intern (new);
144: }
145:
146: /* Duplicate the Extended Communities Attribute structure. */
147: struct ecommunity *
148: ecommunity_dup (struct ecommunity *ecom)
149: {
150: struct ecommunity *new;
151:
152: new = XCALLOC (MTYPE_ECOMMUNITY, sizeof (struct ecommunity));
153: new->size = ecom->size;
154: if (new->size)
155: {
156: new->val = XMALLOC (MTYPE_ECOMMUNITY_VAL, ecom->size * ECOMMUNITY_SIZE);
157: memcpy (new->val, ecom->val, ecom->size * ECOMMUNITY_SIZE);
158: }
159: else
160: new->val = NULL;
161: return new;
162: }
163:
164: /* Retrun string representation of communities attribute. */
165: char *
166: ecommunity_str (struct ecommunity *ecom)
167: {
168: if (! ecom->str)
169: ecom->str = ecommunity_ecom2str (ecom, ECOMMUNITY_FORMAT_DISPLAY);
170: return ecom->str;
171: }
172:
173: /* Merge two Extended Communities Attribute structure. */
174: struct ecommunity *
175: ecommunity_merge (struct ecommunity *ecom1, struct ecommunity *ecom2)
176: {
177: if (ecom1->val)
178: ecom1->val = XREALLOC (MTYPE_ECOMMUNITY_VAL, ecom1->val,
179: (ecom1->size + ecom2->size) * ECOMMUNITY_SIZE);
180: else
181: ecom1->val = XMALLOC (MTYPE_ECOMMUNITY_VAL,
182: (ecom1->size + ecom2->size) * ECOMMUNITY_SIZE);
183:
184: memcpy (ecom1->val + (ecom1->size * ECOMMUNITY_SIZE),
185: ecom2->val, ecom2->size * ECOMMUNITY_SIZE);
186: ecom1->size += ecom2->size;
187:
188: return ecom1;
189: }
190:
191: /* Intern Extended Communities Attribute. */
192: struct ecommunity *
193: ecommunity_intern (struct ecommunity *ecom)
194: {
195: struct ecommunity *find;
196:
197: assert (ecom->refcnt == 0);
198:
199: find = (struct ecommunity *) hash_get (ecomhash, ecom, hash_alloc_intern);
200:
201: if (find != ecom)
202: ecommunity_free (&ecom);
203:
204: find->refcnt++;
205:
206: if (! find->str)
207: find->str = ecommunity_ecom2str (find, ECOMMUNITY_FORMAT_DISPLAY);
208:
209: return find;
210: }
211:
212: /* Unintern Extended Communities Attribute. */
213: void
214: ecommunity_unintern (struct ecommunity **ecom)
215: {
216: struct ecommunity *ret;
217:
218: if ((*ecom)->refcnt)
219: (*ecom)->refcnt--;
220:
221: /* Pull off from hash. */
222: if ((*ecom)->refcnt == 0)
223: {
224: /* Extended community must be in the hash. */
225: ret = (struct ecommunity *) hash_release (ecomhash, *ecom);
226: assert (ret != NULL);
227:
228: ecommunity_free (ecom);
229: }
230: }
231:
232: /* Utinity function to make hash key. */
233: unsigned int
234: ecommunity_hash_make (void *arg)
235: {
236: const struct ecommunity *ecom = arg;
237: int size = ecom->size * ECOMMUNITY_SIZE;
238: u_int8_t *pnt = ecom->val;
239: unsigned int key = 0;
240: int c;
241:
242: for (c = 0; c < size; c += ECOMMUNITY_SIZE)
243: {
244: key += pnt[c];
245: key += pnt[c + 1];
246: key += pnt[c + 2];
247: key += pnt[c + 3];
248: key += pnt[c + 4];
249: key += pnt[c + 5];
250: key += pnt[c + 6];
251: key += pnt[c + 7];
252: }
253:
254: return key;
255: }
256:
257: /* Compare two Extended Communities Attribute structure. */
258: int
259: ecommunity_cmp (const void *arg1, const void *arg2)
260: {
261: const struct ecommunity *ecom1 = arg1;
262: const struct ecommunity *ecom2 = arg2;
263:
264: return (ecom1->size == ecom2->size
265: && memcmp (ecom1->val, ecom2->val, ecom1->size * ECOMMUNITY_SIZE) == 0);
266: }
267:
268: /* Initialize Extended Comminities related hash. */
269: void
270: ecommunity_init (void)
271: {
272: ecomhash = hash_create (ecommunity_hash_make, ecommunity_cmp);
273: }
274:
275: void
276: ecommunity_finish (void)
277: {
278: hash_free (ecomhash);
279: ecomhash = NULL;
280: }
281:
282: /* Extended Communities token enum. */
283: enum ecommunity_token
284: {
285: ecommunity_token_unknown = 0,
286: ecommunity_token_rt,
287: ecommunity_token_soo,
288: ecommunity_token_val,
289: };
290:
291: /* Get next Extended Communities token from the string. */
292: static const char *
293: ecommunity_gettoken (const char *str, struct ecommunity_val *eval,
294: enum ecommunity_token *token)
295: {
296: int ret;
297: int dot = 0;
298: int digit = 0;
299: int separator = 0;
300: const char *p = str;
301: char *endptr;
302: struct in_addr ip;
303: as_t as = 0;
304: u_int32_t val = 0;
305: char buf[INET_ADDRSTRLEN + 1];
306:
307: /* Skip white space. */
308: while (isspace ((int) *p))
309: {
310: p++;
311: str++;
312: }
313:
314: /* Check the end of the line. */
315: if (*p == '\0')
316: return NULL;
317:
318: /* "rt" and "soo" keyword parse. */
319: if (! isdigit ((int) *p))
320: {
321: /* "rt" match check. */
322: if (tolower ((int) *p) == 'r')
323: {
324: p++;
325: if (tolower ((int) *p) == 't')
326: {
327: p++;
328: *token = ecommunity_token_rt;
329: return p;
330: }
331: if (isspace ((int) *p) || *p == '\0')
332: {
333: *token = ecommunity_token_rt;
334: return p;
335: }
336: goto error;
337: }
338: /* "soo" match check. */
339: else if (tolower ((int) *p) == 's')
340: {
341: p++;
342: if (tolower ((int) *p) == 'o')
343: {
344: p++;
345: if (tolower ((int) *p) == 'o')
346: {
347: p++;
348: *token = ecommunity_token_soo;
349: return p;
350: }
351: if (isspace ((int) *p) || *p == '\0')
352: {
353: *token = ecommunity_token_soo;
354: return p;
355: }
356: goto error;
357: }
358: if (isspace ((int) *p) || *p == '\0')
359: {
360: *token = ecommunity_token_soo;
361: return p;
362: }
363: goto error;
364: }
365: goto error;
366: }
367:
368: /* What a mess, there are several possibilities:
369: *
370: * a) A.B.C.D:MN
371: * b) EF:OPQR
372: * c) GHJK:MN
373: *
374: * A.B.C.D: Four Byte IP
375: * EF: Two byte ASN
376: * GHJK: Four-byte ASN
377: * MN: Two byte value
378: * OPQR: Four byte value
379: *
380: */
381: while (isdigit ((int) *p) || *p == ':' || *p == '.')
382: {
383: if (*p == ':')
384: {
385: if (separator)
386: goto error;
387:
388: separator = 1;
389: digit = 0;
390:
391: if ((p - str) > INET_ADDRSTRLEN)
392: goto error;
393: memset (buf, 0, INET_ADDRSTRLEN + 1);
394: memcpy (buf, str, p - str);
395:
396: if (dot)
397: {
398: /* Parsing A.B.C.D in:
399: * A.B.C.D:MN
400: */
401: ret = inet_aton (buf, &ip);
402: if (ret == 0)
403: goto error;
404: }
405: else
406: {
407: /* ASN */
408: as = strtoul (buf, &endptr, 10);
409: if (*endptr != '\0' || as == BGP_AS4_MAX)
410: goto error;
411: }
412: }
413: else if (*p == '.')
414: {
415: if (separator)
416: goto error;
417: dot++;
418: if (dot > 4)
419: goto error;
420: }
421: else
422: {
423: digit = 1;
424:
425: /* We're past the IP/ASN part */
426: if (separator)
427: {
428: val *= 10;
429: val += (*p - '0');
430: }
431: }
432: p++;
433: }
434:
435: /* Low digit part must be there. */
436: if (!digit || !separator)
437: goto error;
438:
439: /* Encode result into routing distinguisher. */
440: if (dot)
441: {
442: if (val > UINT16_MAX)
443: goto error;
444:
445: eval->val[0] = ECOMMUNITY_ENCODE_IP;
446: eval->val[1] = 0;
447: memcpy (&eval->val[2], &ip, sizeof (struct in_addr));
448: eval->val[6] = (val >> 8) & 0xff;
449: eval->val[7] = val & 0xff;
450: }
451: else if (as > BGP_AS_MAX)
452: {
453: if (val > UINT16_MAX)
454: goto error;
455:
456: eval->val[0] = ECOMMUNITY_ENCODE_AS4;
457: eval->val[1] = 0;
458: eval->val[2] = (as >>24) & 0xff;
459: eval->val[3] = (as >>16) & 0xff;
460: eval->val[4] = (as >>8) & 0xff;
461: eval->val[5] = as & 0xff;
462: eval->val[6] = (val >> 8) & 0xff;
463: eval->val[7] = val & 0xff;
464: }
465: else
466: {
467: eval->val[0] = ECOMMUNITY_ENCODE_AS;
468: eval->val[1] = 0;
469:
470: eval->val[2] = (as >>8) & 0xff;
471: eval->val[3] = as & 0xff;
472: eval->val[4] = (val >>24) & 0xff;
473: eval->val[5] = (val >>16) & 0xff;
474: eval->val[6] = (val >>8) & 0xff;
475: eval->val[7] = val & 0xff;
476: }
477: *token = ecommunity_token_val;
478: return p;
479:
480: error:
481: *token = ecommunity_token_unknown;
482: return p;
483: }
484:
485: /* Convert string to extended community attribute.
486:
487: When type is already known, please specify both str and type. str
488: should not include keyword such as "rt" and "soo". Type is
489: ECOMMUNITY_ROUTE_TARGET or ECOMMUNITY_SITE_ORIGIN.
490: keyword_included should be zero.
491:
492: For example route-map's "set extcommunity" command case:
493:
494: "rt 100:1 100:2 100:3" -> str = "100:1 100:2 100:3"
495: type = ECOMMUNITY_ROUTE_TARGET
496: keyword_included = 0
497:
498: "soo 100:1" -> str = "100:1"
499: type = ECOMMUNITY_SITE_ORIGIN
500: keyword_included = 0
501:
502: When string includes keyword for each extended community value.
503: Please specify keyword_included as non-zero value.
504:
505: For example standard extcommunity-list case:
506:
507: "rt 100:1 rt 100:2 soo 100:1" -> str = "rt 100:1 rt 100:2 soo 100:1"
508: type = 0
509: keyword_include = 1
510: */
511: struct ecommunity *
512: ecommunity_str2com (const char *str, int type, int keyword_included)
513: {
514: struct ecommunity *ecom = NULL;
515: enum ecommunity_token token = ecommunity_token_unknown;
516: struct ecommunity_val eval;
517: int keyword = 0;
518:
519: while ((str = ecommunity_gettoken (str, &eval, &token)))
520: {
521: switch (token)
522: {
523: case ecommunity_token_rt:
524: case ecommunity_token_soo:
525: if (! keyword_included || keyword)
526: {
527: if (ecom)
528: ecommunity_free (&ecom);
529: return NULL;
530: }
531: keyword = 1;
532:
533: if (token == ecommunity_token_rt)
534: {
535: type = ECOMMUNITY_ROUTE_TARGET;
536: }
537: if (token == ecommunity_token_soo)
538: {
539: type = ECOMMUNITY_SITE_ORIGIN;
540: }
541: break;
542: case ecommunity_token_val:
543: if (keyword_included)
544: {
545: if (! keyword)
546: {
547: if (ecom)
548: ecommunity_free (&ecom);
549: return NULL;
550: }
551: keyword = 0;
552: }
553: if (ecom == NULL)
554: ecom = ecommunity_new ();
555: eval.val[1] = type;
556: ecommunity_add_val (ecom, &eval);
557: break;
558: case ecommunity_token_unknown:
559: default:
560: if (ecom)
561: ecommunity_free (&ecom);
562: return NULL;
563: }
564: }
565: return ecom;
566: }
567:
568: /* Convert extended community attribute to string.
569:
570: Due to historical reason of industry standard implementation, there
571: are three types of format.
572:
573: route-map set extcommunity format
574: "rt 100:1 100:2"
575: "soo 100:3"
576:
577: extcommunity-list
578: "rt 100:1 rt 100:2 soo 100:3"
579:
580: "show ip bgp" and extcommunity-list regular expression matching
581: "RT:100:1 RT:100:2 SoO:100:3"
582:
583: For each formath please use below definition for format:
584:
585: ECOMMUNITY_FORMAT_ROUTE_MAP
586: ECOMMUNITY_FORMAT_COMMUNITY_LIST
587: ECOMMUNITY_FORMAT_DISPLAY
588: */
589: char *
590: ecommunity_ecom2str (struct ecommunity *ecom, int format)
591: {
592: int i;
593: u_int8_t *pnt;
594: int encode = 0;
595: int type = 0;
596: #define ECOMMUNITY_STR_DEFAULT_LEN 27
597: int str_size;
598: int str_pnt;
599: char *str_buf;
600: const char *prefix;
601: int len = 0;
602: int first = 1;
603:
604: /* For parse Extended Community attribute tupple. */
605: struct ecommunity_as
606: {
607: as_t as;
608: u_int32_t val;
609: } eas;
610:
611: struct ecommunity_ip
612: {
613: struct in_addr ip;
614: u_int16_t val;
615: } eip;
616:
617: if (ecom->size == 0)
618: {
619: str_buf = XMALLOC (MTYPE_ECOMMUNITY_STR, 1);
620: str_buf[0] = '\0';
621: return str_buf;
622: }
623:
624: /* Prepare buffer. */
625: str_buf = XMALLOC (MTYPE_ECOMMUNITY_STR, ECOMMUNITY_STR_DEFAULT_LEN + 1);
626: str_size = ECOMMUNITY_STR_DEFAULT_LEN + 1;
627: str_pnt = 0;
628:
629: for (i = 0; i < ecom->size; i++)
630: {
631: /* Make it sure size is enough. */
632: while (str_pnt + ECOMMUNITY_STR_DEFAULT_LEN >= str_size)
633: {
634: str_size *= 2;
635: str_buf = XREALLOC (MTYPE_ECOMMUNITY_STR, str_buf, str_size);
636: }
637:
638: /* Space between each value. */
639: if (! first)
640: str_buf[str_pnt++] = ' ';
641:
642: pnt = ecom->val + (i * 8);
643:
644: /* High-order octet of type. */
645: encode = *pnt++;
646:
647: switch (encode)
648: {
649: case ECOMMUNITY_ENCODE_AS:
650: case ECOMMUNITY_ENCODE_IP:
651: case ECOMMUNITY_ENCODE_AS4:
652: break;
653:
654: case ECOMMUNITY_ENCODE_OPAQUE:
655: if (*pnt == ECOMMUNITY_OPAQUE_SUBTYPE_ENCAP)
656: {
657: uint16_t tunneltype;
658: memcpy (&tunneltype, pnt + 5, 2);
659: tunneltype = ntohs(tunneltype);
660: len = sprintf (str_buf + str_pnt, "ET:%d", tunneltype);
661: str_pnt += len;
662: first = 0;
663: continue;
664: }
665: /* fall through */
666:
667: default:
668: len = sprintf (str_buf + str_pnt, "?");
669: str_pnt += len;
670: first = 0;
671: continue;
672: }
673:
674: /* Low-order octet of type. */
675: type = *pnt++;
676: if (type != ECOMMUNITY_ROUTE_TARGET && type != ECOMMUNITY_SITE_ORIGIN)
677: {
678: len = sprintf (str_buf + str_pnt, "?");
679: str_pnt += len;
680: first = 0;
681: continue;
682: }
683:
684: switch (format)
685: {
686: case ECOMMUNITY_FORMAT_COMMUNITY_LIST:
687: prefix = (type == ECOMMUNITY_ROUTE_TARGET ? "rt " : "soo ");
688: break;
689: case ECOMMUNITY_FORMAT_DISPLAY:
690: prefix = (type == ECOMMUNITY_ROUTE_TARGET ? "RT:" : "SoO:");
691: break;
692: case ECOMMUNITY_FORMAT_ROUTE_MAP:
693: prefix = "";
694: break;
695: default:
696: prefix = "";
697: break;
698: }
699:
700: /* Put string into buffer. */
701: if (encode == ECOMMUNITY_ENCODE_AS4)
702: {
703: eas.as = (*pnt++ << 24);
704: eas.as |= (*pnt++ << 16);
705: eas.as |= (*pnt++ << 8);
706: eas.as |= (*pnt++);
707:
708: eas.val = (*pnt++ << 8);
709: eas.val |= (*pnt++);
710:
711: len = sprintf( str_buf + str_pnt, "%s%u:%u", prefix,
712: eas.as, eas.val );
713: str_pnt += len;
714: first = 0;
715: }
716: if (encode == ECOMMUNITY_ENCODE_AS)
717: {
718: eas.as = (*pnt++ << 8);
719: eas.as |= (*pnt++);
720:
721: eas.val = (*pnt++ << 24);
722: eas.val |= (*pnt++ << 16);
723: eas.val |= (*pnt++ << 8);
724: eas.val |= (*pnt++);
725:
726: len = sprintf (str_buf + str_pnt, "%s%u:%u", prefix,
727: eas.as, eas.val);
728: str_pnt += len;
729: first = 0;
730: }
731: else if (encode == ECOMMUNITY_ENCODE_IP)
732: {
733: memcpy (&eip.ip, pnt, 4);
734: pnt += 4;
735: eip.val = (*pnt++ << 8);
736: eip.val |= (*pnt++);
737:
738: len = sprintf (str_buf + str_pnt, "%s%s:%u", prefix,
739: inet_ntoa (eip.ip), eip.val);
740: str_pnt += len;
741: first = 0;
742: }
743: }
744: return str_buf;
745: }
746:
747: int
748: ecommunity_match (const struct ecommunity *ecom1,
749: const struct ecommunity *ecom2)
750: {
751: int i = 0;
752: int j = 0;
753:
754: if (ecom1 == NULL && ecom2 == NULL)
755: return 1;
756:
757: if (ecom1 == NULL || ecom2 == NULL)
758: return 0;
759:
760: if (ecom1->size < ecom2->size)
761: return 0;
762:
763: /* Every community on com2 needs to be on com1 for this to match */
764: while (i < ecom1->size && j < ecom2->size)
765: {
766: if (memcmp (ecom1->val + i, ecom2->val + j, ECOMMUNITY_SIZE) == 0)
767: j++;
768: i++;
769: }
770:
771: if (j == ecom2->size)
772: return 1;
773: else
774: return 0;
775: }
776:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_ecommunity.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