开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
bgp_ecommunity.c
资源名称：zebra-0.95a.tar.gz　[点击查看]
上传用户：xiaozhuqw
上传日期：2009-11-15
资源大小：1338k
文件大小：18k
源码类别：

网络

开发平台：

Unix_Linux

bgp_ecommunity.c：源码内容
  1. /* BGP Extended Communities Attribute
  2.    Copyright (C) 2000 Kunihiro Ishiguro <kunihiro@zebra.org>
  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
  9. later version.
  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
  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.  */
  21. #include <zebra.h>
  23. #include "hash.h"
  24. #include "memory.h"
  25. #include "prefix.h"
  26. #include "command.h"
  28. #include "bgpd/bgpd.h"
  29. #include "bgpd/bgp_ecommunity.h"
  31. /* Hash of community attribute. */
  32. struct hash *ecomhash;
  34. /* Allocate a new ecommunities.  */
  35. struct ecommunity *
  36. ecommunity_new ()
  37. {
  38.   return (struct ecommunity *) XCALLOC (MTYPE_ECOMMUNITY,
  39. sizeof (struct ecommunity));
  40. }
  42. /* Allocate ecommunities.  */
  43. void
  44. ecommunity_free (struct ecommunity *ecom)
  45. {
  46.   if (ecom->val)
  47.     XFREE (MTYPE_ECOMMUNITY_VAL, ecom->val);
  48.   if (ecom->str)
  49.     XFREE (MTYPE_ECOMMUNITY_STR, ecom->str);
  50.   XFREE (MTYPE_ECOMMUNITY, ecom);
  51. }
  53. /* Add a new Extended Communities value to Extended Communities
  54.    Attribute structure.  When the value is already exists in the
  55.    structure, we don't add the value.  Newly added value is sorted by
  56.    numerical order.  When the value is added to the structure return 1
  57.    else return 0.  */
  58. static int
  59. ecommunity_add_val (struct ecommunity *ecom, struct ecommunity_val *eval)
  60. {
  61.   u_char *p;
  62.   int ret;
  63.   int c;
  65.   /* When this is fist value, just add it.  */
  66.   if (ecom->val == NULL)
  67.     {
  68.       ecom->size++;
  69.       ecom->val = XMALLOC (MTYPE_ECOMMUNITY_VAL, ecom_length (ecom));
  70.       memcpy (ecom->val, eval->val, ECOMMUNITY_SIZE);
  71.       return 1;
  72.     }
  74.   /* If the value already exists in the structure return 0.  */
  75.   c = 0;
  76.   for (p = ecom->val; c < ecom->size; p += ECOMMUNITY_SIZE, c++)
  77.     {
  78.       ret = memcmp (p, eval->val, ECOMMUNITY_SIZE);
  79.       if (ret == 0)
  80.         return 0;
  81.       if (ret > 0)
  82.         break;
  83.     }
  85.   /* Add the value to the structure with numerical sorting.  */
  86.   ecom->size++;
  87.   ecom->val = XREALLOC (MTYPE_ECOMMUNITY_VAL, ecom->val, ecom_length (ecom));
  89.   memmove (ecom->val + (c + 1) * ECOMMUNITY_SIZE,
  90.    ecom->val + c * ECOMMUNITY_SIZE,
  91.    (ecom->size - 1 - c) * ECOMMUNITY_SIZE);
  92.   memcpy (ecom->val + c * ECOMMUNITY_SIZE, eval->val, ECOMMUNITY_SIZE);
  94.   return 1;
  95. }
  97. /* This function takes pointer to Extended Communites strucutre then
  98.    create a new Extended Communities structure by uniq and sort each
  99.    Exteneded Communities value.  */
  100. struct ecommunity *
  101. ecommunity_uniq_sort (struct ecommunity *ecom)
  102. {
  103.   int i;
  104.   struct ecommunity *new;
  105.   struct ecommunity_val *eval;
  106.   
  107.   if (! ecom)
  108.     return NULL;
  109.   
  110.   new = ecommunity_new ();;
  111.   
  112.   for (i = 0; i < ecom->size; i++)
  113.     {
  114.       eval = (struct ecommunity_val *) (ecom->val + (i * ECOMMUNITY_SIZE));
  115.       ecommunity_add_val (new, eval);
  116.     }
  117.   return new;
  118. }
  120. /* Parse Extended Communites Attribute in BGP packet.  */
  121. struct ecommunity *
  122. ecommunity_parse (char *pnt, u_short length)
  123. {
  124.   struct ecommunity tmp;
  125.   struct ecommunity *new;
  127.   /* Length check.  */
  128.   if (length % ECOMMUNITY_SIZE)
  129.     return NULL;
  131.   /* Prepare tmporary structure for making a new Extended Communities
  132.      Attribute.  */
  133.   tmp.size = length / ECOMMUNITY_SIZE;
  134.   tmp.val = pnt;
  136.   /* Create a new Extended Communities Attribute by uniq and sort each
  137.      Extended Communities value  */
  138.   new = ecommunity_uniq_sort (&tmp);
  140.   return ecommunity_intern (new);
  141. }
  143. /* Duplicate the Extended Communities Attribute structure.  */
  144. struct ecommunity *
  145. ecommunity_dup (struct ecommunity *ecom)
  146. {
  147.   struct ecommunity *new;
  149.   new = XCALLOC (MTYPE_ECOMMUNITY, sizeof (struct ecommunity));
  150.   new->size = ecom->size;
  151.   if (new->size)
  152.     {
  153.       new->val = XMALLOC (MTYPE_ECOMMUNITY_VAL, ecom->size * ECOMMUNITY_SIZE);
  154.       memcpy (new->val, ecom->val, ecom->size * ECOMMUNITY_SIZE);
  155.     }
  156.   else
  157.     new->val = NULL;
  158.   return new;
  159. }
  161. /* Retrun string representation of communities attribute. */
  162. char *
  163. ecommunity_str (struct ecommunity *ecom)
  164. {
  165.   if (! ecom->str)
  166.     ecom->str = ecommunity_ecom2str (ecom, ECOMMUNITY_FORMAT_DISPLAY);
  167.   return ecom->str;
  168. }
  170. /* Merge two Extended Communities Attribute structure.  */
  171. struct ecommunity *
  172. ecommunity_merge (struct ecommunity *ecom1, struct ecommunity *ecom2)
  173. {
  174.   if (ecom1->val)
  175.     ecom1->val = XREALLOC (MTYPE_ECOMMUNITY_VAL, ecom1->val, 
  176.    (ecom1->size + ecom2->size) * ECOMMUNITY_SIZE);
  177.   else
  178.     ecom1->val = XMALLOC (MTYPE_ECOMMUNITY_VAL,
  179.   (ecom1->size + ecom2->size) * ECOMMUNITY_SIZE);
  181.   memcpy (ecom1->val + (ecom1->size * ECOMMUNITY_SIZE),
  182.   ecom2->val, ecom2->size * ECOMMUNITY_SIZE);
  183.   ecom1->size += ecom2->size;
  185.   return ecom1;
  186. }
  188. /* Intern Extended Communities Attribute.  */
  189. struct ecommunity *
  190. ecommunity_intern (struct ecommunity *ecom)
  191. {
  192.   struct ecommunity *find;
  194.   assert (ecom->refcnt == 0);
  196.   find = (struct ecommunity *) hash_get (ecomhash, ecom, hash_alloc_intern);
  198.   if (find != ecom)
  199.     ecommunity_free (ecom);
  201.   find->refcnt++;
  203.   if (! find->str)
  204.     find->str = ecommunity_ecom2str (find, ECOMMUNITY_FORMAT_DISPLAY);
  206.   return find;
  207. }
  209. /* Unintern Extended Communities Attribute.  */
  210. void
  211. ecommunity_unintern (struct ecommunity *ecom)
  212. {
  213.   struct ecommunity *ret;
  215.   if (ecom->refcnt)
  216.     ecom->refcnt--;
  218.   /* Pull off from hash.  */
  219.   if (ecom->refcnt == 0)
  220.     {
  221.       /* Extended community must be in the hash.  */
  222.       ret = (struct ecommunity *) hash_release (ecomhash, ecom);
  223.       assert (ret != NULL);
  225.       ecommunity_free (ecom);
  226.     }
  227. }
  229. /* Utinity function to make hash key.  */
  230. unsigned int
  231. ecommunity_hash_make (struct ecommunity *ecom)
  232. {
  233.   int c;
  234.   unsigned int key;
  235.   unsigned char *pnt;
  237.   key = 0;
  238.   pnt = ecom->val;
  239.   
  240.   for (c = 0; c < ecom->size * ECOMMUNITY_SIZE; c++)
  241.     key += pnt[c];
  243.   return key;
  244. }
  246. /* Compare two Extended Communities Attribute structure.  */
  247. int
  248. ecommunity_cmp (struct ecommunity *ecom1, struct ecommunity *ecom2)
  249. {
  250.   if (ecom1->size == ecom2->size
  251.       && memcmp (ecom1->val, ecom2->val, ecom1->size * ECOMMUNITY_SIZE) == 0)
  252.     return 1;
  253.   return 0;
  254. }
  256. /* Initialize Extended Comminities related hash. */
  257. void
  258. ecommunity_init ()
  259. {
  260.   ecomhash = hash_create (ecommunity_hash_make, ecommunity_cmp);
  261. }
  263. /* Extended Communities token enum. */
  264. enum ecommunity_token
  265. {
  266.   ecommunity_token_rt,
  267.   ecommunity_token_soo,
  268.   ecommunity_token_val,
  269.   ecommunity_token_unknown
  270. };
  272. /* Get next Extended Communities token from the string. */
  273. char *
  274. ecommunity_gettoken (char *str, struct ecommunity_val *eval,
  275.      enum ecommunity_token *token)
  276. {
  277.   int ret;
  278.   int dot = 0;
  279.   int digit = 0;
  280.   int separator = 0;
  281.   u_int32_t val_low = 0;
  282.   u_int32_t val_high = 0;
  283.   char *p = str;
  284.   struct in_addr ip;
  285.   char ipstr[INET_ADDRSTRLEN + 1];
  287.   /* Skip white space. */
  288.   while (isspace ((int) *p))
  289.     {
  290.       p++;
  291.       str++;
  292.     }
  294.   /* Check the end of the line. */
  295.   if (*p == '')
  296.     return NULL;
  298.   /* "rt" and "soo" keyword parse. */
  299.   if (! isdigit ((int) *p)) 
  300.     {
  301.       /* "rt" match check.  */
  302.       if (tolower ((int) *p) == 'r')
  303. {
  304.   p++;
  305.     if (tolower ((int) *p) == 't')
  306.     {
  307.       p++;
  308.       *token = ecommunity_token_rt;
  309.       return p;
  310.     }
  311.   if (isspace ((int) *p) || *p == '')
  312.     {
  313.       *token = ecommunity_token_rt;
  314.       return p;
  315.     }
  316.   goto error;
  317. }
  318.       /* "soo" match check.  */
  319.       else if (tolower ((int) *p) == 's')
  320. {
  321.   p++;
  322.     if (tolower ((int) *p) == 'o')
  323.     {
  324.       p++;
  325.       if (tolower ((int) *p) == 'o')
  326. {
  327.   p++;
  328.   *token = ecommunity_token_soo;
  329.   return p;
  330. }
  331.       if (isspace ((int) *p) || *p == '')
  332. {
  333.   *token = ecommunity_token_soo;
  334.   return p;
  335. }
  336.       goto error;
  337.     }
  338.   if (isspace ((int) *p) || *p == '')
  339.     {
  340.       *token = ecommunity_token_soo;
  341.       return p;
  342.     }
  343.   goto error;
  344. }
  345.       goto error;
  346.     }
  347.   
  348.   while (isdigit ((int) *p) || *p == ':' || *p == '.') 
  349.     {
  350.       if (*p == ':') 
  351. {
  352.   if (separator)
  353.     goto error;
  355.   separator = 1;
  356.   digit = 0;
  358.   if (dot)
  359.     {
  360.       if ((p - str) > INET_ADDRSTRLEN)
  361. goto error;
  363.       memset (ipstr, 0, INET_ADDRSTRLEN + 1);
  364.       memcpy (ipstr, str, p - str);
  366.       ret = inet_aton (ipstr, &ip);
  367.       if (ret == 0)
  368. goto error;
  369.     }
  370.   else
  371.     val_high = val_low;
  373.   val_low = 0;
  374. }
  375.       else if (*p == '.')
  376. {
  377.   if (separator)
  378.     goto error;
  379.   dot++;
  380.   if (dot > 4)
  381.     goto error;
  382. }
  383.       else
  384. {
  385.   digit = 1;
  386.   val_low *= 10;
  387.   val_low += (*p - '0');
  388. }
  389.       p++;
  390.     }
  392.   /* Low digit part must be there. */
  393.   if (! digit || ! separator)
  394.     goto error;
  396.   /* Encode result into routing distinguisher.  */
  397.   if (dot)
  398.     {
  399.       eval->val[0] = ECOMMUNITY_ENCODE_IP;
  400.       eval->val[1] = 0;
  401.       memcpy (&eval->val[2], &ip, sizeof (struct in_addr));
  402.       eval->val[6] = (val_low >> 8) & 0xff;
  403.       eval->val[7] = val_low & 0xff;
  404.     }
  405.   else
  406.     {
  407.       eval->val[0] = ECOMMUNITY_ENCODE_AS;
  408.       eval->val[1] = 0;
  409.       eval->val[2] = (val_high >>8) & 0xff;
  410.       eval->val[3] = val_high & 0xff;
  411.       eval->val[4] = (val_low >>24) & 0xff;
  412.       eval->val[5] = (val_low >>16) & 0xff;
  413.       eval->val[6] = (val_low >>8) & 0xff;
  414.       eval->val[7] = val_low & 0xff;
  415.     }
  416.   *token = ecommunity_token_val;
  417.   return p;
  419.  error:
  420.   *token = ecommunity_token_unknown;
  421.   return p;
  422. }
  424. /* Convert string to extended community attribute. 
  426.    When type is already known, please specify both str and type.  str
  427.    should not include keyword such as "rt" and "soo".  Type is
  428.    ECOMMUNITY_TYPE_ROUTE_TARGET or ECOMMUNITY_TYPE_SITE_ORIGIN.
  429.    keyword_included should be zero.
  431.    For example route-map's "set extcommunity" command case:
  433.    "rt 100:1 100:2 100:3"        -> str = "100:1 100:2 100:3"
  434.                                     type = ECOMMUNITY_TYPE_ROUTE_TARGET
  435.                                     keyword_included = 0
  437.    "soo 100:1"                   -> str = "100:1"
  438.                                     type = ECOMMUNITY_TYPE_SITE_ORIGIN
  439.                                     keyword_included = 0
  441.    When string includes keyword for each extended community value.
  442.    Please specify keyword_included as non-zero value.
  444.    For example standard extcommunity-list case:
  446.    "rt 100:1 rt 100:2 soo 100:1" -> str = "rt 100:1 rt 100:2 soo 100:1"
  447.                                     type = 0
  448.                                     keyword_include = 1
  449. */
  450. struct ecommunity *
  451. ecommunity_str2com (char *str, int type, int keyword_included)
  452. {
  453.   struct ecommunity *ecom = NULL;
  454.   enum ecommunity_token token;
  455.   struct ecommunity_val eval;
  456.   int keyword = 0;
  458.   while ((str = ecommunity_gettoken (str, &eval, &token)))
  459.     {
  460.       switch (token)
  461. {
  462. case ecommunity_token_rt:
  463. case ecommunity_token_soo:
  464.   if (! keyword_included || keyword)
  465.     {
  466.       if (ecom)
  467. ecommunity_free (ecom);
  468.       return NULL;
  469.     }
  470.   keyword = 1;
  472.   if (token == ecommunity_token_rt)
  473.     {
  474.       type = ECOMMUNITY_TYPE_ROUTE_TARGET;
  475.     }
  476.   if (token == ecommunity_token_soo)
  477.     {
  478.       type = ECOMMUNITY_TYPE_SITE_ORIGIN;
  479.     }
  480.   break;
  481. case ecommunity_token_val:
  482.   if (keyword_included)
  483.     {
  484.       if (! keyword)
  485. {
  486.   if (ecom)
  487.     ecommunity_free (ecom);
  488.   return NULL;
  489. }
  490.       keyword = 0;
  491.     }
  492.   if (ecom == NULL)
  493.     ecom = ecommunity_new ();
  494.   eval.val[1] = type;
  495.   ecommunity_add_val (ecom, &eval);
  496.   break;
  497. case ecommunity_token_unknown:
  498. default:
  499.   if (ecom)
  500.     ecommunity_free (ecom);
  501.   return NULL;
  502.   break;
  503. }
  504.     }
  505.   return ecom;
  506. }
  508. struct ecommunity *
  509. ecommunity_cost_str2com (char *str, u_char poi)
  510. {
  511.   struct ecommunity *ecom = NULL;
  512.   struct ecommunity_cost ecost;
  513.   u_int32_t id = 0;
  514.   u_int32_t val = 0;
  515.   char *p = str;
  517.   while (isspace ((int) *p))
  518.     p++;
  520.   while (isdigit ((int) *p))
  521.     {
  522.       id *= 10;
  523.       id += (*p - '0');
  524.       p++;
  525.     }
  527.   while (isspace ((int) *p))
  528.     p++;
  530.   while (isdigit ((int) *p))
  531.     {
  532.       val *= 10;
  533.       val += (*p - '0');
  534.       p++;
  535.     }
  537.   ecost.type = ntohs (ECOMMUNITY_COST_COMMUNITY);
  538.   ecost.poi = poi;
  539.   ecost.id = id;
  540.   ecost.val = ntohl (val);
  542.   ecom = ecommunity_new ();
  543.   ecommunity_add_val (ecom, (struct ecommunity_val *)&ecost);
  545.   return ecom;
  546. }
  548. /* Convert extended community attribute to string.  
  550.    Due to historical reason of industry standard implementation, there
  551.    are three types of format.
  553.    route-map set extcommunity format
  554.         "rt 100:1 100:2"
  555.         "soo 100:3"
  557.    extcommunity-list
  558.         "rt 100:1 rt 100:2 soo 100:3"
  560.    "show ip bgp" and extcommunity-list regular expression matching
  561.         "RT:100:1 RT:100:2 SoO:100:3"
  563.    For each formath please use below definition for format:
  565.    ECOMMUNITY_FORMAT_CONFIG
  566.    ECOMMUNITY_FORMAT_DISPLAY
  567. */
  570. char *
  571. ecommunity_cost_poi_print (u_char poi)
  572. {
  573.   if (poi == ECOMMUNITY_COST_POI_IGP)
  574.     return "igp";
  576.   return "?";
  577. }
  579. char *
  580. ecommunity_ecom2str (struct ecommunity *ecom, int format)
  581. {
  582.   int i;
  583.   u_char *pnt;
  584.   int encode = 0;
  585.   int encode_check = 0;
  586.   int type = 0;
  587. #define ECOMMUNITY_STR_DEFAULT_LEN  26
  588.   int str_size;
  589.   int str_pnt;
  590.   u_char *str_buf;
  591.   char *prefix;
  592.   int len = 0;
  593.   int first = 1;
  595.   /* For parse Extended Community attribute tupple. */
  596.   struct ecommunity_as
  597.   {
  598.     as_t as;
  599.     u_int32_t val;
  600.   } eas;
  602.   struct ecommunity_ip
  603.   {
  604.     struct in_addr ip;
  605.     u_int16_t val;
  606.   } eip;
  608.   if (ecom->size == 0)
  609.     {
  610.       str_buf = XMALLOC (MTYPE_ECOMMUNITY_STR, 1);
  611.       str_buf[0] = '';
  612.       return str_buf;
  613.     }
  615.   /* Prepare buffer.  */
  616.   str_buf = XMALLOC (MTYPE_ECOMMUNITY_STR, ECOMMUNITY_STR_DEFAULT_LEN + 1);
  617.   str_size = ECOMMUNITY_STR_DEFAULT_LEN + 1;
  618.   str_pnt = 0;
  620.   for (i = 0; i < ecom->size; i++)
  621.     {
  622.       /* Make it sure size is enough.  */
  623.       while (str_pnt + ECOMMUNITY_STR_DEFAULT_LEN >= str_size)
  624. {
  625.   str_size *= 2;
  626.   str_buf = XREALLOC (MTYPE_ECOMMUNITY_STR, str_buf, str_size);
  627. }
  629.       /* Space between each value.  */
  630.       if (! first)
  631. str_buf[str_pnt++] = ' ';
  633.       pnt = ecom->val + (i * 8);
  635.       /* High-order octet of type. */
  636.       encode = *pnt++;
  637.       encode_check = encode & ~ECOMMUNITY_FLAG_NON_TRANSITIVE;
  639.       if (encode_check != ECOMMUNITY_ENCODE_AS
  640.           && encode_check != ECOMMUNITY_ENCODE_IP
  641.           && encode_check != ECOMMUNITY_ENCODE_OPAQUE)
  642. {
  643.   len = sprintf (str_buf + str_pnt, "?");
  644.   str_pnt += len;
  645.   first = 0;
  646.   continue;
  647. }
  648.       
  649.       /* Low-order octet of type. */
  650.       type = *pnt++;
  651.       if ((encode_check == ECOMMUNITY_ENCODE_AS
  652.    || encode_check == ECOMMUNITY_ENCODE_IP
  653.    || encode_check == ECOMMUNITY_ENCODE_4OCTET_AS)
  654.   && (type == ECOMMUNITY_TYPE_ROUTE_TARGET || type == ECOMMUNITY_TYPE_SITE_ORIGIN)
  655.   && ! CHECK_FLAG (encode, ECOMMUNITY_FLAG_NON_TRANSITIVE))
  656. {
  657.   switch (format)
  658.     {
  659.       case ECOMMUNITY_FORMAT_CONFIG:
  660. prefix = (type == ECOMMUNITY_TYPE_ROUTE_TARGET ? "rt " : "soo ");
  661. break;
  662.       case ECOMMUNITY_FORMAT_DISPLAY:
  663. prefix = (type == ECOMMUNITY_TYPE_ROUTE_TARGET ? "RT:" : "SoO:");
  664. break;
  665.       default:
  666. prefix = "";
  667. break;
  668.     }
  669. }
  670.       else if (encode_check == ECOMMUNITY_ENCODE_OPAQUE
  671.        && type == ECOMMUNITY_TYPE_COST_COMMUNITY
  672.        && CHECK_FLAG (encode, ECOMMUNITY_FLAG_NON_TRANSITIVE))
  673. {
  674.   u_int32_t val;
  675.   u_char poi;
  676.   u_char id;
  678.           poi = *pnt++;
  679.   id =  *pnt++;
  680.   memcpy (&val, pnt, 4);
  682.   len = sprintf (str_buf + str_pnt, "Cost:%s:%d:%u",
  683.  ecommunity_cost_poi_print (poi), id, ntohl (val));
  684.   str_pnt += len;
  685.   first = 0;
  686.   continue;
  687. }
  688.       else
  689. {
  690.   len = sprintf (str_buf + str_pnt, "?");
  691.   str_pnt += len;
  692.   first = 0;
  693.   continue;
  694. }
  696.       /* Put string into buffer.  */
  697.       if (encode_check == ECOMMUNITY_ENCODE_AS)
  698. {
  699.   eas.as = (*pnt++ << 8);
  700.   eas.as |= (*pnt++);
  702.   eas.val = (*pnt++ << 24);
  703.   eas.val |= (*pnt++ << 16);
  704.   eas.val |= (*pnt++ << 8);
  705.   eas.val |= (*pnt++);
  707.   len = sprintf (str_buf + str_pnt, "%s%d:%d", prefix,
  708.  eas.as, eas.val);
  709.   str_pnt += len;
  710.   first = 0;
  711. }
  712.       else if (encode_check == ECOMMUNITY_ENCODE_IP)
  713. {
  714.   memcpy (&eip.ip, pnt, 4);
  715.   pnt += 4;
  716.   eip.val = (*pnt++ << 8);
  717.   eip.val |= (*pnt++);
  719.   len = sprintf (str_buf + str_pnt, "%s%s:%d", prefix,
  720.  inet_ntoa (eip.ip), eip.val);
  721.   str_pnt += len;
  722.   first = 0;
  723. }
  724.     }
  725.   return str_buf;
  726. }
  728. int
  729. ecommunity_match (struct ecommunity *ecom1, struct ecommunity *ecom2)
  730. {
  731.   int i = 0;
  732.   int j = 0;
  734.   if (ecom1 == NULL && ecom2 == NULL)
  735.     return 1;
  737.   if (ecom1 == NULL || ecom2 == NULL)
  738.     return 0;
  740.   if (ecom1->size < ecom2->size)
  741.     return 0;
  743.   /* Every community on com2 needs to be on com1 for this to match */
  744.   while (i < ecom1->size && j < ecom2->size)
  745.     {
  746.       if (memcmp (ecom1->val + i, ecom2->val + j, ECOMMUNITY_SIZE) == 0)
  747.         j++;
  748.       i++;
  749.     }
  751.   if (j == ecom2->size)
  752.     return 1;
  753.   else
  754.     return 0;
  755. }
  757. int
  758. ecommunity_cost_cmp (struct ecommunity *ecom1, struct ecommunity *ecom2, u_char poi)
  759. {
  760.   int i = 0;
  761.   int j = 0;
  762.   int find1 = 0;
  763.   int find2 = 0;
  764.   u_char id1 = 0;
  765.   u_char id2 = 0;
  766.   u_int32_t val1 = 0;
  767.   u_int32_t val2 = 0;
  769.   /* For parse Extended Community attribute tupple. */
  770.   struct ecommunity_cost
  771.   {
  772.     u_int16_t type;
  773.     u_char poi;
  774.     u_char id;
  775.     u_int32_t val;
  776.   } ecost;
  778.   if (ecom1 == NULL && ecom2 == NULL)
  779.     return 0;
  781.   while (1)
  782.     {
  783.       while (ecom1 && i < ecom1->size)
  784. {
  785.   memcpy (&ecost, (ecom1->val + (i * 8)), sizeof (struct ecommunity_cost));
  787.   if (ntohs (ecost.type) == ECOMMUNITY_COST_COMMUNITY
  788.       && ecost.poi == poi)
  789.     {
  790.       id1 = ecost.id;
  791.       val1 = ntohl (ecost.val);
  792.       find1 = 1;
  793.       break;
  794.     }
  795.   i++;
  796. }
  798.       while (ecom2 && j < ecom2->size)
  799. {
  800.   memcpy (&ecost, ecom2->val + (j * 8), sizeof (struct ecommunity_cost));
  801.   if (ntohs (ecost.type) == ECOMMUNITY_COST_COMMUNITY
  802.       && ecost.poi == poi)
  803.     {
  804.       id2 = ecost.id;
  805.       val2 = ntohl (ecost.val);
  806.       find2 = 1;
  807.       break;
  808.     }
  809.   j++;
  810. }
  812.       if (! find1 || ! find2)
  813. break;
  814.       if (id1 != id2)
  815. break;
  816.       if (val1 != val2)
  817. break;
  819.       find1 = 0;
  820.       find2 = 0;
  821.       i++;
  822.       j++;
  823.     }
  825.   if (! find1)
  826.     val1 = COST_COMMUNITY_DEFAULT_COST;
  827.   if (! find2)
  828.     val2 = COST_COMMUNITY_DEFAULT_COST;
  830.   if (find1 && find2)
  831.     {
  832.       if (id1 < id2)
  833. return 1;
  834.       if (id1 > id2)
  835. return -1;
  836.     }
  837.   if (val1 < val2)
  838.     return 1;
  839.   if (val1 > val2)
  840.     return -1;
  842.   return 0;
  843. }