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

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

网络

开发平台：

Unix_Linux

bgpd.c：源码内容
  1. /* BGP-4, BGP-4+ daemon program
  2.    Copyright (C) 1996, 97, 98, 99, 2000 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
  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 "prefix.h"
  24. #include "thread.h"
  25. #include "buffer.h"
  26. #include "stream.h"
  27. #include "command.h"
  28. #include "sockunion.h"
  29. #include "network.h"
  30. #include "memory.h"
  31. #include "filter.h"
  32. #include "routemap.h"
  33. #include "str.h"
  34. #include "log.h"
  35. #include "plist.h"
  36. #include "linklist.h"
  38. #include "bgpd/bgpd.h"
  39. #include "bgpd/bgp_table.h"
  40. #include "bgpd/bgp_aspath.h"
  41. #include "bgpd/bgp_route.h"
  42. #include "bgpd/bgp_dump.h"
  43. #include "bgpd/bgp_debug.h"
  44. #include "bgpd/bgp_community.h"
  45. #include "bgpd/bgp_attr.h"
  46. #include "bgpd/bgp_regex.h"
  47. #include "bgpd/bgp_clist.h"
  48. #include "bgpd/bgp_fsm.h"
  49. #include "bgpd/bgp_packet.h"
  50. #include "bgpd/bgp_zebra.h"
  51. #include "bgpd/bgp_open.h"
  52. #include "bgpd/bgp_filter.h"
  53. #include "bgpd/bgp_nexthop.h"
  54. #include "bgpd/bgp_damp.h"
  55. #include "bgpd/bgp_mplsvpn.h"
  56. #include "bgpd/bgp_advertise.h"
  57. #include "bgpd/bgp_network.h"
  58. #include "bgpd/bgp_vty.h"
  59. #ifdef HAVE_SNMP
  60. #include "bgpd/bgp_snmp.h"
  61. #endif /* HAVE_SNMP */
  62. #ifdef HAVE_TCP_SIGNATURE
  63. #include "bgpd/bgp_tcpsig.h"
  64. #endif /* HAVE_TCP_SIGNATURE */
  66. /* BGP process wide configuration.  */
  67. static struct bgp_master bgp_master;
  69. /* BGP process wide configuration pointer to export.  */
  70. struct bgp_master *bm;
  72. /* BGP community-list.  */
  73. struct community_list_handler *bgp_clist;
  75. /* BGP global flag manipulation.  */
  76. int
  77. bgp_option_set (int flag)
  78. {
  79.   switch (flag)
  80.     {
  81.     case BGP_OPT_NO_FIB:
  82.     case BGP_OPT_MULTIPLE_INSTANCE:
  83.     case BGP_OPT_CONFIG_CISCO:
  84.       SET_FLAG (bm->options, flag);
  85.       break;
  86.     default:
  87.       return BGP_ERR_INVALID_FLAG;
  88.       break;
  89.     }
  90.   return 0;
  91. }
  93. int
  94. bgp_option_unset (int flag)
  95. {
  96.   switch (flag)
  97.     {
  98.     case BGP_OPT_MULTIPLE_INSTANCE:
  99.       if (listcount (bm->bgp) > 1)
  100. return BGP_ERR_MULTIPLE_INSTANCE_USED;
  101.       /* Fall through.  */
  102.     case BGP_OPT_NO_FIB:
  103.     case BGP_OPT_CONFIG_CISCO:
  104.       UNSET_FLAG (bm->options, flag);
  105.       break;
  106.     default:
  107.       return BGP_ERR_INVALID_FLAG;
  108.       break;
  109.     }
  110.   return 0;
  111. }
  113. int
  114. bgp_option_check (int flag)
  115. {
  116.   return CHECK_FLAG (bm->options, flag);
  117. }
  119. /* BGP flag manipulation.  */
  120. int
  121. bgp_flag_set (struct bgp *bgp, int flag)
  122. {
  123.   SET_FLAG (bgp->flags, flag);
  124.   return 0;
  125. }
  127. int
  128. bgp_flag_unset (struct bgp *bgp, int flag)
  129. {
  130.   UNSET_FLAG (bgp->flags, flag);
  131.   return 0;
  132. }
  134. int
  135. bgp_flag_check (struct bgp *bgp, int flag)
  136. {
  137.   return CHECK_FLAG (bgp->flags, flag);
  138. }
  140. /* Internal function to set BGP structure configureation flag.  */
  141. static void
  142. bgp_config_set (struct bgp *bgp, int config)
  143. {
  144.   SET_FLAG (bgp->config, config);
  145. }
  147. static void
  148. bgp_config_unset (struct bgp *bgp, int config)
  149. {
  150.   UNSET_FLAG (bgp->config, config);
  151. }
  153. static int
  154. bgp_config_check (struct bgp *bgp, int config)
  155. {
  156.   return CHECK_FLAG (bgp->config, config);
  157. }
  159. /* Set BGP router identifier. */
  160. int
  161. bgp_router_id_set (struct bgp *bgp, struct in_addr *id)
  162. {
  163.   struct peer *peer;
  164.   struct listnode *nn;
  166.   if (bgp_config_check (bgp, BGP_CONFIG_ROUTER_ID)
  167.       && IPV4_ADDR_SAME (&bgp->router_id, id))
  168.     return 0;
  170.   IPV4_ADDR_COPY (&bgp->router_id, id);
  171.   bgp_config_set (bgp, BGP_CONFIG_ROUTER_ID);
  173.   /* Set all peer's local identifier with this value. */
  174.   LIST_LOOP (bgp->peer, peer, nn)
  175.     {
  176.       IPV4_ADDR_COPY (&peer->local_id, id);
  178.       if (peer->status == Established)
  179. {
  180.   peer->last_reset = PEER_DOWN_RID_CHANGE;
  181.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  182.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  183. }
  184.     }
  185.   return 0;
  186. }
  188. /* Unset BGP router identifier. */
  189. int
  190. bgp_router_id_unset (struct bgp *bgp)
  191. {
  192.   struct peer *peer;
  193.   struct listnode *nn;
  195.   if (! bgp_config_check (bgp, BGP_CONFIG_ROUTER_ID))
  196.     return 0;
  198.   bgp->router_id.s_addr = 0;
  199.   bgp_config_unset (bgp, BGP_CONFIG_ROUTER_ID);
  201.   /* Clear peer router id configuration.  */
  202.   LIST_LOOP (bgp->peer, peer, nn)
  203.     {
  204.       peer->local_id.s_addr = 0;
  205.     }
  207.   /* Set router-id from interface's address. */
  208.   bgp_if_update_all ();
  210.   /* Reset all BGP sessions to use new router-id.  */
  211.   LIST_LOOP (bgp->peer, peer, nn)
  212.     {
  213.       if (peer->status == Established)
  214. {
  215.   peer->last_reset = PEER_DOWN_RID_CHANGE;
  216.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  217.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  218. }
  219.     }
  221.   return 0;
  222. }
  224. /* BGP's cluster-id control. */
  225. int
  226. bgp_cluster_id_set (struct bgp *bgp, struct in_addr *cluster_id)
  227. {
  228.   struct peer *peer;
  229.   struct listnode *nn;
  231.   if (bgp_config_check (bgp, BGP_CONFIG_CLUSTER_ID)
  232.       && IPV4_ADDR_SAME (&bgp->cluster_id, cluster_id))
  233.     return 0;
  235.   IPV4_ADDR_COPY (&bgp->cluster_id, cluster_id);
  236.   bgp_config_set (bgp, BGP_CONFIG_CLUSTER_ID);
  238.   /* Clear all IBGP peer. */
  239.   LIST_LOOP (bgp->peer, peer, nn)
  240.     {
  241.       if (peer_sort (peer) != BGP_PEER_IBGP)
  242. continue;
  244.       if (peer->status == Established)
  245. {
  246.   peer->last_reset = PEER_DOWN_CLID_CHANGE;
  247.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  248.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  249. }
  250.     }
  251.   return 0;
  252. }
  254. int
  255. bgp_cluster_id_unset (struct bgp *bgp)
  256. {
  257.   struct peer *peer;
  258.   struct listnode *nn;
  260.   if (! bgp_config_check (bgp, BGP_CONFIG_CLUSTER_ID))
  261.     return 0;
  263.   bgp->cluster_id.s_addr = 0;
  264.   bgp_config_unset (bgp, BGP_CONFIG_CLUSTER_ID);
  266.   /* Clear all IBGP peer. */
  267.   LIST_LOOP (bgp->peer, peer, nn)
  268.     {
  269.       if (peer_sort (peer) != BGP_PEER_IBGP)
  270. continue;
  272.       if (peer->status == Established)
  273. {
  274.   peer->last_reset = PEER_DOWN_CLID_CHANGE;
  275.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  276.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  277. }
  278.     }
  279.   return 0;
  280. }
  282. /* BGP timer configuration.  */
  283. int
  284. bgp_timers_set (struct bgp *bgp, u_int32_t keepalive, u_int32_t holdtime)
  285. {
  286.   bgp->default_keepalive = (keepalive < holdtime / 3 
  287.     ? keepalive : holdtime / 3);
  288.   bgp->default_holdtime = holdtime;
  290.   return 0;
  291. }
  293. int
  294. bgp_timers_unset (struct bgp *bgp)
  295. {
  296.   bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
  297.   bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
  299.   return 0;
  300. }
  302. /* BGP confederation configuration.  */
  303. int
  304. bgp_confederation_id_set (struct bgp *bgp, as_t as)
  305. {
  306.   struct peer *peer;
  307.   struct listnode *nn;
  308.   int already_confed;
  310.   if (as == 0)
  311.     return BGP_ERR_INVALID_AS;
  313.   /* Remember - were we doing confederation before? */
  314.   already_confed = bgp_config_check (bgp, BGP_CONFIG_CONFEDERATION);
  315.   bgp->confed_id = as;
  316.   bgp_config_set (bgp, BGP_CONFIG_CONFEDERATION);
  318.   /* If we were doing confederation already, this is just an external
  319.      AS change.  Just Reset EBGP sessions, not CONFED sessions.  If we
  320.      were not doing confederation before, reset all EBGP sessions.  */
  321.   LIST_LOOP (bgp->peer, peer, nn)
  322.     {
  323.       /* We're looking for peers who's AS is not local or part of our
  324.  confederation.  */
  325.       if (already_confed)
  326. {
  327.   if (peer_sort (peer) == BGP_PEER_EBGP)
  328.     {
  329.       peer->local_as = as;
  330.       if (peer->status == Established)
  331. {
  332.   peer->last_reset = PEER_DOWN_CONFED_ID_CHANGE;
  333.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  334.        BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  335. }
  336.       else
  337. BGP_EVENT_ADD (peer, BGP_Stop);
  338.     }
  339. }
  340.       else
  341. {
  342.   /* Not doign confederation before, so reset every non-local
  343.      session */
  344.   if (peer_sort (peer) != BGP_PEER_IBGP)
  345.     {
  346.       /* Reset the local_as to be our EBGP one */
  347.       if (peer_sort (peer) == BGP_PEER_EBGP)
  348. peer->local_as = as;
  349.       if (peer->status == Established)
  350. {
  351.   peer->last_reset = PEER_DOWN_CONFED_ID_CHANGE;
  352.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  353.        BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  354. }
  355.       else
  356. BGP_EVENT_ADD (peer, BGP_Stop);
  357.     }
  358. }
  359.     }
  360.   return 0;
  361. }
  363. int
  364. bgp_confederation_id_unset (struct bgp *bgp)
  365. {
  366.   struct peer *peer;
  367.   struct listnode *nn;
  369.   bgp->confed_id = 0;
  370.   bgp_config_unset (bgp, BGP_CONFIG_CONFEDERATION);
  371.       
  372.   LIST_LOOP (bgp->peer, peer, nn)
  373.     {
  374.       /* We're looking for peers who's AS is not local */
  375.       if (peer_sort (peer) != BGP_PEER_IBGP)
  376. {
  377.   peer->local_as = bgp->as;
  378.   if (peer->status == Established)
  379.     {
  380.       peer->last_reset = PEER_DOWN_CONFED_ID_CHANGE;
  381.       bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  382.        BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  383.     }
  384.   else
  385.     BGP_EVENT_ADD (peer, BGP_Stop);
  386. }
  387.     }
  388.   return 0;
  389. }
  391. /* Is an AS part of the confed or not? */
  392. int
  393. bgp_confederation_peers_check (struct bgp *bgp, as_t as)
  394. {
  395.   int i;
  397.   if (! bgp)
  398.     return 0;
  400.   for (i = 0; i < bgp->confed_peers_cnt; i++)
  401.     if (bgp->confed_peers[i] == as)
  402.       return 1;
  403.   
  404.   return 0;
  405. }
  407. /* Add an AS to the confederation set.  */
  408. int
  409. bgp_confederation_peers_add (struct bgp *bgp, as_t as)
  410. {
  411.   struct peer *peer;
  412.   struct listnode *nn;
  414.   if (! bgp)
  415.     return BGP_ERR_INVALID_BGP;
  417.   if (bgp->as == as)
  418.     return BGP_ERR_INVALID_AS;
  420.   if (bgp_confederation_peers_check (bgp, as))
  421.     return -1;
  423.   if (bgp->confed_peers)
  424.     bgp->confed_peers = XREALLOC (MTYPE_BGP_CONFED_LIST, 
  425.   bgp->confed_peers,
  426.   (bgp->confed_peers_cnt + 1) * sizeof (as_t));
  427.   else
  428.     bgp->confed_peers = XMALLOC (MTYPE_BGP_CONFED_LIST, 
  429.  (bgp->confed_peers_cnt + 1) * sizeof (as_t));
  431.   bgp->confed_peers[bgp->confed_peers_cnt] = as;
  432.   bgp->confed_peers_cnt++;
  434.   if (bgp_config_check (bgp, BGP_CONFIG_CONFEDERATION))
  435.     {
  436.       LIST_LOOP (bgp->peer, peer, nn)
  437. {
  438.   if (peer->as == as)
  439.     {
  440.       peer->local_as = bgp->as;
  441.       if (peer->status == Established)
  442. {
  443.   peer->last_reset = PEER_DOWN_CONFED_PEER_CHANGE;
  444.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  445.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  446. }
  447.       else
  448.         BGP_EVENT_ADD (peer, BGP_Stop);
  449.     }
  450. }
  451.     }
  452.   return 0;
  453. }
  455. /* Delete an AS from the confederation set.  */
  456. int
  457. bgp_confederation_peers_remove (struct bgp *bgp, as_t as)
  458. {
  459.   int i;
  460.   int j;
  461.   struct peer *peer;
  462.   struct listnode *nn;
  464.   if (! bgp)
  465.     return -1;
  467.   if (! bgp_confederation_peers_check (bgp, as))
  468.     return -1;
  470.   for (i = 0; i < bgp->confed_peers_cnt; i++)
  471.     if (bgp->confed_peers[i] == as)
  472.       for(j = i + 1; j < bgp->confed_peers_cnt; j++)
  473. bgp->confed_peers[j - 1] = bgp->confed_peers[j];
  475.   bgp->confed_peers_cnt--;
  477.   if (bgp->confed_peers_cnt == 0)
  478.     {
  479.       if (bgp->confed_peers)
  480. XFREE (MTYPE_BGP_CONFED_LIST, bgp->confed_peers);
  481.       bgp->confed_peers = NULL;
  482.     }
  483.   else
  484.     bgp->confed_peers = XREALLOC (MTYPE_BGP_CONFED_LIST,
  485.   bgp->confed_peers,
  486.   bgp->confed_peers_cnt * sizeof (as_t));
  488.   /* Now reset any peer who's remote AS has just been removed from the
  489.      CONFED */
  490.   if (bgp_config_check (bgp, BGP_CONFIG_CONFEDERATION))
  491.     {
  492.       LIST_LOOP (bgp->peer, peer, nn)
  493. {
  494.   if (peer->as == as)
  495.     {
  496.       peer->local_as = bgp->confed_id;
  497.       if (peer->status == Established)
  498. {
  499.   peer->last_reset = PEER_DOWN_CONFED_PEER_CHANGE;
  500.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  501.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  502. }
  503.       else
  504. BGP_EVENT_ADD (peer, BGP_Stop);
  505.     }
  506. }
  507.     }
  509.   return 0;
  510. }
  512. /* Local preference configuration.  */
  513. int
  514. bgp_default_local_preference_set (struct bgp *bgp, u_int32_t local_pref)
  515. {
  516.   if (! bgp)
  517.     return -1;
  519.   bgp->default_local_pref = local_pref;
  521.   return 0;
  522. }
  524. int
  525. bgp_default_local_preference_unset (struct bgp *bgp)
  526. {
  527.   if (! bgp)
  528.     return -1;
  530.   bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
  532.   return 0;
  533. }
  535. /* Peer comparison function for sorting.  */
  536. static int
  537. peer_cmp (struct peer *p1, struct peer *p2)
  538. {
  539.   return sockunion_cmp (&p1->su, &p2->su);
  540. }
  542. int
  543. peer_af_flag_check (struct peer *peer, afi_t afi, safi_t safi, u_int32_t flag)
  544. {
  545.   return CHECK_FLAG (peer->af_flags[afi][safi], flag);
  546. }
  548. /* Reset all address family specific configuration.  */
  549. static void
  550. peer_af_flag_reset (struct peer *peer, afi_t afi, safi_t safi)
  551. {
  552.   int i;
  553.   struct bgp_filter *filter;
  554.   char orf_name[BUFSIZ];
  556.   filter = &peer->filter[afi][safi];
  558.   /* Clear neighbor filter and route-map */
  559.   for (i = FILTER_IN; i < FILTER_MAX; i++)
  560.     {
  561.       if (filter->dlist[i].name)
  562. {
  563.   free (filter->dlist[i].name);
  564.   filter->dlist[i].name = NULL;
  565. }
  566.       if (filter->plist[i].name)
  567. {
  568.   free (filter->plist[i].name);
  569.   filter->plist[i].name = NULL; 
  570. }
  571.       if (filter->aslist[i].name)
  572. {
  573.   free (filter->aslist[i].name);
  574.   filter->aslist[i].name = NULL;
  575. }
  576.       if (filter->map[i].name)
  577. {
  578.   free (filter->map[i].name);
  579.   filter->map[i].name = NULL;
  580. }
  581.     }
  583.   /* Clear unsuppress map.  */
  584.   if (filter->usmap.name)
  585.     free (filter->usmap.name);
  586.   filter->usmap.name = NULL;
  587.   filter->usmap.map = NULL;
  589.   /* Clear neighbor's all address family flags.  */
  590.   peer->af_flags[afi][safi] = 0;
  592.   /* Clear neighbor's all address family sflags. */
  593.   peer->af_sflags[afi][safi] = 0;
  595.   /* Clear neighbor's all address family capabilities. */
  596.   peer->af_cap[afi][safi] = 0;
  598.   /* Clear ORF info */
  599.   peer->orf_plist[afi][safi] = NULL;
  600.   sprintf (orf_name, "%s.%d.%d", peer->host, afi, safi);
  601.   prefix_bgp_orf_remove_all (orf_name);
  603.   /* Set default neighbor send-community.  */
  604.   if (! bgp_option_check (BGP_OPT_CONFIG_CISCO))
  605.     {
  606.       SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY);
  607.       SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY);
  608.     }
  610.   /* Clear neighbor default_originate_rmap */
  611.   if (peer->default_rmap[afi][safi].name)
  612.     free (peer->default_rmap[afi][safi].name);
  613.   peer->default_rmap[afi][safi].name = NULL;
  614.   peer->default_rmap[afi][safi].map = NULL;
  616.   /* Clear neighbor maximum-prefix */
  617.   peer->pmax[afi][safi] = 0;
  618.   peer->pmax_threshold[afi][safi] = MAXIMUM_PREFIX_THRESHOLD_DEFAULT;
  620.   /* Clear address family configuration */
  621.   peer->af_config[afi][safi] = 0;
  622. }
  624. void 
  625. peer_group_global_config_copy (struct peer *group, struct peer *peer)
  626. {
  627.   /* remote-as */
  628.   if (group->as)
  629.     peer->as = group->as;
  631.   /* remote-as */
  632.   if (group->change_local_as)
  633.     peer->change_local_as = group->change_local_as;
  635.   /* TTL */
  636.   peer->ttl = group->ttl;
  638.   peer->flags = group->flags;
  639.   peer->config = group->config;
  641.   /* peer timers apply */
  642.   peer->holdtime = group->holdtime;
  643.   peer->keepalive = group->keepalive;
  645.   /* advertisement-interval reset */
  646.   if (peer_sort (peer) == BGP_PEER_IBGP)
  647.     peer->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
  648.   else
  649.     peer->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
  651. #ifdef HAVE_TCP_SIGNATURE
  652.   /* password apply */
  653.   if (CHECK_FLAG (group->flags, PEER_FLAG_PASSWORD))
  654.     {
  655.       if (peer->password)
  656. free (peer->password);
  657.       peer->password = strdup (group->password);
  659.       bgp_tcpsig_set (bm->sock, peer);
  660.     }
  661.   else if (peer->password)
  662.     {
  663.       bgp_tcpsig_unset (bm->sock, peer);
  664.       free (peer->password);
  665.       peer->password = NULL;
  666.     }
  667. #endif /* HAVE_TCP_SIGNATURE */
  669.   /* update-source apply */
  670.   if (group->update_source)
  671.     {
  672.       if (peer->update_source)
  673. sockunion_free (peer->update_source);
  674.       if (peer->update_if)
  675. {
  676.   XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
  677.   peer->update_if = NULL;
  678. }
  679.       peer->update_source = sockunion_dup (group->update_source);
  680.     }
  681.   else if (group->update_if)
  682.     {
  683.       if (peer->update_if)
  684. XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
  685.       if (peer->update_source)
  686. {
  687.   sockunion_free (peer->update_source);
  688.   peer->update_source = NULL;
  689. }
  690.       peer->update_if = XSTRDUP (MTYPE_PEER_UPDATE_SOURCE, group->update_if);
  691.     }
  692. } 
  694. void 
  695. peer_group_af_config_copy (struct peer *group, struct peer *peer,
  696.    afi_t afi, safi_t safi)
  697. {
  698.   int in = FILTER_IN;
  699.   int out = FILTER_OUT;
  700.   struct bgp_filter *pfilter;
  701.   struct bgp_filter *gfilter;
  703.   pfilter = &peer->filter[afi][safi];
  704.   gfilter = &group->filter[afi][safi];
  706.   peer->af_flags[afi][safi] = group->af_flags[afi][safi];
  707.   peer->af_config[afi][safi] = group->af_config[afi][safi];
  708.   peer->weight[afi][safi] = group->weight[afi][safi];
  710.   /* maximum-prefix */
  711.   peer->pmax[afi][safi] = group->pmax[afi][safi];
  712.   peer->pmax_threshold[afi][safi] = group->pmax_threshold[afi][safi];
  713.   peer->pmax_restart[afi][safi] = group->pmax_restart[afi][safi];
  715.   /* allowas-in */
  716.   peer->allowas_in[afi][safi] = group->allowas_in[afi][safi];
  718.   /* default-originate route-map */
  719.   if (group->default_rmap[afi][safi].name)
  720.     {
  721.       if (peer->default_rmap[afi][safi].name)
  722. free (peer->default_rmap[afi][safi].name);
  723.       peer->default_rmap[afi][safi].name = strdup (group->default_rmap[afi][safi].name);
  724.       peer->default_rmap[afi][safi].map = group->default_rmap[afi][safi].map;
  725.     }
  727.   /* inbound filter apply */
  728.   if (gfilter->dlist[in].name && ! pfilter->dlist[in].name)
  729.     {
  730.       if (pfilter->dlist[in].name)
  731. free (pfilter->dlist[in].name);
  732.       pfilter->dlist[in].name = strdup (gfilter->dlist[in].name);
  733.       pfilter->dlist[in].alist = gfilter->dlist[in].alist;
  734.     }
  735.   if (gfilter->plist[in].name && ! pfilter->plist[in].name)
  736.     {
  737.       if (pfilter->plist[in].name)
  738. free (pfilter->plist[in].name);
  739.       pfilter->plist[in].name = strdup (gfilter->plist[in].name);
  740.       pfilter->plist[in].plist = gfilter->plist[in].plist;
  741.     }
  742.   if (gfilter->aslist[in].name && ! pfilter->aslist[in].name)
  743.     {
  744.       if (pfilter->aslist[in].name)
  745. free (pfilter->aslist[in].name);
  746.       pfilter->aslist[in].name = strdup (gfilter->aslist[in].name);
  747.       pfilter->aslist[in].aslist = gfilter->aslist[in].aslist;
  748.     }
  749.   if (gfilter->map[in].name && ! pfilter->map[in].name)
  750.     {
  751.       if (pfilter->map[in].name)
  752. free (pfilter->map[in].name);
  753.       pfilter->map[in].name = strdup (gfilter->map[in].name);
  754.       pfilter->map[in].map = gfilter->map[in].map;
  755.     }
  757.   /* outbound filter apply */
  758.   if (gfilter->dlist[out].name)
  759.     {
  760.       if (pfilter->dlist[out].name)
  761. free (pfilter->dlist[out].name);
  762.       pfilter->dlist[out].name = strdup (gfilter->dlist[out].name);
  763.       pfilter->dlist[out].alist = gfilter->dlist[out].alist;
  764.     }
  765.   else
  766.     {
  767.       if (pfilter->dlist[out].name)
  768. free (pfilter->dlist[out].name);
  769.       pfilter->dlist[out].name = NULL;
  770.       pfilter->dlist[out].alist = NULL;
  771.     }
  772.   if (gfilter->plist[out].name)
  773.     {
  774.       if (pfilter->plist[out].name)
  775. free (pfilter->plist[out].name);
  776.       pfilter->plist[out].name = strdup (gfilter->plist[out].name);
  777.       pfilter->plist[out].plist = gfilter->plist[out].plist;
  778.     }
  779.   else
  780.     {
  781.       if (pfilter->plist[out].name)
  782. free (pfilter->plist[out].name);
  783.       pfilter->plist[out].name = NULL;
  784.       pfilter->plist[out].plist = NULL;
  785.     }
  786.   if (gfilter->aslist[out].name)
  787.     {
  788.       if (pfilter->aslist[out].name)
  789. free (pfilter->aslist[out].name);
  790.       pfilter->aslist[out].name = strdup (gfilter->aslist[out].name);
  791.       pfilter->aslist[out].aslist = gfilter->aslist[out].aslist;
  792.     }
  793.   else
  794.     {
  795.       if (pfilter->aslist[out].name)
  796. free (pfilter->aslist[out].name);
  797.       pfilter->aslist[out].name = NULL;
  798.       pfilter->aslist[out].aslist = NULL;
  799.     }
  800.   if (gfilter->map[out].name)
  801.     {
  802.       if (pfilter->map[out].name)
  803. free (pfilter->map[out].name);
  804.       pfilter->map[out].name = strdup (gfilter->map[out].name);
  805.       pfilter->map[out].map = gfilter->map[out].map;
  806.     }
  807.   else
  808.     {
  809.       if (pfilter->map[out].name)
  810. free (pfilter->map[out].name);
  811.       pfilter->map[out].name = NULL;
  812.       pfilter->map[out].map = NULL;
  813.     }
  815.   if (gfilter->usmap.name)
  816.     {
  817.       if (pfilter->usmap.name)
  818. free (pfilter->usmap.name);
  819.       pfilter->usmap.name = strdup (gfilter->usmap.name);
  820.       pfilter->usmap.map = gfilter->usmap.map;
  821.     }
  822.   else
  823.     {
  824.       if (pfilter->usmap.name)
  825. free (pfilter->usmap.name);
  826.       pfilter->usmap.name = NULL;
  827.       pfilter->usmap.map = NULL;
  828.     }
  829. } 
  831. /* Check peer's AS number and determin is this peer IBGP or EBGP */
  832. int
  833. peer_sort (struct peer *peer)
  834. {
  835.   struct bgp *bgp;
  837.   bgp = peer->bgp;
  839.   /* Peer-group */
  840.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  841.     {
  842.       if (peer->as)
  843. return (bgp->as == peer->as ? BGP_PEER_IBGP : BGP_PEER_EBGP);
  844.       else
  845. {
  846.   struct peer *peer1;
  847.   peer1 = listnode_head (peer->group->peer);
  848.   if (peer1)
  849.     return (peer1->local_as == peer1->as 
  850.     ? BGP_PEER_IBGP : BGP_PEER_EBGP);
  851. } 
  852.       return BGP_PEER_INTERNAL;
  853.     }
  855.   /* Normal peer */
  856.   if (bgp && CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION))
  857.     {
  858.       if (peer->local_as == 0)
  859. return BGP_PEER_INTERNAL;
  861.       if (peer->local_as == peer->as)
  862. {
  863.   if (peer->local_as == bgp->confed_id)
  864.     return BGP_PEER_EBGP;
  865.   else
  866.     return BGP_PEER_IBGP;
  867. }
  869.       if (bgp_confederation_peers_check (bgp, peer->as))
  870. return BGP_PEER_CONFED;
  872.       return BGP_PEER_EBGP;
  873.     }
  874.   else
  875.     {
  876.       return (peer->local_as == 0
  877.       ? BGP_PEER_INTERNAL : peer->local_as == peer->as
  878.       ? BGP_PEER_IBGP : BGP_PEER_EBGP);
  879.     }
  880. }
  882. /* Allocate new peer object.  */
  883. static struct peer *
  884. peer_new ()
  885. {
  886.   afi_t afi;
  887.   safi_t safi;
  888.   struct peer *peer;
  889.   struct servent *sp;
  891.   /* Allocate new peer. */
  892.   peer = XMALLOC (MTYPE_BGP_PEER, sizeof (struct peer));
  893.   memset (peer, 0, sizeof (struct peer));
  895.   /* Set default value. */
  896.   peer->fd = -1;
  897.   peer->v_start = BGP_INIT_START_TIMER;
  898.   peer->v_connect = BGP_DEFAULT_CONNECT_RETRY;
  899.   peer->v_asorig = BGP_DEFAULT_ASORIGINATE;
  900.   peer->v_active_delay = BGP_ACTIVE_DELAY_TIMER;
  901.   peer->status = Idle;
  902.   peer->ostatus = Idle;
  903.   peer->password = NULL;
  905.   /* Set default flags.  */
  906.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  907.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  908.       {
  909. if (! bgp_option_check (BGP_OPT_CONFIG_CISCO))
  910.   {
  911.     SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY);
  912.     SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY);
  913.   }
  914. peer->orf_plist[afi][safi] = NULL;
  915.       }
  916.   SET_FLAG (peer->sflags, PEER_STATUS_CAPABILITY_OPEN);
  918.   /* Create buffers.  */
  919.   peer->ibuf = stream_new (BGP_MAX_PACKET_SIZE);
  920.   peer->obuf = stream_fifo_new ();
  921.   peer->work = stream_new (BGP_MAX_PACKET_SIZE);
  923.   bgp_sync_init (peer);
  925.   /* Get service port number.  */
  926.   sp = getservbyname ("bgp", "tcp");
  927.   peer->port = (sp == NULL) ? BGP_PORT_DEFAULT : ntohs (sp->s_port);
  929.   return peer;
  930. }
  932. /* Create new BGP peer.  */
  933. struct peer *
  934. peer_create (union sockunion *su, struct bgp *bgp, as_t local_as,
  935.      as_t remote_as, afi_t afi, safi_t safi)
  936. {
  937.   int active;
  938.   struct peer *peer;
  939.   char buf[SU_ADDRSTRLEN];
  941.   peer = peer_new ();
  942.   peer->bgp = bgp;
  943.   peer->su = *su;
  944.   peer->local_as = local_as;
  945.   peer->as = remote_as;
  946.   peer->local_id = bgp->router_id;
  947.   peer->v_holdtime = bgp->default_holdtime;
  948.   peer->v_keepalive = bgp->default_keepalive;
  949.   if (peer_sort (peer) == BGP_PEER_IBGP)
  950.     peer->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
  951.   else
  952.     peer->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
  953.   listnode_add_sort (bgp->peer, peer);
  955.   active = peer_active (peer);
  957.   if (afi && safi)
  958.     peer->afc[afi][safi] = 1;
  960.   /* Last read time set */
  961.   peer->readtime = time (NULL);
  963.   /* Last reset time set */
  964.   peer->resettime = time (NULL);
  966.   /* Default TTL set. */
  967.   peer->ttl = (peer_sort (peer) == BGP_PEER_IBGP ? 255 : 1);
  969.   /* Make peer's address string. */
  970.   sockunion2str (su, buf, SU_ADDRSTRLEN);
  971.   peer->host = strdup (buf);
  973.   /* set peer first create flag */ 
  974.   SET_FLAG (peer->sflags, PEER_STATUS_CREATE_INIT);
  976.   /* Set up peer's events and timers. */
  977.   if (! active && peer_active (peer))
  978.     bgp_timer_set (peer);
  980.   return peer;
  981. }
  983. /* Make accept BGP peer.  Called from bgp_accept (). */
  984. struct peer *
  985. peer_create_accept (struct bgp *bgp)
  986. {
  987.   struct peer *peer;
  989.   peer = peer_new ();
  990.   peer->bgp = bgp;
  991.   listnode_add_sort (bgp->peer, peer);
  993.   return peer;
  994. }
  996. /* Change peer's AS number.  */
  997. void
  998. peer_as_change (struct peer *peer, as_t as)
  999. {
  1000.   int type;
  1002.   /* Stop peer. */
  1003.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  1004.     {
  1005.       if (peer->status == Established)
  1006. {
  1007.   peer->last_reset = PEER_DOWN_REMOTE_AS_CHANGE;
  1008.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  1009.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  1010. }
  1011.       else
  1012. BGP_EVENT_ADD (peer, BGP_Stop);
  1013.     }
  1014.   type = peer_sort (peer);
  1015.   peer->as = as;
  1017.   if (bgp_config_check (peer->bgp, BGP_CONFIG_CONFEDERATION)
  1018.       && ! bgp_confederation_peers_check (peer->bgp, as)
  1019.       && peer->bgp->as != as)
  1020.     peer->local_as = peer->bgp->confed_id;
  1021.   else
  1022.     peer->local_as = peer->bgp->as;
  1024.   /* Advertisement-interval reset */
  1025.   if (peer_sort (peer) == BGP_PEER_IBGP)
  1026.     peer->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
  1027.   else
  1028.     peer->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
  1030.   /* TTL reset */
  1031.   if (peer_sort (peer) == BGP_PEER_IBGP)
  1032.     peer->ttl = 255;
  1033.   else if (type == BGP_PEER_IBGP)
  1034.     peer->ttl = 1;
  1036.   /* reflector-client reset */
  1037.   if (peer_sort (peer) != BGP_PEER_IBGP)
  1038.     {
  1039.       UNSET_FLAG (peer->af_flags[AFI_IP][SAFI_UNICAST],
  1040.   PEER_FLAG_REFLECTOR_CLIENT);
  1041.       UNSET_FLAG (peer->af_flags[AFI_IP][SAFI_MULTICAST],
  1042.   PEER_FLAG_REFLECTOR_CLIENT);
  1043.       UNSET_FLAG (peer->af_flags[AFI_IP][SAFI_MPLS_VPN],
  1044.   PEER_FLAG_REFLECTOR_CLIENT);
  1045.       UNSET_FLAG (peer->af_flags[AFI_IP6][SAFI_UNICAST],
  1046.   PEER_FLAG_REFLECTOR_CLIENT);
  1047.       UNSET_FLAG (peer->af_flags[AFI_IP6][SAFI_MULTICAST],
  1048.   PEER_FLAG_REFLECTOR_CLIENT);
  1049.     }
  1051.   /* local-as reset */
  1052.   if (peer_sort (peer) != BGP_PEER_EBGP)
  1053.     {
  1054.       peer->change_local_as = 0;
  1055.       UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
  1056.     }
  1057. }
  1059. /* If peer does not exist, create new one.  If peer already exists,
  1060.    set AS number to the peer.  */
  1061. int
  1062. peer_remote_as (struct bgp *bgp, union sockunion *su, as_t *as,
  1063. afi_t afi, safi_t safi)
  1064. {
  1065.   struct peer *peer;
  1066.   as_t local_as;
  1068.   peer = peer_lookup (bgp, su);
  1070.   if (peer)
  1071.     {
  1072.       /* When this peer is a member of peer-group.  */
  1073.       if (peer->group)
  1074. {
  1075.   if (peer->group->conf->as)
  1076.     {
  1077.       /* Return peer group's AS number.  */
  1078.       *as = peer->group->conf->as;
  1079.       return BGP_ERR_PEER_GROUP_MEMBER;
  1080.     }
  1081.   if (peer_sort (peer->group->conf) == BGP_PEER_IBGP)
  1082.     {
  1083.       if (bgp->as != *as)
  1084. {
  1085.   *as = peer->as;
  1086.   return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
  1087. }
  1088.     }
  1089.   else
  1090.     {
  1091.       if (bgp->as == *as)
  1092. {
  1093.   *as = peer->as;
  1094.   return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
  1095. }
  1096.     }
  1097. }
  1099.       /* Existing peer's AS number change. */
  1100.       if (peer->as != *as)
  1101. peer_as_change (peer, *as);
  1102.     }
  1103.   else
  1104.     {
  1106.       /* If the peer is not part of our confederation, and its not an
  1107.  iBGP peer then spoof the source AS */
  1108.       if (bgp_config_check (bgp, BGP_CONFIG_CONFEDERATION)
  1109.   && ! bgp_confederation_peers_check (bgp, *as) 
  1110.   && bgp->as != *as)
  1111. local_as = bgp->confed_id;
  1112.       else
  1113. local_as = bgp->as;
  1114.       
  1115.       /* If this is IPv4 unicast configuration and "no bgp default
  1116.          ipv4-unicast" is specified. */
  1118.       if (bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4)
  1119.   && afi == AFI_IP && safi == SAFI_UNICAST)
  1120. peer = peer_create (su, bgp, local_as, *as, 0, 0); 
  1121.       else
  1122. peer = peer_create (su, bgp, local_as, *as, afi, safi); 
  1123.     }
  1125.   return 0;
  1126. }
  1128. /* Activate the peer or peer group for specified AFI and SAFI.  */
  1129. int
  1130. peer_activate (struct peer *peer, afi_t afi, safi_t safi)
  1131. {
  1132.   int active;
  1134.   if (peer->afc[afi][safi])
  1135.     return 0;
  1137.   /* Activate the address family configuration. */
  1138.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  1139.     peer->afc[afi][safi] = 1;
  1140.   else
  1141.     {
  1142.       active = peer_active (peer);
  1144.       peer->afc[afi][safi] = 1;
  1146.       if (peer_group_member (peer))
  1147. {
  1148.   peer->group->conf->afc[afi][safi] = 1;
  1149.   peer_group_af_config_copy (peer->group->conf, peer, afi, safi);
  1150. }
  1152.       if (! active && peer_active (peer))
  1153. bgp_timer_set (peer);
  1154.       else
  1155. {
  1156.   if (peer->status == Established)
  1157.     {
  1158.       if (CHECK_FLAG (peer->cap, PEER_CAP_DYNAMIC_ADV)
  1159.   && CHECK_FLAG (peer->cap, PEER_CAP_DYNAMIC_RCV))
  1160. {
  1161.   peer->afc_adv[afi][safi] = 1;
  1162.   bgp_capability_send (peer, afi, safi,
  1163.        CAPABILITY_CODE_MP,
  1164.        CAPABILITY_ACTION_SET);
  1165.   if (peer->afc_recv[afi][safi])
  1166.     {
  1167.       peer->afc_nego[afi][safi] = 1;
  1168.       bgp_announce_route (peer, afi, safi);
  1169.     }
  1170. }
  1171.       else
  1172. {
  1173.   peer->last_reset = PEER_DOWN_AF_ACTIVATE;
  1174.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  1175.      BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  1176. }
  1177.     }
  1178. }
  1179.     }
  1180.   return 0;
  1181. }
  1183. int
  1184. peer_deactivate (struct peer *peer, afi_t afi, safi_t safi)
  1185. {
  1186.   struct peer_group *group;
  1187.   struct peer *peer1;
  1188.   struct listnode *nn;
  1190.   if (! peer->afc[afi][safi])
  1191.     return 0;
  1193.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  1194.     {
  1195.       group = peer->group;
  1197.       LIST_LOOP (group->peer, peer1, nn)
  1198. {
  1199.   if (peer1->afc[afi][safi])
  1200.     return BGP_ERR_PEER_GROUP_MEMBER_EXISTS;
  1201. }
  1202.     }
  1204.   /* De-activate the address family configuration. */
  1205.   peer->afc[afi][safi] = 0;
  1206.   peer_af_flag_reset (peer, afi, safi);
  1208.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  1209.     {  
  1210.       if (peer->status == Established)
  1211. {
  1212.   if (CHECK_FLAG (peer->cap, PEER_CAP_DYNAMIC_ADV)
  1213.       && CHECK_FLAG (peer->cap, PEER_CAP_DYNAMIC_RCV))
  1214.     {
  1215.       peer->afc_adv[afi][safi] = 0;
  1216.       peer->afc_nego[afi][safi] = 0;
  1218.       if (peer_active_nego (peer))
  1219. {
  1220.   bgp_capability_send (peer, afi, safi,
  1221.        CAPABILITY_CODE_MP,
  1222.        CAPABILITY_ACTION_UNSET);
  1223.   bgp_clear_route (peer, afi, safi);
  1224.   peer->synctime[afi][safi] = 0;
  1225.   BGP_TIMER_OFF (peer->t_routeadv[afi][safi]);
  1226.   peer->af_sflags[afi][safi] = 0;
  1227. }
  1228.       else
  1229. {
  1230.   peer->last_reset = PEER_DOWN_NEIGHBOR_DELETE;
  1231.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  1232.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  1233. }
  1234.     }
  1235.   else
  1236.     {
  1237.       peer->last_reset = PEER_DOWN_NEIGHBOR_DELETE;
  1238.       bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  1239.        BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  1240.     }
  1241. }
  1242.     }
  1243.   return 0;
  1244. }
  1246. void
  1247. peer_nsf_stop (struct peer *peer)
  1248. {
  1249.   afi_t afi;
  1250.   safi_t safi;
  1252.   UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT);
  1253.   UNSET_FLAG (peer->sflags, PEER_STATUS_NSF_MODE);
  1255.   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
  1256.     for (safi = SAFI_UNICAST ; safi < SAFI_UNICAST_MULTICAST ; safi++)
  1257.       peer->nsf[afi][safi] = 0;
  1259.   if (peer->t_gr_restart)
  1260.     {
  1261.       BGP_TIMER_OFF (peer->t_gr_restart);
  1262.       if (BGP_DEBUG (events, EVENTS))
  1263. zlog_info ("%s graceful restart timer stopped", peer->host);
  1264.     }
  1265.   if (peer->t_gr_stale)
  1266.     {
  1267.       BGP_TIMER_OFF (peer->t_gr_stale);
  1268.       if (BGP_DEBUG (events, EVENTS))
  1269. zlog_info ("%s graceful restart stalepath timer stopped", peer->host);
  1270.     }
  1271.   bgp_clear_route_all (peer);
  1272. }
  1274. /* Delete peer from confguration. */
  1275. int
  1276. peer_delete (struct peer *peer)
  1277. {
  1278.   int i;
  1279.   afi_t afi;
  1280.   safi_t safi;
  1281.   struct bgp *bgp;
  1282.   struct bgp_filter *filter;
  1284.   bgp = peer->bgp;
  1286.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT))
  1287.     peer_nsf_stop (peer);
  1289.   /* Delete peer from peer-list of group when peer is member of peer-group. */
  1290.   if (peer_group_member (peer))
  1291.     {
  1292.       listnode_delete (peer->group->peer, peer);
  1293.       peer->group = NULL;
  1294.     }
  1296.   /* Withdraw all information from routing table.  We can not use
  1297.      BGP_EVENT_ADD (peer, BGP_Stop) at here.  Because the event is
  1298.      executed after peer structure is deleted. */
  1299.   if (peer->status == Established)
  1300.     bgp_notify_send (peer, BGP_NOTIFY_CEASE, BGP_NOTIFY_CEASE_PEER_UNCONFIG);
  1301.   else
  1302.     {
  1303.       bgp_stop (peer);
  1304.       bgp_fsm_change_status (peer, Idle);
  1305.     }
  1307.   /* Stop all timers. */
  1308.   BGP_TIMER_OFF (peer->t_start);
  1309.   BGP_TIMER_OFF (peer->t_connect);
  1310.   BGP_TIMER_OFF (peer->t_holdtime);
  1311.   BGP_TIMER_OFF (peer->t_keepalive);
  1312.   BGP_TIMER_OFF (peer->t_asorig);
  1313.   BGP_TIMER_OFF (peer->t_pmax_restart);
  1314.   BGP_TIMER_OFF (peer->t_gr_restart);
  1315.   BGP_TIMER_OFF (peer->t_gr_stale);
  1316.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  1317.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  1318.       BGP_TIMER_OFF (peer->t_routeadv[afi][safi]);
  1320. #ifdef HAVE_TCP_SIGNATURE
  1321.   /* Password configuration */
  1322.   if (peer->password)
  1323.     {
  1324.       if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  1325. bgp_tcpsig_unset (bm->sock, peer);
  1326.       free (peer->password);
  1327.     }
  1328. #endif /* HAVE_TCP_SIGNATURE */
  1330.   /* Delete peer from peer-list of bgp, except peer of peer_self and peer_group. */
  1331.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP)
  1332.       && peer != bgp->peer_self)
  1333.     listnode_delete (bgp->peer, peer);
  1335.   /* Buffer.  */
  1336.   if (peer->ibuf)
  1337.     stream_free (peer->ibuf);
  1339.   if (peer->obuf)
  1340.     stream_fifo_free (peer->obuf);
  1342.   if (peer->work)
  1343.     stream_free (peer->work);
  1345.   /* Free allocated host character. */
  1346.   if (peer->host)
  1347.     free (peer->host);
  1349.   /* Local and remote addresses. */
  1350.   if (peer->su_local)
  1351.     XFREE (MTYPE_TMP, peer->su_local);
  1352.   if (peer->su_remote)
  1353.     XFREE (MTYPE_TMP, peer->su_remote);
  1355.   /* Peer description string.  */
  1356.   if (peer->desc)
  1357.     XFREE (MTYPE_TMP, peer->desc);
  1359.   bgp_sync_delete (peer);
  1361.   /* Free filter related memory.  */
  1362.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  1363.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  1364.       {
  1365. filter = &peer->filter[afi][safi];
  1367. for (i = FILTER_IN; i < FILTER_MAX; i++)
  1368.   {
  1369.     if (filter->dlist[i].name)
  1370.       free (filter->dlist[i].name);
  1371.     if (filter->plist[i].name)
  1372.       free (filter->plist[i].name);
  1373.     if (filter->aslist[i].name)
  1374.       free (filter->aslist[i].name);
  1375.     if (filter->map[i].name)
  1376.       free (filter->map[i].name);
  1377.   }
  1379. if (filter->usmap.name)
  1380.   free (filter->usmap.name);
  1382. if (peer->default_rmap[afi][safi].name)
  1383.   free (peer->default_rmap[afi][safi].name);
  1384.       }
  1386.   /* Update source configuration.  */
  1387.   if (peer->update_source)
  1388.     {
  1389.       sockunion_free (peer->update_source);
  1390.       peer->update_source = NULL;
  1391.     }
  1392.   if (peer->update_if)
  1393.     {
  1394.       XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
  1395.       peer->update_if = NULL;
  1396.     }
  1398.   /* Free peer structure. */
  1399.   XFREE (MTYPE_BGP_PEER, peer);
  1401.   return 0;
  1402. }
  1404. int
  1405. peer_group_cmp (struct peer_group *g1, struct peer_group *g2)
  1406. {
  1407.   return strcmp (g1->name, g2->name);
  1408. }
  1410. /* If peer is member of peer-group return 1. */
  1411. int
  1412. peer_group_member (struct peer *peer)
  1413. {
  1414.   if (peer->group && ! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  1415.     return 1;
  1416.   return 0;
  1417. }
  1419. /* Peer group cofiguration. */
  1420. static struct peer_group *
  1421. peer_group_new ()
  1422. {
  1423.   return (struct peer_group *) XCALLOC (MTYPE_PEER_GROUP,
  1424. sizeof (struct peer_group));
  1425. }
  1427. void
  1428. peer_group_free (struct peer_group *group)
  1429. {
  1430.   XFREE (MTYPE_PEER_GROUP, group);
  1431. }
  1433. struct peer_group *
  1434. peer_group_lookup (struct bgp *bgp, char *name)
  1435. {
  1436.   struct peer_group *group;
  1437.   struct listnode *nn;
  1439.   LIST_LOOP (bgp->group, group, nn)
  1440.     {
  1441.       if (strcmp (group->name, name) == 0)
  1442. return group;
  1443.     }
  1444.   return NULL;
  1445. }
  1447. struct peer_group *
  1448. peer_group_get (struct bgp *bgp, char *name)
  1449. {
  1450.   struct peer_group *group;
  1452.   group = peer_group_lookup (bgp, name);
  1453.   if (group)
  1454.     return group;
  1456.   group = peer_group_new ();
  1457.   group->bgp = bgp;
  1458.   group->name = strdup (name);
  1459.   group->peer = list_new ();
  1460.   group->conf = peer_new ();
  1461.   if (! bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4))
  1462.     group->conf->afc[AFI_IP][SAFI_UNICAST] = 1;
  1463.   group->conf->host = strdup (name);
  1464.   group->conf->bgp = bgp;
  1465.   group->conf->group = group;
  1466.   group->conf->as = 0; 
  1467.   group->conf->ttl = 1;
  1468.   group->conf->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
  1469.   UNSET_FLAG (group->conf->config, PEER_CONFIG_TIMER);
  1470.   group->conf->keepalive = 0;
  1471.   group->conf->holdtime = 0;
  1472.   SET_FLAG (group->conf->sflags, PEER_STATUS_GROUP);
  1473.   listnode_add_sort (bgp->group, group);
  1475.   return 0;
  1476. }
  1478. /* Peer group's remote AS configuration.  */
  1479. int
  1480. peer_group_remote_as (struct bgp *bgp, char *group_name, as_t *as)
  1481. {
  1482.   struct peer_group *group;
  1483.   struct peer *peer;
  1484.   struct listnode *nn;
  1486.   group = peer_group_lookup (bgp, group_name);
  1487.   if (! group)
  1488.     return -1;
  1490.   if (group->conf->as == *as)
  1491.     return 0;
  1493.   /* When we setup peer-group AS number all peer group member's AS
  1494.      number must be updated to same number.  */
  1495.   peer_as_change (group->conf, *as);
  1497.   LIST_LOOP (group->peer, peer, nn)
  1498.     {
  1499.       if (peer->as != *as)
  1500. peer_as_change (peer, *as);
  1501.     }
  1503.   return 0;
  1504. }
  1506. int
  1507. peer_group_delete (struct peer_group *group)
  1508. {
  1509.   struct bgp *bgp;
  1510.   struct peer *peer;
  1511.   struct listnode *nn;
  1512.   struct listnode *next;
  1514.   bgp = group->bgp;
  1516.   for (nn = group->peer->head; nn; nn = next)
  1517.     {
  1518.       peer = nn->data;
  1519.       next = nn->next;
  1520.       peer_delete (peer);
  1521.     }
  1523.   free (group->name);
  1524.   group->name = NULL;
  1525.   peer_delete (group->conf);
  1527.   /* Delete from all peer_group list. */
  1528.   listnode_delete (bgp->group, group);
  1530.   peer_group_free (group);
  1532.   return 0;
  1533. }
  1535. int
  1536. peer_group_remote_as_delete (struct peer_group *group)
  1537. {
  1538.   struct peer *peer;
  1539.   struct listnode *nn;
  1541.   if (! group->conf->as)
  1542.     return 0;
  1544.   LIST_LOOP (group->peer, peer, nn)
  1545.     {
  1546.       peer->group = NULL;
  1547.       peer_delete (peer);
  1548.     }
  1549.   list_delete_all_node (group->peer);
  1551.   group->conf->as = 0;
  1553.   return 0;
  1554. }
  1556. /* Bind specified peer to peer group.  */
  1557. int
  1558. peer_group_bind (struct bgp *bgp, union sockunion *su,
  1559.  struct peer_group *group, afi_t afi, safi_t safi, as_t *as)
  1560. {
  1561.   struct peer *peer;
  1562.   int first_member = 0;
  1564.   /* Lookup the peer.  */
  1565.   peer = peer_lookup (bgp, su);
  1567.   /* Create a new peer. */
  1568.   if (! peer)
  1569.     {
  1570.       if (! group->conf->as)
  1571. return BGP_ERR_PEER_GROUP_NO_REMOTE_AS;
  1573.       peer = peer_create (su, bgp, bgp->as, group->conf->as, 0, 0);
  1574.       peer->group = group;
  1575.       listnode_add (group->peer, peer);
  1576.       peer_group_global_config_copy (group->conf, peer);
  1578.       if (bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4)
  1579.   && afi == AFI_IP && safi == SAFI_UNICAST)
  1580. return 0;
  1582.       return peer_activate (peer, afi, safi);
  1583.     }
  1585.   /* When the peer already belongs to peer group, check the consistency.  */
  1586.   if (peer_group_member (peer))
  1587.     {
  1588.       if (strcmp (peer->group->name, group->name) != 0)
  1589. return BGP_ERR_PEER_GROUP_CANT_CHANGE;
  1591.       return peer_activate (peer, afi, safi);
  1592.     }
  1594.   if (! group->conf->as)
  1595.     {
  1596.       if (peer_sort (group->conf) == BGP_PEER_INTERNAL)
  1597. first_member = 1;
  1598.       else if (peer_sort (group->conf) != peer_sort (peer))
  1599. {
  1600.   if (as)
  1601.     *as = peer->as;
  1602.   return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
  1603. }
  1604.     }
  1606.   peer->group = group;
  1607.   listnode_add (group->peer, peer);
  1609.   if (first_member)
  1610.     {
  1611.       /* Advertisement-interval reset */
  1612.       if (peer_sort (group->conf) == BGP_PEER_IBGP)
  1613. group->conf->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
  1614.       else
  1615. group->conf->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
  1617.       /* ebgp-multihop reset */
  1618.       if (peer_sort (group->conf) == BGP_PEER_IBGP)
  1619. group->conf->ttl = 255;
  1621.       /* local-as reset */
  1622.       if (peer_sort (group->conf) != BGP_PEER_EBGP)
  1623. {
  1624.   group->conf->change_local_as = 0;
  1625.   UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
  1626. }
  1627.     }
  1629.   peer_group_global_config_copy (group->conf, peer);
  1630.   peer_deactivate (peer, afi, safi);
  1631.   return peer_activate (peer, afi,safi);
  1632. }
  1634. /* Bind specified peer to peer group.  */
  1635. int
  1636. peer_group_bind2 (struct bgp *bgp, union sockunion *su,
  1637.  struct peer_group *group, afi_t afi, safi_t safi, as_t *as)
  1638. {
  1639.   struct peer *peer;
  1640.   int first_member = 0;
  1642.   /* Lookup the peer.  */
  1643.   peer = peer_lookup (bgp, su);
  1645.   /* Create a new peer. */
  1646.   if (! peer)
  1647.     {
  1648.       if (! group->conf->as)
  1649. return BGP_ERR_PEER_GROUP_NO_REMOTE_AS;
  1651.       if (bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4)
  1652.   && afi == AFI_IP && safi == SAFI_UNICAST)
  1653. {
  1654.   peer = peer_create (su, bgp, bgp->as, group->conf->as, 0, 0);
  1655.   peer->group = group;
  1656.   listnode_add (group->peer, peer);
  1657.   peer_group_global_config_copy (group->conf, peer);
  1658. }
  1659.       else
  1660. {
  1661.   peer = peer_create (su, bgp, bgp->as, group->conf->as, afi, safi);
  1662.   peer->group = group;
  1663.   listnode_add (group->peer, peer);
  1664.   peer_group_global_config_copy (group->conf, peer);
  1665.   peer_group_af_config_copy (group->conf, peer, afi, safi);
  1666.   peer_activate (group->conf, afi, safi);
  1667. }
  1668.       return 0;
  1669.     }
  1671.   /* When the peer already belongs to peer group, check the consistency.  */
  1672.   if (peer_group_member (peer))
  1673.     {
  1674.       if (strcmp (peer->group->name, group->name) != 0)
  1675. return BGP_ERR_PEER_GROUP_CANT_CHANGE;
  1677.       return peer_activate (peer, afi, safi);
  1678.     }
  1680.   if (! group->conf->as)
  1681.     {
  1682.       if (peer_sort (group->conf) == BGP_PEER_INTERNAL)
  1683. first_member = 1;
  1684.       else if (peer_sort (group->conf) != peer_sort (peer))
  1685. {
  1686.   if (as)
  1687.     *as = peer->as;
  1688.   return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
  1689. }
  1690.     }
  1692.   peer->group = group;
  1693.   listnode_add (group->peer, peer);
  1695.   if (first_member)
  1696.     {
  1697.       /* Advertisement-interval reset */
  1698.       if (peer_sort (group->conf) == BGP_PEER_IBGP)
  1699. group->conf->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
  1700.       else
  1701. group->conf->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
  1703.       /* ebgp-multihop reset */
  1704.       if (peer_sort (group->conf) == BGP_PEER_IBGP)
  1705. group->conf->ttl = 255;
  1707.       /* local-as reset */
  1708.       if (peer_sort (group->conf) != BGP_PEER_EBGP)
  1709. {
  1710.   group->conf->change_local_as = 0;
  1711.   UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
  1712. }
  1713.     }
  1715.   peer_group_global_config_copy (group->conf, peer);
  1716.   return peer_activate (peer, afi,safi);
  1717. }
  1719. int
  1720. peer_group_unbind (struct bgp *bgp, struct peer *peer,
  1721.    struct peer_group *group, afi_t afi, safi_t safi)
  1722. {
  1723.   if (! peer->afc[afi][safi])
  1724.       return 0;
  1726.   if (group != peer->group)
  1727.     return BGP_ERR_PEER_GROUP_MISMATCH;
  1729.   peer->afc[afi][safi] = 0;
  1730.   peer_af_flag_reset (peer, afi, safi);
  1732.   if (! peer_active (peer))
  1733.     {
  1734.       peer_delete (peer);
  1735.       return 0;
  1736.     }
  1738.   if (peer->status == Established)
  1739.     {
  1740.       peer->last_reset = PEER_DOWN_RMAP_UNBIND;
  1741.       bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  1742.        BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  1743.     }
  1744.   else
  1745.     BGP_EVENT_ADD (peer, BGP_Stop);
  1747.   return 0;
  1748. }
  1750. /* BGP instance creation by `router bgp' commands. */
  1751. struct bgp *
  1752. bgp_create (as_t *as, char *name)
  1753. {
  1754.   struct bgp *bgp;
  1755.   afi_t afi;
  1756.   safi_t safi;
  1758.   bgp = XCALLOC (MTYPE_BGP, sizeof (struct bgp));
  1760.   bgp->peer_self = peer_new ();
  1761.   bgp->peer_self->bgp = bgp;
  1762.   bgp->peer_self->host = strdup ("Static announcement");
  1764.   bgp->peer = list_new ();
  1765.   bgp->peer->cmp = (int (*)(void *, void *)) peer_cmp;
  1767.   bgp->group = list_new ();
  1768.   bgp->group->cmp = (int (*)(void *, void *)) peer_group_cmp;
  1770.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  1771.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  1772.       {
  1773. bgp->route[afi][safi] = bgp_table_init ();
  1774. bgp->aggregate[afi][safi] = bgp_table_init ();
  1775. bgp->rib[afi][safi] = bgp_table_init ();
  1776.       }
  1778.   bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
  1779.   bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
  1780.   bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
  1781.   bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
  1782.   bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
  1784.   bgp->as = *as;
  1786.   if (name)
  1787.     bgp->name = strdup (name);
  1789.   return bgp;
  1790. }
  1792. /* Return first entry of BGP. */
  1793. struct bgp *
  1794. bgp_get_default ()
  1795. {
  1796.   if (bm->bgp->head)
  1797.     return bm->bgp->head->data;
  1798.   return NULL;
  1799. }
  1801. /* Lookup BGP entry. */
  1802. struct bgp *
  1803. bgp_lookup (as_t as, char *name)
  1804. {
  1805.   struct bgp *bgp;
  1806.   struct listnode *nn;
  1808.   LIST_LOOP (bm->bgp, bgp, nn)
  1809.     if (bgp->as == as
  1810. && ((bgp->name == NULL && name == NULL) 
  1811.     || (bgp->name && name && strcmp (bgp->name, name) == 0)))
  1812.       return bgp;
  1813.   return NULL;
  1814. }
  1816. /* Lookup BGP structure by view name. */
  1817. struct bgp *
  1818. bgp_lookup_by_name (char *name)
  1819. {
  1820.   struct bgp *bgp;
  1821.   struct listnode *nn;
  1823.   LIST_LOOP (bm->bgp, bgp, nn)
  1824.     if ((bgp->name == NULL && name == NULL)
  1825. || (bgp->name && name && strcmp (bgp->name, name) == 0))
  1826.       return bgp;
  1827.   return NULL;
  1828. }
  1830. /* Called from VTY commands. */
  1831. int
  1832. bgp_get (struct bgp **bgp_val, as_t *as, char *name)
  1833. {
  1834.   struct bgp *bgp;
  1836.   /* Multiple instance check. */
  1837.   if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE))
  1838.     {
  1839.       if (name)
  1840. bgp = bgp_lookup_by_name (name);
  1841.       else
  1842. bgp = bgp_get_default ();
  1844.       /* Already exists. */
  1845.       if (bgp)
  1846. {
  1847.           if (bgp->as != *as)
  1848.     {
  1849.       *as = bgp->as;
  1850.       return BGP_ERR_INSTANCE_MISMATCH;
  1851.     }
  1852.   *bgp_val = bgp;
  1853.   return 0;
  1854. }
  1855.     }
  1856.   else
  1857.     {
  1858.       /* BGP instance name can not be specified for single instance.  */
  1859.       if (name)
  1860. return BGP_ERR_MULTIPLE_INSTANCE_NOT_SET;
  1862.       /* Get default BGP structure if exists. */
  1863.       bgp = bgp_get_default ();
  1865.       if (bgp)
  1866. {
  1867.   if (bgp->as != *as)
  1868.     {
  1869.       *as = bgp->as;
  1870.       return BGP_ERR_AS_MISMATCH;
  1871.     }
  1872.   *bgp_val = bgp;
  1873.   return 0;
  1874. }
  1875.     }
  1877.   bgp = bgp_create (as, name);
  1878.   listnode_add (bm->bgp, bgp);
  1879.   bgp_if_update_all ();
  1880.   *bgp_val = bgp;
  1882.   return 0;
  1883. }
  1885. /* Delete BGP instance. */
  1886. int
  1887. bgp_delete (struct bgp *bgp)
  1888. {
  1889.   struct peer *peer;
  1890.   struct peer_group *group;
  1891.   struct listnode *nn;
  1892.   struct listnode *next;
  1893.   afi_t afi;
  1894.   safi_t safi;
  1895.   int i;
  1897.   /* Delete static route. */
  1898.   bgp_static_delete (bgp);
  1900.   /* Unset redistribution. */
  1901.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  1902.     for (i = 0; i < ZEBRA_ROUTE_MAX; i++) 
  1903.       if (i != ZEBRA_ROUTE_BGP)
  1904. bgp_redistribute_unset (bgp, afi, i);
  1906.   for (nn = bgp->group->head; nn; nn = next)
  1907.     {
  1908.       group = nn->data;
  1909.       next = nn->next;
  1910.       peer_group_delete (group);
  1911.     }
  1913.   for (nn = bgp->peer->head; nn; nn = next)
  1914.     {
  1915.       peer = nn->data;
  1916.       next = nn->next;
  1917.       peer_delete (peer);
  1918.     }
  1920.   listnode_delete (bm->bgp, bgp);
  1922.   if (bgp->name)
  1923.     free (bgp->name);
  1924.   
  1925.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  1926.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  1927.       {
  1928. if (bgp->route[afi][safi])
  1929.   bgp_table_finish (bgp->route[afi][safi]);
  1930. if (bgp->aggregate[afi][safi])
  1931.   bgp_table_finish (bgp->aggregate[afi][safi]);
  1932. if (bgp->rib[afi][safi])
  1933.   bgp_table_finish (bgp->rib[afi][safi]);
  1934.      }
  1935.   peer_delete (bgp->peer_self);
  1936.   XFREE (MTYPE_BGP, bgp);
  1938.   return 0;
  1939. }
  1941. struct peer *
  1942. peer_lookup (struct bgp *bgp, union sockunion *su)
  1943. {
  1944.   struct peer *peer;
  1945.   struct listnode *nn;
  1947.   if (! bgp)
  1948.     bgp = bgp_get_default ();
  1950.   if (! bgp)
  1951.     return NULL;
  1952.   
  1953.   LIST_LOOP (bgp->peer, peer, nn)
  1954.     {
  1955.       if (sockunion_same (&peer->su, su)
  1956.   && ! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
  1957. return peer;
  1958.     }
  1959.   return NULL;
  1960. }
  1962. struct peer *
  1963. peer_lookup_with_open (union sockunion *su, as_t remote_as,
  1964.        struct in_addr *remote_id, int *as)
  1965. {
  1966.   struct peer *peer;
  1967.   struct listnode *nn;
  1968.   struct bgp *bgp;
  1970.   bgp = bgp_get_default ();
  1971.   if (! bgp)
  1972.     return NULL;
  1974.   LIST_LOOP (bgp->peer, peer, nn)
  1975.     {
  1976.       if (sockunion_same (&peer->su, su)
  1977.   && ! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
  1978. {
  1979.   if (peer->as == remote_as
  1980.       && peer->remote_id.s_addr == remote_id->s_addr)
  1981.     return peer;
  1982.   if (peer->as == remote_as)
  1983.     *as = 1;
  1984. }
  1985.     }
  1986.   LIST_LOOP (bgp->peer, peer, nn)
  1987.     {
  1988.       if (sockunion_same (&peer->su, su)
  1989.   &&  ! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
  1990. {
  1991.   if (peer->as == remote_as
  1992.       && peer->remote_id.s_addr == 0)
  1993.     return peer;
  1994.   if (peer->as == remote_as)
  1995.     *as = 1;
  1996. }
  1997.     }
  1998.   return NULL;
  1999. }
  2001. /* If peer is configured at least one address family return 1. */
  2002. int
  2003. peer_active (struct peer *peer)
  2004. {
  2005.   if (peer->afc[AFI_IP][SAFI_UNICAST]
  2006.       || peer->afc[AFI_IP][SAFI_MULTICAST]
  2007.       || peer->afc[AFI_IP][SAFI_MPLS_VPN]
  2008.       || peer->afc[AFI_IP6][SAFI_UNICAST]
  2009.       || peer->afc[AFI_IP6][SAFI_MULTICAST])
  2010.     return 1;
  2011.   return 0;
  2012. }
  2014. /* If peer is negotiated at least one address family return 1. */
  2015. int
  2016. peer_active_nego (struct peer *peer)
  2017. {
  2018.   if (peer->afc_nego[AFI_IP][SAFI_UNICAST]
  2019.       || peer->afc_nego[AFI_IP][SAFI_MULTICAST]
  2020.       || peer->afc_nego[AFI_IP][SAFI_MPLS_VPN]
  2021.       || peer->afc_nego[AFI_IP6][SAFI_UNICAST]
  2022.       || peer->afc_nego[AFI_IP6][SAFI_MULTICAST])
  2023.     return 1;
  2024.   return 0;
  2025. }
  2027. /* peer_flag_change_type. */
  2028. enum peer_change_type
  2029. {
  2030.   peer_change_none,
  2031.   peer_change_reset,
  2032.   peer_change_reset_in,
  2033.   peer_change_reset_out,
  2034. };
  2036. void
  2037. peer_change_action (struct peer *peer, afi_t afi, safi_t safi,
  2038.     enum peer_change_type type)
  2039. {
  2040.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2041.     return;
  2043.   if (type == peer_change_reset)
  2044.     bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2045.      BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  2046.   else if (type == peer_change_reset_in)
  2047.     {
  2048.       if (CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_OLD_RCV)
  2049.   || CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV))
  2050. bgp_route_refresh_send (peer, afi, safi, 0, 0, 0);
  2051.       else
  2052. bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2053.  BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  2054.     }
  2055.   else if (type == peer_change_reset_out)
  2056.     bgp_announce_route (peer, afi, safi);
  2057. }
  2059. struct peer_flag_action
  2060. {
  2061.   /* Peer's flag.  */
  2062.   u_int32_t flag;
  2064.   /* This flag can be set for peer-group member.  */
  2065.   u_char not_for_member;
  2067.   /* Action when the flag is changed.  */
  2068.   enum peer_change_type type;
  2070.   /* Peer down cause */
  2071.   u_char peer_down;
  2072. };
  2074. struct peer_flag_action peer_flag_action_list[] = 
  2075.   {
  2076.     { PEER_FLAG_CONNECT_MODE_PASSIVE,     0, peer_change_reset },
  2077.     { PEER_FLAG_CONNECT_MODE_ACTIVE,      0, peer_change_reset },
  2078.     { PEER_FLAG_SHUTDOWN,                 0, peer_change_reset },
  2079.     { PEER_FLAG_DONT_CAPABILITY,          0, peer_change_none },
  2080.     { PEER_FLAG_OVERRIDE_CAPABILITY,      0, peer_change_none },
  2081.     { PEER_FLAG_STRICT_CAP_MATCH,         0, peer_change_none },
  2082.     { PEER_FLAG_DYNAMIC_CAPABILITY,       0, peer_change_reset },
  2083.     { PEER_FLAG_DISABLE_CONNECTED_CHECK,  0, peer_change_reset },
  2084.     { 0, 0, 0 }
  2085.   };
  2087. struct peer_flag_action peer_af_flag_action_list[] = 
  2088.   {
  2089.     { PEER_FLAG_NEXTHOP_SELF,             1, peer_change_reset_out },
  2090.     { PEER_FLAG_SEND_COMMUNITY,           1, peer_change_reset_out },
  2091.     { PEER_FLAG_SEND_EXT_COMMUNITY,       1, peer_change_reset_out },
  2092.     { PEER_FLAG_SOFT_RECONFIG,            0, peer_change_reset_in },
  2093.     { PEER_FLAG_REFLECTOR_CLIENT,         1, peer_change_reset },
  2094.     { PEER_FLAG_RSERVER_CLIENT,           1, peer_change_reset },
  2095.     { PEER_FLAG_AS_PATH_UNCHANGED,        1, peer_change_reset_out },
  2096.     { PEER_FLAG_NEXTHOP_UNCHANGED,        1, peer_change_reset_out },
  2097.     { PEER_FLAG_MED_UNCHANGED,            1, peer_change_reset_out },
  2098.     { PEER_FLAG_REMOVE_PRIVATE_AS,        1, peer_change_reset_out },
  2099.     { PEER_FLAG_ALLOWAS_IN,               0, peer_change_reset_in },
  2100.     { PEER_FLAG_ORF_PREFIX_SM,            1, peer_change_reset },
  2101.     { PEER_FLAG_ORF_PREFIX_RM,            1, peer_change_reset },
  2102.     { 0, 0, 0 }
  2103.   };
  2105. /* Proper action set. */
  2106. int
  2107. peer_flag_action_set (struct peer_flag_action *action_list, int size,
  2108.       struct peer_flag_action *action, u_int32_t flag)
  2109. {
  2110.   int i;
  2111.   int found = 0;
  2112.   int reset_in = 0;
  2113.   int reset_out = 0;
  2114.   struct peer_flag_action *match = NULL;
  2116.   /* Check peer's frag action.  */
  2117.   for (i = 0; i < size; i++)
  2118.     {
  2119.       match = &action_list[i];
  2121.       if (match->flag == 0)
  2122. break;
  2124.       if (match->flag & flag)
  2125. {
  2126.   found = 1;
  2128.   if (match->type == peer_change_reset_in)
  2129.     reset_in = 1;
  2130.   if (match->type == peer_change_reset_out)
  2131.     reset_out = 1;
  2132.   if (match->type == peer_change_reset)
  2133.     {
  2134.       reset_in = 1;
  2135.       reset_out = 1;
  2136.     }
  2137.   if (match->not_for_member)
  2138.     action->not_for_member = 1;
  2139. }
  2140.     }
  2142.   /* Set peer clear type.  */
  2143.   if (reset_in && reset_out)
  2144.     action->type = peer_change_reset;
  2145.   else if (reset_in)
  2146.     action->type = peer_change_reset_in;
  2147.   else if (reset_out)
  2148.     action->type = peer_change_reset_out;
  2149.   else
  2150.     action->type = peer_change_none;
  2152.   return found;
  2153. }
  2155. void
  2156. peer_flag_modify_action (struct peer *peer, u_int32_t flag)
  2157. {
  2158.   if (flag == PEER_FLAG_SHUTDOWN)
  2159.     {
  2160.       if (CHECK_FLAG (peer->flags, flag))
  2161. {
  2162.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT))
  2163.     peer_nsf_stop (peer);
  2165.   UNSET_FLAG (peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
  2166.   if (peer->t_pmax_restart)
  2167.     {
  2168.       BGP_TIMER_OFF (peer->t_pmax_restart);
  2169.               if (BGP_DEBUG (events, EVENTS))
  2170. zlog_info ("%s Maximum-prefix restart timer canceled", peer->host);
  2171.     }
  2173.   if (peer->status == Established)
  2174.     bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2175.      BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN);
  2176.   else
  2177.     BGP_EVENT_ADD (peer, BGP_Stop);
  2178. }
  2179.       else
  2180. {
  2181.   BGP_EVENT_ADD (peer, BGP_Start);
  2182. }
  2183.     }
  2184.   else if (peer->status == Established)
  2185.     {
  2186.       if (flag == PEER_FLAG_DYNAMIC_CAPABILITY)
  2187. peer->last_reset = PEER_DOWN_CAPABILITY_CHANGE;
  2188.       else if (flag == PEER_FLAG_DISABLE_CONNECTED_CHECK)
  2189. peer->last_reset = PEER_DOWN_MULTIHOP_CHANGE;
  2191.       if (flag != PEER_FLAG_CONNECT_MODE_ACTIVE
  2192.   && flag != PEER_FLAG_CONNECT_MODE_PASSIVE)
  2193. bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2194.        BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  2195.     }
  2196.   else
  2197.     BGP_EVENT_ADD (peer, BGP_Stop);
  2198. }
  2200. /* Change specified peer flag. */
  2201. int
  2202. peer_flag_modify (struct peer *peer, u_int32_t flag, int set)
  2203. {
  2204.   int found;
  2205.   int size;
  2206.   struct peer_group *group;
  2207.   struct listnode *nn;
  2208.   struct peer_flag_action action;
  2210.   memset (&action, 0, sizeof (struct peer_flag_action));
  2211.   size = sizeof peer_flag_action_list / sizeof (struct peer_flag_action);
  2213.   found = peer_flag_action_set (peer_flag_action_list, size, &action, flag);
  2215.   /* No flag action is found.  */
  2216.   if (! found)
  2217.     return BGP_ERR_INVALID_FLAG;    
  2219.   /* Not for peer-group member.  */
  2220.   if (action.not_for_member && peer_group_member (peer))
  2221.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  2223.   /* When unset the peer-group member's flag we have to check
  2224.      peer-group configuration.  */
  2225.   if (! set && peer_group_member (peer))
  2226.     if (CHECK_FLAG (peer->group->conf->flags, flag))
  2227.       {
  2228. if (flag == PEER_FLAG_SHUTDOWN)
  2229.   return BGP_ERR_PEER_GROUP_SHUTDOWN;
  2230. else
  2231.   return BGP_ERR_PEER_GROUP_HAS_THE_FLAG;
  2232.       }
  2234.   /* Flag conflict check.  */
  2235.   if (set
  2236.       && CHECK_FLAG (peer->flags | flag, PEER_FLAG_STRICT_CAP_MATCH)
  2237.       && CHECK_FLAG (peer->flags | flag, PEER_FLAG_OVERRIDE_CAPABILITY))
  2238.     return BGP_ERR_PEER_FLAG_CONFLICT;
  2240.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2241.     {
  2242.       if (set && CHECK_FLAG (peer->flags, flag) == flag)
  2243. return 0;
  2244.       if (! set && ! CHECK_FLAG (peer->flags, flag))
  2245. return 0;
  2246.     }
  2248.   if (set)
  2249.     SET_FLAG (peer->flags, flag);
  2250.   else
  2251.     UNSET_FLAG (peer->flags, flag);
  2252.  
  2253.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2254.     {
  2255.       if (action.type == peer_change_reset)
  2256. peer_flag_modify_action (peer, flag);
  2258.       return 0;
  2259.     }
  2261.   /* peer-group member updates. */
  2262.   group = peer->group;
  2264.   LIST_LOOP (group->peer, peer, nn)
  2265.     {
  2266.       if (set && CHECK_FLAG (peer->flags, flag) == flag)
  2267. continue;
  2269.       if (! set && ! CHECK_FLAG (peer->flags, flag))
  2270. continue;
  2272.       if (set)
  2273. SET_FLAG (peer->flags, flag);
  2274.       else
  2275. UNSET_FLAG (peer->flags, flag);
  2277.       if (action.type == peer_change_reset)
  2278. peer_flag_modify_action (peer, flag);
  2279.     }
  2280.   return 0;
  2281. }
  2283. int
  2284. peer_flag_set (struct peer *peer, u_int32_t flag)
  2285. {
  2286.   return peer_flag_modify (peer, flag, 1);
  2287. }
  2289. int
  2290. peer_flag_unset (struct peer *peer, u_int32_t flag)
  2291. {
  2292.   return peer_flag_modify (peer, flag, 0);
  2293. }
  2295. int
  2296. peer_af_flag_modify (struct peer *peer, afi_t afi, safi_t safi, u_int32_t flag,
  2297.      int set)
  2298. {
  2299.   int found;
  2300.   int size;
  2301.   struct listnode *nn;
  2302.   struct peer_group *group;
  2303.   struct peer_flag_action action;
  2305.   memset (&action, 0, sizeof (struct peer_flag_action));
  2306.   size = sizeof peer_af_flag_action_list / sizeof (struct peer_flag_action);
  2307.   
  2308.   found = peer_flag_action_set (peer_af_flag_action_list, size, &action, flag);
  2309.   
  2310.   /* No flag action is found.  */
  2311.   if (! found)
  2312.     return BGP_ERR_INVALID_FLAG;    
  2314.   /* Adress family must be activated.  */
  2315.   if (! peer->afc[afi][safi])
  2316.     return BGP_ERR_PEER_INACTIVE;
  2318.   /* Not for peer-group member.  */
  2319.   if (action.not_for_member && peer_group_member (peer))
  2320.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  2322.  /* Spcecial check for reflector client.  */
  2323.   if (flag & PEER_FLAG_REFLECTOR_CLIENT
  2324.       && peer_sort (peer) != BGP_PEER_IBGP)
  2325.     return BGP_ERR_NOT_INTERNAL_PEER;
  2327.   /* Spcecial check for remove-private-AS.  */
  2328.   if (flag & PEER_FLAG_REMOVE_PRIVATE_AS
  2329.       && peer_sort (peer) == BGP_PEER_IBGP)
  2330.     return BGP_ERR_REMOVE_PRIVATE_AS;
  2332.   /* When unset the peer-group member's flag we have to check
  2333.      peer-group configuration.  */
  2334.   if (! set && peer_group_member(peer))
  2335.     if (CHECK_FLAG (peer->group->conf->af_flags[afi][safi], flag))
  2336.       return BGP_ERR_PEER_GROUP_HAS_THE_FLAG;
  2338.   /* When current flag configuration is same as requested one.  */
  2339.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2340.     {
  2341.       if (set && CHECK_FLAG (peer->af_flags[afi][safi], flag) == flag)
  2342. return 0;
  2343.       if (! set && ! CHECK_FLAG (peer->af_flags[afi][safi], flag))
  2344. return 0;
  2345.     }
  2347.   if (set)
  2348.     SET_FLAG (peer->af_flags[afi][safi], flag);
  2349.   else
  2350.     UNSET_FLAG (peer->af_flags[afi][safi], flag);
  2352.   /* Execute action when peer is established.  */
  2353.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP)
  2354.       && peer->status == Established)
  2355.     {
  2356.       if (! set && flag == PEER_FLAG_SOFT_RECONFIG)
  2357. bgp_clear_adj_in (peer, afi, safi);
  2358.       else
  2359. {
  2360.   if (flag == PEER_FLAG_REFLECTOR_CLIENT)
  2361.     peer->last_reset = PEER_DOWN_RR_CLIENT_CHANGE;
  2362.   else if (flag == PEER_FLAG_RSERVER_CLIENT)
  2363.     peer->last_reset = PEER_DOWN_RS_CLIENT_CHANGE;
  2364.   else if (flag == PEER_FLAG_ORF_PREFIX_SM)
  2365.     peer->last_reset = PEER_DOWN_CAPABILITY_CHANGE;
  2366.   else if (flag == PEER_FLAG_ORF_PREFIX_RM)
  2367.     peer->last_reset = PEER_DOWN_CAPABILITY_CHANGE;
  2369.     peer_change_action (peer, afi, safi, action.type);
  2370. }
  2371.     }
  2373.   /* Peer group member updates.  */
  2374.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2375.     {
  2376.       group = peer->group;
  2377.       
  2378.       LIST_LOOP (group->peer, peer, nn)
  2379. {
  2380.   if (! peer->afc[afi][safi])
  2381.     continue;
  2383.   if (set && CHECK_FLAG (peer->af_flags[afi][safi], flag) == flag)
  2384.     continue;
  2386.   if (! set && ! CHECK_FLAG (peer->af_flags[afi][safi], flag))
  2387.     continue;
  2389.   if (set)
  2390.     SET_FLAG (peer->af_flags[afi][safi], flag);
  2391.   else
  2392.     UNSET_FLAG (peer->af_flags[afi][safi], flag);
  2394.   if (peer->status == Established)
  2395.     {
  2396.       if (! set && flag == PEER_FLAG_SOFT_RECONFIG)
  2397. bgp_clear_adj_in (peer, afi, safi);
  2398.       else
  2399. {
  2400.   if (flag == PEER_FLAG_REFLECTOR_CLIENT)
  2401.     peer->last_reset = PEER_DOWN_RR_CLIENT_CHANGE;
  2402.   else if (flag == PEER_FLAG_RSERVER_CLIENT)
  2403.     peer->last_reset = PEER_DOWN_RS_CLIENT_CHANGE;
  2404.   else if (flag == PEER_FLAG_ORF_PREFIX_SM)
  2405.     peer->last_reset = PEER_DOWN_CAPABILITY_CHANGE;
  2406.   else if (flag == PEER_FLAG_ORF_PREFIX_RM)
  2407.     peer->last_reset = PEER_DOWN_CAPABILITY_CHANGE;
  2409.   peer_change_action (peer, afi, safi, action.type);
  2410. }
  2411.     }
  2412. }
  2413.     }
  2414.   return 0;
  2415. }
  2417. int
  2418. peer_af_flag_set (struct peer *peer, afi_t afi, safi_t safi, u_int32_t flag)
  2419. {
  2420.   return peer_af_flag_modify (peer, afi, safi, flag, 1);
  2421. }
  2423. int
  2424. peer_af_flag_unset (struct peer *peer, afi_t afi, safi_t safi, u_int32_t flag)
  2425. {
  2426.   return peer_af_flag_modify (peer, afi, safi, flag, 0);
  2427. }
  2429. /* EBGP multihop configuration. */
  2430. int
  2431. peer_ebgp_multihop_set (struct peer *peer, int ttl)
  2432. {
  2433.   struct peer_group *group;
  2434.   struct listnode *nn;
  2436.   if (peer_sort (peer) == BGP_PEER_IBGP)
  2437.     return 0;
  2439.   peer->ttl = ttl;
  2441.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2442.     {
  2443.       if (peer->fd >= 0 && peer_sort (peer) != BGP_PEER_IBGP)
  2444. sockopt_ttl (peer->su.sa.sa_family, peer->fd, peer->ttl);
  2445.     }
  2446.   else
  2447.     {
  2448.       group = peer->group;
  2449.       LIST_LOOP (group->peer, peer, nn)
  2450. {
  2451.   if (peer_sort (peer) == BGP_PEER_IBGP)
  2452.     continue;
  2454.   peer->ttl = group->conf->ttl;
  2456.   if (peer->fd >= 0)
  2457.     sockopt_ttl (peer->su.sa.sa_family, peer->fd, peer->ttl);
  2458. }
  2459.     }
  2460.   return 0;
  2461. }
  2463. int
  2464. peer_ebgp_multihop_unset (struct peer *peer)
  2465. {
  2466.   struct peer_group *group;
  2467.   struct listnode *nn;
  2469.   if (peer_sort (peer) == BGP_PEER_IBGP)
  2470.     return 0;
  2472.   if (peer_group_member (peer))
  2473.     peer->ttl = peer->group->conf->ttl;
  2474.   else
  2475.     peer->ttl = 1;
  2477.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2478.     {
  2479.       if (peer->fd >= 0 && peer_sort (peer) != BGP_PEER_IBGP)
  2480. sockopt_ttl (peer->su.sa.sa_family, peer->fd, peer->ttl);
  2481.     }
  2482.   else
  2483.     {
  2484.       group = peer->group;
  2485.       LIST_LOOP (group->peer, peer, nn)
  2486. {
  2487.   if (peer_sort (peer) == BGP_PEER_IBGP)
  2488.     continue;
  2490.   peer->ttl = 1;
  2491.   
  2492.   if (peer->fd >= 0)
  2493.     sockopt_ttl (peer->su.sa.sa_family, peer->fd, peer->ttl);
  2494. }
  2495.     }
  2496.   return 0;
  2497. }
  2499. /* Neighbor description. */
  2500. int
  2501. peer_description_set (struct peer *peer, char *desc)
  2502. {
  2503.   if (peer->desc)
  2504.     XFREE (MTYPE_PEER_DESC, peer->desc);
  2506.   peer->desc = XSTRDUP (MTYPE_PEER_DESC, desc);
  2508.   return 0;
  2509. }
  2511. int
  2512. peer_description_unset (struct peer *peer)
  2513. {
  2514.   if (peer->desc)
  2515.     XFREE (MTYPE_PEER_DESC, peer->desc);
  2517.   peer->desc = NULL;
  2519.   return 0;
  2520. }
  2522. /* Neighbor update-source. */
  2523. int
  2524. peer_update_source_if_set (struct peer *peer, char *ifname)
  2525. {
  2526.   struct peer_group *group;
  2527.   struct listnode *nn;
  2529.   if (peer->update_if)
  2530.     {
  2531.       if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP)
  2532.   && strcmp (peer->update_if, ifname) == 0)
  2533. return 0;
  2535.       XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
  2536.       peer->update_if = NULL;
  2537.     }
  2539.   if (peer->update_source)
  2540.     {
  2541.       sockunion_free (peer->update_source);
  2542.       peer->update_source = NULL;
  2543.     }
  2545.   peer->update_if = XSTRDUP (MTYPE_PEER_UPDATE_SOURCE, ifname);
  2547.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2548.     {
  2549.       if (peer->status == Established)
  2550. {
  2551.   peer->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
  2552.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2553.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  2554. }
  2555.       else
  2556. BGP_EVENT_ADD (peer, BGP_Stop);
  2557.       return 0;
  2558.     }
  2560.   /* peer-group member updates. */
  2561.   group = peer->group;
  2562.   LIST_LOOP (group->peer, peer, nn)
  2563.     {
  2564.       if (peer->update_if)
  2565. {
  2566.   if (strcmp (peer->update_if, ifname) == 0)
  2567.     continue;
  2569.   XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
  2570.   peer->update_if = NULL;
  2571. }
  2573.       if (peer->update_source)
  2574. {
  2575.   sockunion_free (peer->update_source);
  2576.   peer->update_source = NULL;
  2577. }
  2579.       peer->update_if = XSTRDUP (MTYPE_PEER_UPDATE_SOURCE, ifname);
  2581.       if (peer->status == Established)
  2582. {
  2583.   peer->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
  2584.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2585.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  2586. }
  2587.       else
  2588. BGP_EVENT_ADD (peer, BGP_Stop);
  2589.     }
  2590.   return 0;
  2591. }
  2593. int
  2594. peer_update_source_addr_set (struct peer *peer, union sockunion *su)
  2595. {
  2596.   struct peer_group *group;
  2597.   struct listnode *nn;
  2599. #ifdef HAVE_OPENBSD_TCP_SIGNATURE
  2600.   if (peer->password)
  2601.     bgp_tcpsig_unset (bm->sock, peer);
  2602. #endif /* HAVE_OPENBSD_TCP_SIGNATURE */
  2604.   if (peer->update_source)
  2605.     {
  2606.       if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP)
  2607.   && sockunion_cmp (peer->update_source, su) == 0)
  2608. return 0;
  2609.       sockunion_free (peer->update_source);
  2610.       peer->update_source = NULL;
  2611.     }
  2613.   if (peer->update_if)
  2614.     {
  2615.       XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
  2616.       peer->update_if = NULL;
  2617.     }
  2619. #ifdef HAVE_OPENBSD_TCP_SIGNATURE
  2620.   if (peer->password)
  2621.     bgp_tcpsig_set (bm->sock, peer);
  2622. #endif /* HAVE_OPENBSD_TCP_SIGNATURE */
  2624.   peer->update_source = sockunion_dup (su);
  2626.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2627.     {
  2628.       if (peer->status == Established)
  2629. {
  2630.   peer->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
  2631.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2632.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  2633. }
  2634.       else
  2635. BGP_EVENT_ADD (peer, BGP_Stop);
  2636.       return 0;
  2637.     }
  2639.   /* peer-group member updates. */
  2640.   group = peer->group;
  2641.   LIST_LOOP (group->peer, peer, nn)
  2642.     {
  2643. #ifdef HAVE_OPENBSD_TCP_SIGNATURE
  2644.       if (peer->password)
  2645. bgp_tcpsig_unset (bm->sock, peer);
  2646. #endif /* HAVE_OPENBSD_TCP_SIGNATURE */
  2648.       if (peer->update_source)
  2649. {
  2650.   if (sockunion_cmp (peer->update_source, su) == 0)
  2651.     continue;
  2652.   sockunion_free (peer->update_source);
  2653.   peer->update_source = NULL;
  2654. }
  2656.       if (peer->update_if)
  2657. {
  2658.   XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
  2659.   peer->update_if = NULL;
  2660. }
  2662.       peer->update_source = sockunion_dup (su);
  2664. #ifdef HAVE_OPENBSD_TCP_SIGNATURE
  2665.       if (peer->password)
  2666. bgp_tcpsig_set (bm->sock, peer);
  2667. #endif /* HAVE_OPENBSD_TCP_SIGNATURE */
  2669.       if (peer->status == Established)
  2670. {
  2671.   peer->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
  2672.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2673.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  2674. }
  2675.       else
  2676. BGP_EVENT_ADD (peer, BGP_Stop);
  2677.     }
  2678.   return 0;
  2679. }
  2681. int
  2682. peer_update_source_unset (struct peer *peer)
  2683. {
  2684.   union sockunion *su;
  2685.   struct peer_group *group;
  2686.   struct listnode *nn;
  2688.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP)
  2689.       && ! peer->update_source
  2690.       && ! peer->update_if)
  2691.     return 0;
  2693. #ifdef HAVE_OPENBSD_TCP_SIGNATURE
  2694.   if (peer->password)
  2695.     bgp_tcpsig_unset (bm->sock, peer);
  2696. #endif /* HAVE_OPENBSD_TCP_SIGNATURE */
  2698.   if (peer->update_source)
  2699.     {
  2700.       sockunion_free (peer->update_source);
  2701.       peer->update_source = NULL;
  2702.     }
  2703.   if (peer->update_if)
  2704.     {
  2705.       XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
  2706.       peer->update_if = NULL;
  2707.     }
  2709.   if (peer_group_member (peer))
  2710.     {
  2711.       group = peer->group;
  2713.       if (group->conf->update_source)
  2714. {
  2715.   su = sockunion_dup (group->conf->update_source);
  2716.   peer->update_source = su;
  2717. }
  2718.       else if (group->conf->update_if)
  2719. peer->update_if = 
  2720.   XSTRDUP (MTYPE_PEER_UPDATE_SOURCE, group->conf->update_if);
  2721.     }
  2723.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2724.     {
  2725.       if (peer->status == Established)
  2726. {
  2727.   peer->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
  2728.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2729.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  2730. }
  2731.       else
  2732. BGP_EVENT_ADD (peer, BGP_Stop);
  2733.       return 0;
  2734.     }
  2736.   /* peer-group member updates. */
  2737.   group = peer->group;
  2738.   LIST_LOOP (group->peer, peer, nn)
  2739.     {
  2740.       if (! peer->update_source && ! peer->update_if)
  2741. continue;
  2743. #ifdef HAVE_OPENBSD_TCP_SIGNATURE
  2744.       if (peer->password)
  2745. bgp_tcpsig_set (bm->sock, peer);
  2746. #endif /* HAVE_OPENBSD_TCP_SIGNATURE */
  2748.       if (peer->update_source)
  2749. {
  2750.   sockunion_free (peer->update_source);
  2751.   peer->update_source = NULL;
  2752. }
  2754.       if (peer->update_if)
  2755. {
  2756.   XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
  2757.   peer->update_if = NULL;
  2758. }
  2760.       if (peer->status == Established)
  2761. {
  2762.   peer->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
  2763.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  2764.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  2765. }
  2766.       else
  2767. BGP_EVENT_ADD (peer, BGP_Stop);
  2768.     }
  2769.   return 0;
  2770. }
  2772. int
  2773. peer_default_originate_set (struct peer *peer, afi_t afi, safi_t safi,
  2774.     char *rmap)
  2775. {
  2776.   struct peer_group *group;
  2777.   struct listnode *nn;
  2779.   /* Adress family must be activated.  */
  2780.   if (! peer->afc[afi][safi])
  2781.     return BGP_ERR_PEER_INACTIVE;
  2783.   /* Default originate can't be used for peer group memeber.  */
  2784.   if (peer_group_member (peer))
  2785.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  2787.   if (! CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE)
  2788.       || (rmap && ! peer->default_rmap[afi][safi].name)
  2789.       || (rmap && strcmp (rmap, peer->default_rmap[afi][safi].name) != 0))
  2790.     { 
  2791.       SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
  2793.       if (rmap)
  2794. {
  2795.   if (peer->default_rmap[afi][safi].name)
  2796.     free (peer->default_rmap[afi][safi].name);
  2797.   peer->default_rmap[afi][safi].name = strdup (rmap);
  2798.   peer->default_rmap[afi][safi].map = route_map_lookup_by_name (rmap);
  2799. }
  2800.     }
  2802.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2803.     {
  2804.       if (peer->status == Established && peer->afc_nego[afi][safi])
  2805. bgp_default_originate (peer, afi, safi, 0);
  2806.       return 0;
  2807.     }
  2809.   /* peer-group member updates. */
  2810.   group = peer->group;
  2811.   LIST_LOOP (group->peer, peer, nn)
  2812.     {
  2813.       SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
  2815.       if (rmap)
  2816. {
  2817.   if (peer->default_rmap[afi][safi].name)
  2818.     free (peer->default_rmap[afi][safi].name);
  2819.   peer->default_rmap[afi][safi].name = strdup (rmap);
  2820.   peer->default_rmap[afi][safi].map = route_map_lookup_by_name (rmap);
  2821. }
  2823.       if (peer->status == Established && peer->afc_nego[afi][safi])
  2824. bgp_default_originate (peer, afi, safi, 0);
  2825.     }
  2826.   return 0;
  2827. }
  2829. int
  2830. peer_default_originate_unset (struct peer *peer, afi_t afi, safi_t safi)
  2831. {
  2832.   struct peer_group *group;
  2833.   struct listnode *nn;
  2835.   /* Adress family must be activated.  */
  2836.   if (! peer->afc[afi][safi])
  2837.     return BGP_ERR_PEER_INACTIVE;
  2839.   /* Default originate can't be used for peer group memeber.  */
  2840.   if (peer_group_member (peer))
  2841.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  2843.   if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE))
  2844.     { 
  2845.       UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
  2847.       if (peer->default_rmap[afi][safi].name)
  2848. free (peer->default_rmap[afi][safi].name);
  2849.       peer->default_rmap[afi][safi].name = NULL;
  2850.       peer->default_rmap[afi][safi].map = NULL;
  2851.     }
  2853.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2854.     {
  2855.       if (peer->status == Established && peer->afc_nego[afi][safi])
  2856. bgp_default_originate (peer, afi, safi, 1);
  2857.       return 0;
  2858.     }
  2860.   /* peer-group member updates. */
  2861.   group = peer->group;
  2862.   LIST_LOOP (group->peer, peer, nn)
  2863.     {
  2864.       UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
  2866.       if (peer->default_rmap[afi][safi].name)
  2867. free (peer->default_rmap[afi][safi].name);
  2868.       peer->default_rmap[afi][safi].name = NULL;
  2869.       peer->default_rmap[afi][safi].map = NULL;
  2871.       if (peer->status == Established && peer->afc_nego[afi][safi])
  2872. bgp_default_originate (peer, afi, safi, 1);
  2873.     }
  2874.   return 0;
  2875. }
  2877. int
  2878. peer_port_set (struct peer *peer, u_int16_t port)
  2879. {
  2880.   peer->port = port;
  2881.   return 0;
  2882. }
  2884. int
  2885. peer_port_unset (struct peer *peer)
  2886. {
  2887.   peer->port = BGP_PORT_DEFAULT;
  2888.   return 0;
  2889. }
  2891. /* neighbor weight. */
  2892. int
  2893. peer_weight_set (struct peer *peer, u_int16_t weight, afi_t afi, safi_t safi)
  2894. {
  2895.   struct peer_group *group;
  2896.   struct listnode *nn;
  2898.   if (CHECK_FLAG (peer->af_config[afi][safi], PEER_AF_CONFIG_WEIGHT)
  2899.       && peer->weight[afi][safi] == weight)
  2900.     return 0;
  2902.   SET_FLAG (peer->af_config[afi][safi], PEER_AF_CONFIG_WEIGHT);
  2903.   peer->weight[afi][safi] = weight;
  2905.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2906.     {
  2907.       group = peer->group;
  2908.       LIST_LOOP (group->peer, peer, nn)
  2909. {
  2910.   SET_FLAG (peer->af_config[afi][safi], PEER_AF_CONFIG_WEIGHT);
  2911.   peer->weight[afi][safi] = weight;
  2912.   peer_clear_soft (peer, afi, safi, BGP_CLEAR_SOFT_IN);
  2913. }
  2914.     }
  2915.   else
  2916.     peer_clear_soft (peer, afi, safi, BGP_CLEAR_SOFT_IN);
  2918.   return 0;
  2919. }
  2921. int
  2922. peer_weight_unset (struct peer *peer, afi_t afi, safi_t safi)
  2923. {
  2924.   struct peer_group *group;
  2925.   struct listnode *nn;
  2927.   if (! CHECK_FLAG (peer->af_config[afi][safi], PEER_AF_CONFIG_WEIGHT))
  2928.     return 0;
  2930.   if (peer_group_member (peer)
  2931.       && CHECK_FLAG (peer->group->conf->af_config[afi][safi], PEER_AF_CONFIG_WEIGHT))
  2932.     {
  2933.       peer->weight[afi][safi] = peer->group->conf->weight[afi][safi];
  2934.     }
  2935.   else
  2936.     {
  2937.       UNSET_FLAG (peer->af_config[afi][safi], PEER_AF_CONFIG_WEIGHT);
  2938.       peer->weight[afi][safi] = 0;
  2939.     }
  2941.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2942.     {
  2943.       group = peer->group;
  2944.       LIST_LOOP (group->peer, peer, nn)
  2945. {
  2946.   UNSET_FLAG (peer->af_config[afi][safi], PEER_AF_CONFIG_WEIGHT);
  2947.   peer->weight[afi][safi] = 0;
  2948.   peer_clear_soft (peer, afi, safi, BGP_CLEAR_SOFT_IN);
  2949. }
  2950.     } 
  2951.   else
  2952.     peer_clear_soft (peer, afi, safi, BGP_CLEAR_SOFT_IN);
  2954.   return 0;
  2955. }
  2957. int
  2958. peer_timers_set (struct peer *peer, u_int32_t keepalive, u_int32_t holdtime)
  2959. {
  2960.   struct peer_group *group;
  2961.   struct listnode *nn;
  2963.   /* Not for peer group memeber.  */
  2964.   if (peer_group_member (peer))
  2965.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  2967.   /* keepalive value check.  */
  2968.   if (keepalive > 65535)
  2969.     return BGP_ERR_INVALID_VALUE;
  2971.   /* Holdtime value check.  */
  2972.   if (holdtime > 65535)
  2973.     return BGP_ERR_INVALID_VALUE;
  2975.   /* Holdtime value must be either 0 or greater than 3.  */
  2976.   if (holdtime < 3 && holdtime != 0)
  2977.     return BGP_ERR_INVALID_VALUE;
  2979.   /* Set value to the configuration. */
  2980.   SET_FLAG (peer->config, PEER_CONFIG_TIMER);
  2981.   peer->holdtime = holdtime;
  2982.   peer->keepalive = (keepalive < holdtime / 3 ? keepalive : holdtime / 3);
  2984.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  2985.     return 0;
  2987.   /* peer-group member updates. */
  2988.   group = peer->group;
  2989.   LIST_LOOP (group->peer, peer, nn)
  2990.     {
  2991.       SET_FLAG (peer->config, PEER_CONFIG_TIMER);
  2992.       peer->holdtime = group->conf->holdtime;
  2993.       peer->keepalive = group->conf->keepalive;
  2994.     }
  2995.   return 0;
  2996. }
  2998. int
  2999. peer_timers_unset (struct peer *peer)
  3000. {
  3001.   struct peer_group *group;
  3002.   struct listnode *nn;
  3004.   if (peer_group_member (peer))
  3005.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3007.   /* Clear configuration. */
  3008.   UNSET_FLAG (peer->config, PEER_CONFIG_TIMER);
  3009.   peer->keepalive = 0;
  3010.   peer->holdtime = 0;
  3012.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3013.     return 0;
  3015.   /* peer-group member updates. */
  3016.   group = peer->group;
  3017.   LIST_LOOP (group->peer, peer, nn)
  3018.     {
  3019.       UNSET_FLAG (peer->config, PEER_CONFIG_TIMER);
  3020.       peer->holdtime = 0;
  3021.       peer->keepalive = 0;
  3022.     }
  3024.   return 0;
  3025. }
  3027. int
  3028. peer_advertise_interval_set (struct peer *peer, u_int32_t routeadv)
  3029. {
  3030.   if (peer_group_member (peer))
  3031.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3033.   if (routeadv > 600)
  3034.     return BGP_ERR_INVALID_VALUE;
  3036.   SET_FLAG (peer->config, PEER_CONFIG_ROUTEADV);
  3037.   peer->routeadv = routeadv;
  3038.   peer->v_routeadv = routeadv;
  3040.   return 0;
  3041. }
  3043. int
  3044. peer_advertise_interval_unset (struct peer *peer)
  3045. {
  3046.   if (peer_group_member (peer))
  3047.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3049.   UNSET_FLAG (peer->config, PEER_CONFIG_ROUTEADV);
  3050.   peer->routeadv = 0;
  3052.   if (peer_sort (peer) == BGP_PEER_IBGP)
  3053.     peer->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
  3054.   else
  3055.     peer->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
  3056.   
  3057.   return 0;
  3058. }
  3060. /* neighbor interface */
  3061. int
  3062. peer_interface_set (struct peer *peer, char *str)
  3063. {
  3064.   if (peer->ifname)
  3065.     free (peer->ifname);
  3066.   peer->ifname = strdup (str);
  3068.   return 0;
  3069. }
  3071. int
  3072. peer_interface_unset (struct peer *peer)
  3073. {
  3074.   if (peer->ifname)
  3075.     free (peer->ifname);
  3076.   peer->ifname = NULL;
  3078.   return 0;
  3079. }
  3081. /* Allow-as in.  */
  3082. int
  3083. peer_allowas_in_set (struct peer *peer, afi_t afi, safi_t safi, int allow_num)
  3084. {
  3085.   struct peer_group *group;
  3086.   struct listnode *nn;
  3088.   if (allow_num < 1 || allow_num > 10)
  3089.     return BGP_ERR_INVALID_VALUE;
  3091.   if (peer->allowas_in[afi][safi] != allow_num)
  3092.     {
  3093.       peer->allowas_in[afi][safi] = allow_num;
  3094.       SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN);
  3095.       peer_change_action (peer, afi, safi, peer_change_reset_in);
  3096.     }
  3098.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3099.     return 0;
  3101.   group = peer->group;
  3102.   LIST_LOOP (group->peer, peer, nn)
  3103.     {
  3104.       if (peer->allowas_in[afi][safi] != allow_num)
  3105. {
  3106.   peer->allowas_in[afi][safi] = allow_num;
  3107.   SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN);
  3108.   peer_change_action (peer, afi, safi, peer_change_reset_in);
  3109. }
  3110.   
  3111.     }
  3112.   return 0;
  3113. }
  3115. int
  3116. peer_allowas_in_unset (struct peer *peer, afi_t afi, safi_t safi)
  3117. {
  3118.   struct peer_group *group;
  3119.   struct listnode *nn;
  3121.   if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN))
  3122.     {
  3123.       peer->allowas_in[afi][safi] = 0;
  3124.       peer_af_flag_unset (peer, afi, safi, PEER_FLAG_ALLOWAS_IN);
  3125.     }
  3127.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3128.     return 0;
  3130.   group = peer->group;
  3131.   LIST_LOOP (group->peer, peer, nn)
  3132.     {
  3133.       if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN))
  3134. {
  3135.   peer->allowas_in[afi][safi] = 0;
  3136.   peer_af_flag_unset (peer, afi, safi, PEER_FLAG_ALLOWAS_IN);
  3137. }
  3138.     }
  3139.   return 0;
  3140. }
  3142. int
  3143. peer_local_as_set (struct peer *peer, as_t as, int no_prepend)
  3144. {
  3145.   struct bgp *bgp = peer->bgp;
  3146.   struct peer_group *group;
  3147.   struct listnode *nn;
  3149.   if (peer_sort (peer) != BGP_PEER_EBGP
  3150.       && peer_sort (peer) != BGP_PEER_INTERNAL)
  3151.     return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP;
  3153.   if (bgp->as == as)
  3154.     return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS;
  3156.   if (peer_group_member (peer))
  3157.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3159.   if (peer->change_local_as == as &&
  3160.       ((CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND) && no_prepend)
  3161.        || (! CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND) && ! no_prepend)))
  3162.     return 0;
  3164.   peer->change_local_as = as;
  3165.   if (no_prepend)
  3166.     SET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
  3167.   else
  3168.     UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
  3170.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3171.     {
  3172.       if (peer->status == Established)
  3173. {
  3174.   peer->last_reset = PEER_DOWN_LOCAL_AS_CHANGE;
  3175.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  3176.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  3177. }
  3178.       else
  3179.         BGP_EVENT_ADD (peer, BGP_Stop);
  3181.       return 0;
  3182.     }
  3184.   group = peer->group;
  3185.   LIST_LOOP (group->peer, peer, nn)
  3186.     {
  3187.       peer->change_local_as = as;
  3188.       if (no_prepend)
  3189. SET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
  3190.       else
  3191. UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
  3193.       if (peer->status == Established)
  3194. {
  3195.   peer->last_reset = PEER_DOWN_LOCAL_AS_CHANGE;
  3196.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  3197.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  3198. }
  3199.       else
  3200.         BGP_EVENT_ADD (peer, BGP_Stop);
  3201.     }
  3203.   return 0;
  3204. }
  3206. int
  3207. peer_local_as_unset (struct peer *peer)
  3208. {
  3209.   struct peer_group *group;
  3210.   struct listnode *nn;
  3212.   if (peer_group_member (peer))
  3213.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3215.   if (! peer->change_local_as)
  3216.     return 0;
  3218.   peer->change_local_as = 0;
  3219.   UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
  3221.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3222.     {
  3223.       if (peer->status == Established)
  3224. {
  3225.   peer->last_reset = PEER_DOWN_LOCAL_AS_CHANGE;
  3226.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  3227.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  3228. }
  3229.       else
  3230.         BGP_EVENT_ADD (peer, BGP_Stop);
  3232.       return 0;
  3233.     }
  3235.   group = peer->group;
  3236.   LIST_LOOP (group->peer, peer, nn)
  3237.     {
  3238.       peer->change_local_as = 0;
  3239.       UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
  3241.       if (peer->status == Established)
  3242. {
  3243.   peer->last_reset = PEER_DOWN_LOCAL_AS_CHANGE;
  3244.   bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  3245.    BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  3246. }
  3247.       else
  3248.         BGP_EVENT_ADD (peer, BGP_Stop);
  3249.     }
  3250.   return 0;
  3251. }
  3253. #ifdef HAVE_TCP_SIGNATURE
  3254. /* Set password for authenticating with the peer. */
  3255. int
  3256. peer_password_set (struct peer *peer, char *password)
  3257. {
  3258.   struct peer_group *group;
  3259.   struct listnode *nn;
  3261.   if (peer->password && strcmp (peer->password, password) == 0
  3262.       && ! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3263. return 0;
  3265.   SET_FLAG (peer->flags, PEER_FLAG_PASSWORD);
  3266.   if (peer->password)
  3267.     free (peer->password);
  3268.   peer->password = strdup (password);
  3270.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3271.     {
  3272.       if (peer->status == Established)
  3273.         {
  3274.           peer->last_reset = PEER_DOWN_PASSWORD_CHANGE;
  3275.           bgp_notify_send (peer, BGP_NOTIFY_CEASE, BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  3276.         }
  3277.       else
  3278.         BGP_EVENT_ADD (peer, BGP_Stop);
  3280.       bgp_tcpsig_set (bm->sock, peer);
  3281.       return 0;
  3282.     }
  3284.   group = peer->group;
  3285.   LIST_LOOP (group->peer, peer, nn)
  3286.     {
  3287.       if (peer->password && strcmp (peer->password, password) == 0)
  3288. continue;
  3290.       SET_FLAG (peer->flags, PEER_FLAG_PASSWORD);
  3291.       if (peer->password)
  3292.         free (peer->password);
  3293.       peer->password = strdup (password);
  3295.       if (peer->status == Established)
  3296.         {
  3297.           peer->last_reset = PEER_DOWN_PASSWORD_CHANGE;
  3298.           bgp_notify_send (peer, BGP_NOTIFY_CEASE, BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  3299.         }
  3300.       else
  3301.         BGP_EVENT_ADD (peer, BGP_Stop);
  3303.       bgp_tcpsig_set (bm->sock, peer);
  3304.     }
  3306.   return 0;
  3307. }
  3309. int
  3310. peer_password_unset (struct peer *peer)
  3311. {
  3312.   struct peer_group *group;
  3313.   struct listnode *nn;
  3315.   if (! CHECK_FLAG (peer->flags, PEER_FLAG_PASSWORD)
  3316.       && ! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3317.     return 0;
  3319.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3320.     {
  3321.       if (peer_group_member (peer)
  3322.   && CHECK_FLAG (peer->group->conf->flags, PEER_FLAG_PASSWORD))
  3323. return BGP_ERR_PEER_GROUP_HAS_THE_FLAG;
  3325.       if (peer->status == Established)
  3326.         {
  3327.           peer->last_reset = PEER_DOWN_PASSWORD_CHANGE;
  3328.           bgp_notify_send (peer, BGP_NOTIFY_CEASE, BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  3329.         }
  3330.       else
  3331.         BGP_EVENT_ADD (peer, BGP_Stop);
  3333.       bgp_tcpsig_unset (bm->sock, peer);
  3335.       UNSET_FLAG (peer->flags, PEER_FLAG_PASSWORD);
  3336.       if (peer->password)
  3337. free (peer->password);
  3338.       peer->password = NULL;
  3340.       return 0;
  3341.     }
  3343.   UNSET_FLAG (peer->flags, PEER_FLAG_PASSWORD);
  3344.   if (peer->password)
  3345.     free (peer->password);
  3346.   peer->password = NULL;
  3348.   group = peer->group;
  3349.   LIST_LOOP (group->peer, peer, nn)
  3350.     {
  3351.       if (! CHECK_FLAG (peer->flags, PEER_FLAG_PASSWORD))
  3352. continue;
  3354.       if (peer->status == Established)
  3355.         {
  3356.           peer->last_reset = PEER_DOWN_PASSWORD_CHANGE;
  3357.           bgp_notify_send (peer, BGP_NOTIFY_CEASE, BGP_NOTIFY_CEASE_CONFIG_CHANGE);
  3358.         }
  3359.       else
  3360.         BGP_EVENT_ADD (peer, BGP_Stop);
  3362.       bgp_tcpsig_unset (bm->sock, peer);
  3364.       UNSET_FLAG (peer->flags, PEER_FLAG_PASSWORD);
  3365.       if (peer->password)
  3366.         free (peer->password);
  3367.       peer->password = NULL;
  3368.     }
  3370.   return 0;
  3371. }
  3372. #endif /* HAVE_TCP_SIGNATURE */
  3374. /* Set distribute list to the peer. */
  3375. int
  3376. peer_distribute_set (struct peer *peer, afi_t afi, safi_t safi, int direct, 
  3377.      char *name)
  3378. {
  3379.   struct bgp_filter *filter;
  3380.   struct peer_group *group;
  3381.   struct listnode *nn;
  3383.   if (! peer->afc[afi][safi])
  3384.     return BGP_ERR_PEER_INACTIVE;
  3386.   if (direct != FILTER_IN && direct != FILTER_OUT)
  3387.     return BGP_ERR_INVALID_VALUE;
  3389.   if (direct == FILTER_OUT && peer_group_member (peer))
  3390.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3392.   filter = &peer->filter[afi][safi];
  3394.   if (filter->plist[direct].name)
  3395.     return BGP_ERR_PEER_FILTER_CONFLICT;
  3397.   if (filter->dlist[direct].name)
  3398.     free (filter->dlist[direct].name);
  3399.   filter->dlist[direct].name = strdup (name);
  3400.   filter->dlist[direct].alist = access_list_lookup (afi, name);
  3402.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3403.     {
  3404.       group = peer->group;
  3405.       LIST_LOOP (group->peer, peer, nn)
  3406. {
  3407.   filter = &peer->filter[afi][safi];
  3409.   if (! peer->afc[afi][safi])
  3410.     continue;
  3412.   if (filter->dlist[direct].name)
  3413.     free (filter->dlist[direct].name);
  3414.   filter->dlist[direct].name = strdup (name);
  3415.   filter->dlist[direct].alist = access_list_lookup (afi, name);
  3416. }
  3417.     }
  3419.   return 0;
  3420. }
  3422. int
  3423. peer_distribute_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
  3424. {
  3425.   struct bgp_filter *filter;
  3426.   struct bgp_filter *gfilter;
  3427.   struct peer_group *group;
  3428.   struct listnode *nn;
  3430.   if (! peer->afc[afi][safi])
  3431.     return BGP_ERR_PEER_INACTIVE;
  3433.   if (direct != FILTER_IN && direct != FILTER_OUT)
  3434.     return BGP_ERR_INVALID_VALUE;
  3436.   if (direct == FILTER_OUT && peer_group_member (peer))
  3437.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3439.   filter = &peer->filter[afi][safi];
  3441.   if (filter->dlist[direct].name)
  3442.     free (filter->dlist[direct].name);
  3443.   filter->dlist[direct].name = NULL;
  3444.   filter->dlist[direct].alist = NULL;
  3446.   if (peer_group_member (peer))
  3447.     {
  3448.       gfilter = &peer->group->conf->filter[afi][safi];
  3450.       if (gfilter->dlist[direct].name)
  3451. {
  3452.   filter->dlist[direct].name = strdup (gfilter->dlist[direct].name);
  3453.   filter->dlist[direct].alist = gfilter->dlist[direct].alist;
  3454. }
  3455.     }
  3457.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3458.     {
  3459.       group = peer->group;
  3460.       LIST_LOOP (group->peer, peer, nn)
  3461. {
  3462.   filter = &peer->filter[afi][safi];
  3464.   if (! peer->afc[afi][safi])
  3465.     continue;
  3467.   if (filter->dlist[direct].name)
  3468.     free (filter->dlist[direct].name);
  3469.   filter->dlist[direct].name = NULL;
  3470.   filter->dlist[direct].alist = NULL;
  3471. }
  3472.     }
  3474.   return 0;
  3475. }
  3477. /* Update distribute list. */
  3478. void
  3479. peer_distribute_update (struct access_list *access)
  3480. {
  3481.   afi_t afi;
  3482.   safi_t safi;
  3483.   int direct;
  3484.   struct listnode *nn, *nm;
  3485.   struct bgp *bgp;
  3486.   struct peer *peer;
  3487.   struct peer_group *group;
  3488.   struct bgp_filter *filter;
  3490.   LIST_LOOP (bm->bgp, bgp, nn)
  3491.     {
  3492.       LIST_LOOP (bgp->peer, peer, nm)
  3493. {
  3494.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  3495.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  3496.       {
  3497. filter = &peer->filter[afi][safi];
  3499. for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
  3500.   {
  3501.     if (filter->dlist[direct].name)
  3502.       filter->dlist[direct].alist = 
  3503. access_list_lookup (afi, filter->dlist[direct].name);
  3504.     else
  3505.       filter->dlist[direct].alist = NULL;
  3506.   }
  3507.       }
  3508. }
  3509.       LIST_LOOP (bgp->group, group, nm)
  3510. {
  3511.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  3512.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  3513.       {
  3514. filter = &group->conf->filter[afi][safi];
  3516. for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
  3517.   {
  3518.     if (filter->dlist[direct].name)
  3519.       filter->dlist[direct].alist = 
  3520. access_list_lookup (afi, filter->dlist[direct].name);
  3521.     else
  3522.       filter->dlist[direct].alist = NULL;
  3523.   }
  3524.       }
  3525. }
  3526.     }
  3527. }
  3529. /* Set prefix list to the peer. */
  3530. int
  3531. peer_prefix_list_set (struct peer *peer, afi_t afi, safi_t safi, int direct, 
  3532.       char *name)
  3533. {
  3534.   struct bgp_filter *filter;
  3535.   struct peer_group *group;
  3536.   struct listnode *nn;
  3538.   if (! peer->afc[afi][safi])
  3539.     return BGP_ERR_PEER_INACTIVE;
  3541.   if (direct != FILTER_IN && direct != FILTER_OUT)
  3542.     return BGP_ERR_INVALID_VALUE;
  3544.   if (direct == FILTER_OUT && peer_group_member (peer))
  3545.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3547.   filter = &peer->filter[afi][safi];
  3549.   if (filter->dlist[direct].name)
  3550.     return BGP_ERR_PEER_FILTER_CONFLICT;
  3552.   if (filter->plist[direct].name)
  3553.     free (filter->plist[direct].name);
  3554.   filter->plist[direct].name = strdup (name);
  3555.   filter->plist[direct].plist = prefix_list_lookup (afi, name);
  3557.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3558.     {
  3559.       group = peer->group;
  3560.       LIST_LOOP (group->peer, peer, nn)
  3561. {
  3562.   filter = &peer->filter[afi][safi];
  3564.   if (! peer->afc[afi][safi])
  3565.     continue;
  3567.   if (filter->plist[direct].name)
  3568.     free (filter->plist[direct].name);
  3569.   filter->plist[direct].name = strdup (name);
  3570.   filter->plist[direct].plist = prefix_list_lookup (afi, name);
  3571. }
  3572.     }
  3573.   return 0;
  3574. }
  3576. int
  3577. peer_prefix_list_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
  3578. {
  3579.   struct bgp_filter *filter;
  3580.   struct bgp_filter *gfilter;
  3581.   struct peer_group *group;
  3582.   struct listnode *nn;
  3584.   if (! peer->afc[afi][safi])
  3585.     return BGP_ERR_PEER_INACTIVE;
  3587.   if (direct != FILTER_IN && direct != FILTER_OUT)
  3588.     return BGP_ERR_INVALID_VALUE;
  3590.   if (direct == FILTER_OUT && peer_group_member (peer))
  3591.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3593.   filter = &peer->filter[afi][safi];
  3595.   if (filter->plist[direct].name)
  3596.     free (filter->plist[direct].name);
  3597.   filter->plist[direct].name = NULL;
  3598.   filter->plist[direct].plist = NULL;
  3600.   if (peer_group_member (peer))
  3601.     {
  3602.       gfilter = &peer->group->conf->filter[afi][safi];
  3604.       if (gfilter->plist[direct].name)
  3605. {
  3606.   filter->plist[direct].name = strdup (gfilter->plist[direct].name);
  3607.   filter->plist[direct].plist = gfilter->plist[direct].plist;
  3608. }
  3609.     }
  3611.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3612.     {
  3613.       group = peer->group;
  3614.       LIST_LOOP (group->peer, peer, nn)
  3615. {
  3616.   filter = &peer->filter[afi][safi];
  3618.   if (! peer->afc[afi][safi])
  3619.     continue;
  3621.   if (filter->plist[direct].name)
  3622.     free (filter->plist[direct].name);
  3623.   filter->plist[direct].name = NULL;
  3624.   filter->plist[direct].plist = NULL;
  3625. }
  3626.     }
  3628.   return 0;
  3629. }
  3631. /* Update prefix-list list. */
  3632. void
  3633. peer_prefix_list_update (struct prefix_list *plist)
  3634. {
  3635.   struct listnode *nn, *nm;
  3636.   struct bgp *bgp;
  3637.   struct peer *peer;
  3638.   struct peer_group *group;
  3639.   struct bgp_filter *filter;
  3640.   afi_t afi;
  3641.   safi_t safi;
  3642.   int direct;
  3644.   LIST_LOOP (bm->bgp, bgp, nn)
  3645.     {
  3646.       LIST_LOOP (bgp->peer, peer, nm)
  3647. {
  3648.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  3649.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  3650.       {
  3651. filter = &peer->filter[afi][safi];
  3653. for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
  3654.   {
  3655.     if (filter->plist[direct].name)
  3656.       filter->plist[direct].plist = 
  3657. prefix_list_lookup (afi, filter->plist[direct].name);
  3658.     else
  3659.       filter->plist[direct].plist = NULL;
  3660.   }
  3661.       }
  3662. }
  3663.       LIST_LOOP (bgp->group, group, nm)
  3664. {
  3665.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  3666.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  3667.       {
  3668. filter = &group->conf->filter[afi][safi];
  3670. for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
  3671.   {
  3672.     if (filter->plist[direct].name)
  3673.       filter->plist[direct].plist = 
  3674. prefix_list_lookup (afi, filter->plist[direct].name);
  3675.     else
  3676.       filter->plist[direct].plist = NULL;
  3677.   }
  3678.       }
  3679. }
  3680.     }
  3681. }
  3683. int
  3684. peer_aslist_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
  3685.  char *name)
  3686. {
  3687.   struct bgp_filter *filter;
  3688.   struct peer_group *group;
  3689.   struct listnode *nn;
  3691.   if (! peer->afc[afi][safi])
  3692.     return BGP_ERR_PEER_INACTIVE;
  3694.   if (direct != FILTER_IN && direct != FILTER_OUT)
  3695.     return BGP_ERR_INVALID_VALUE;
  3697.   if (direct == FILTER_OUT && peer_group_member (peer))
  3698.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3700.   filter = &peer->filter[afi][safi];
  3702.   if (filter->aslist[direct].name)
  3703.     free (filter->aslist[direct].name);
  3704.   filter->aslist[direct].name = strdup (name);
  3705.   filter->aslist[direct].aslist = as_list_lookup (name);
  3707.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3708.     {
  3709.       group = peer->group;
  3710.       LIST_LOOP (group->peer, peer, nn)
  3711. {
  3712.   filter = &peer->filter[afi][safi];
  3714.   if (! peer->afc[afi][safi])
  3715.     continue;
  3717.   if (filter->aslist[direct].name)
  3718.     free (filter->aslist[direct].name);
  3719.   filter->aslist[direct].name = strdup (name);
  3720.   filter->aslist[direct].aslist = as_list_lookup (name);
  3721. }
  3722.     }
  3723.   return 0;
  3724. }
  3726. int
  3727. peer_aslist_unset (struct peer *peer,afi_t afi, safi_t safi, int direct)
  3728. {
  3729.   struct bgp_filter *filter;
  3730.   struct bgp_filter *gfilter;
  3731.   struct peer_group *group;
  3732.   struct listnode *nn;
  3734.   if (! peer->afc[afi][safi])
  3735.     return BGP_ERR_PEER_INACTIVE;
  3737.   if (direct != FILTER_IN && direct != FILTER_OUT)
  3738.     return BGP_ERR_INVALID_VALUE;
  3740.   if (direct == FILTER_OUT && peer_group_member (peer))
  3741.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3743.   filter = &peer->filter[afi][safi];
  3745.   if (filter->aslist[direct].name)
  3746.     free (filter->aslist[direct].name);
  3747.   filter->aslist[direct].name = NULL;
  3748.   filter->aslist[direct].aslist = NULL;
  3750.   if (peer_group_member (peer))
  3751.     {
  3752.       gfilter = &peer->group->conf->filter[afi][safi];
  3754.       if (gfilter->aslist[direct].name)
  3755. {
  3756.   filter->aslist[direct].name = strdup (gfilter->aslist[direct].name);
  3757.   filter->aslist[direct].aslist = gfilter->aslist[direct].aslist;
  3758. }
  3759.     }
  3761.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3762.     {
  3763.       group = peer->group;
  3764.       LIST_LOOP (group->peer, peer, nn)
  3765. {
  3766.   filter = &peer->filter[afi][safi];
  3768.   if (! peer->afc[afi][safi])
  3769.     continue;
  3771.   if (filter->aslist[direct].name)
  3772.     free (filter->aslist[direct].name);
  3773.   filter->aslist[direct].name = NULL;
  3774.   filter->aslist[direct].aslist = NULL;
  3775. }
  3776.     }
  3777.   return 0;
  3778. }
  3780. void
  3781. peer_aslist_update ()
  3782. {
  3783.   afi_t afi;
  3784.   safi_t safi;
  3785.   int direct;
  3786.   struct listnode *nn, *nm;
  3787.   struct bgp *bgp;
  3788.   struct peer *peer;
  3789.   struct peer_group *group;
  3790.   struct bgp_filter *filter;
  3792.   LIST_LOOP (bm->bgp, bgp, nn)
  3793.     {
  3794.       LIST_LOOP (bgp->peer, peer, nm)
  3795. {
  3796.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  3797.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  3798.       {
  3799. filter = &peer->filter[afi][safi];
  3801. for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
  3802.   {
  3803.     if (filter->aslist[direct].name)
  3804.       filter->aslist[direct].aslist = 
  3805. as_list_lookup (filter->aslist[direct].name);
  3806.     else
  3807.       filter->aslist[direct].aslist = NULL;
  3808.   }
  3809.       }
  3810. }
  3811.       LIST_LOOP (bgp->group, group, nm)
  3812. {
  3813.   for (afi = AFI_IP; afi < AFI_MAX; afi++)
  3814.     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
  3815.       {
  3816. filter = &group->conf->filter[afi][safi];
  3818. for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
  3819.   {
  3820.     if (filter->aslist[direct].name)
  3821.       filter->aslist[direct].aslist = 
  3822. as_list_lookup (filter->aslist[direct].name);
  3823.     else
  3824.       filter->aslist[direct].aslist = NULL;
  3825.   }
  3826.       }
  3827. }
  3828.     }
  3829. }
  3831. /* Set route-map to the peer. */
  3832. int
  3833. peer_route_map_set (struct peer *peer, afi_t afi, safi_t safi, int direct, 
  3834.     char *name)
  3835. {
  3836.   struct bgp_filter *filter;
  3837.   struct peer_group *group;
  3838.   struct listnode *nn;
  3840.   if (! peer->afc[afi][safi])
  3841.     return BGP_ERR_PEER_INACTIVE;
  3843.   if (direct != FILTER_IN && direct != FILTER_OUT)
  3844.     return BGP_ERR_INVALID_VALUE;
  3846.   if (direct == FILTER_OUT && peer_group_member (peer))
  3847.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3849.   filter = &peer->filter[afi][safi];
  3851.   if (filter->map[direct].name)
  3852.     free (filter->map[direct].name);
  3853.   filter->map[direct].name = strdup (name);
  3854.   filter->map[direct].map = route_map_lookup_by_name (name);
  3856.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3857.     {
  3858.       group = peer->group;
  3859.       LIST_LOOP (group->peer, peer, nn)
  3860. {
  3861.   filter = &peer->filter[afi][safi];
  3863.   if (! peer->afc[afi][safi])
  3864.     continue;
  3866.   if (filter->map[direct].name)
  3867.     free (filter->map[direct].name);
  3868.   filter->map[direct].name = strdup (name);
  3869.   filter->map[direct].map = route_map_lookup_by_name (name);
  3870. }
  3871.     }
  3872.   return 0;
  3873. }
  3875. /* Unset route-map from the peer. */
  3876. int
  3877. peer_route_map_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
  3878. {
  3879.   struct bgp_filter *filter;
  3880.   struct bgp_filter *gfilter;
  3881.   struct peer_group *group;
  3882.   struct listnode *nn;
  3884.   if (! peer->afc[afi][safi])
  3885.     return BGP_ERR_PEER_INACTIVE;
  3887.   if (direct != FILTER_IN && direct != FILTER_OUT)
  3888.     return BGP_ERR_INVALID_VALUE;
  3890.   if (direct == FILTER_OUT && peer_group_member (peer))
  3891.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3893.   filter = &peer->filter[afi][safi];
  3895.   if (filter->map[direct].name)
  3896.     free (filter->map[direct].name);
  3897.   filter->map[direct].name = NULL;
  3898.   filter->map[direct].map = NULL;
  3900.   if (peer_group_member (peer))
  3901.     {
  3902.       gfilter = &peer->group->conf->filter[afi][safi];
  3904.       if (gfilter->map[direct].name)
  3905. {
  3906.   filter->map[direct].name = strdup (gfilter->map[direct].name);
  3907.   filter->map[direct].map = gfilter->map[direct].map;
  3908. }
  3909.     }
  3911.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3912.     {
  3913.       group = peer->group;
  3914.       LIST_LOOP (group->peer, peer, nn)
  3915. {
  3916.   filter = &peer->filter[afi][safi];
  3918.   if (! peer->afc[afi][safi])
  3919.     continue;
  3921.   if (filter->map[direct].name)
  3922.     free (filter->map[direct].name);
  3923.   filter->map[direct].name = NULL;
  3924.   filter->map[direct].map = NULL;
  3925. }
  3926.     }
  3927.   return 0;
  3928. }
  3930. /* Set unsuppress-map to the peer. */
  3931. int
  3932. peer_unsuppress_map_set (struct peer *peer, afi_t afi, safi_t safi, char *name)
  3933. {
  3934.   struct bgp_filter *filter;
  3935.   struct peer_group *group;
  3936.   struct listnode *nn;
  3938.   if (! peer->afc[afi][safi])
  3939.     return BGP_ERR_PEER_INACTIVE;
  3941.   if (peer_group_member (peer))
  3942.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3943.       
  3944.   filter = &peer->filter[afi][safi];
  3946.   if (filter->usmap.name)
  3947.     free (filter->usmap.name);
  3948.   filter->usmap.name = strdup (name);
  3949.   filter->usmap.map = route_map_lookup_by_name (name);
  3951.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  3952.     {
  3953.       group = peer->group;
  3954.       LIST_LOOP (group->peer, peer, nn)
  3955. {
  3956.   filter = &peer->filter[afi][safi];
  3958.   if (! peer->afc[afi][safi])
  3959.     continue;
  3961.   if (filter->usmap.name)
  3962.     free (filter->usmap.name);
  3963.   filter->usmap.name = strdup (name);
  3964.   filter->usmap.map = route_map_lookup_by_name (name);
  3965. }
  3966.     }
  3967.   return 0;
  3968. }
  3970. /* Unset route-map from the peer. */
  3971. int
  3972. peer_unsuppress_map_unset (struct peer *peer, afi_t afi, safi_t safi)
  3973. {
  3974.   struct bgp_filter *filter;
  3975.   struct bgp_filter *gfilter;
  3976.   struct peer_group *group;
  3977.   struct listnode *nn;
  3979.   if (! peer->afc[afi][safi])
  3980.     return BGP_ERR_PEER_INACTIVE;
  3981.   
  3982.   if (peer_group_member (peer))
  3983.     return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
  3985.   filter = &peer->filter[afi][safi];
  3987.   if (filter->usmap.name)
  3988.     free (filter->usmap.name);
  3989.   filter->usmap.name = NULL;
  3990.   filter->usmap.map = NULL;
  3992.   if (peer_group_member (peer))
  3993.     {
  3994.       gfilter = &peer->group->conf->filter[afi][safi];
  3996.       if (gfilter->usmap.name)
  3997. {
  3998.   filter->usmap.name = strdup (gfilter->usmap.name);
  3999.   filter->usmap.map = gfilter->usmap.map;
  4000. }
  4001.     }
  4003.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  4004.     {
  4005.       group = peer->group;
  4006.       LIST_LOOP (group->peer, peer, nn)
  4007. {
  4008.   filter = &peer->filter[afi][safi];
  4010.   if (! peer->afc[afi][safi])
  4011.     continue;
  4013.   if (filter->usmap.name)
  4014.     free (filter->usmap.name);
  4015.   filter->usmap.name = NULL;
  4016.   filter->usmap.map = NULL;
  4017. }
  4018.     }
  4019.   return 0;
  4020. }
  4022. int
  4023. peer_maximum_prefix_set (struct peer *peer, afi_t afi, safi_t safi,
  4024.  u_int32_t max, u_char threshold,
  4025.  int warning, u_int16_t restart)
  4026. {
  4027.   struct peer_group *group;
  4028.   struct listnode *nn;
  4030.   if (! peer->afc[afi][safi])
  4031.     return BGP_ERR_PEER_INACTIVE;
  4033.   SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
  4034.   peer->pmax[afi][safi] = max;
  4035.   peer->pmax_threshold[afi][safi] = threshold;
  4036.   peer->pmax_restart[afi][safi] = restart;
  4037.   if (warning)
  4038.     SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
  4039.   else
  4040.     UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
  4042.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  4043.     {
  4044.       group = peer->group;
  4045.       LIST_LOOP (group->peer, peer, nn)
  4046. {
  4047.   if (! peer->afc[afi][safi])
  4048.     continue;
  4050.   SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
  4051.   peer->pmax[afi][safi] = max;
  4052.   peer->pmax_threshold[afi][safi] = threshold;
  4053.   peer->pmax_restart[afi][safi] = restart;
  4054.   if (warning)
  4055.     SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
  4056.   else
  4057.     UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
  4058. }
  4059.     }
  4060.   return 0;
  4061. }
  4063. int
  4064. peer_maximum_prefix_unset (struct peer *peer, afi_t afi, safi_t safi)
  4065. {
  4066.   struct peer_group *group;
  4067.   struct listnode *nn;
  4069.   if (! peer->afc[afi][safi])
  4070.     return BGP_ERR_PEER_INACTIVE;
  4072.   UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
  4073.   UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
  4074.   peer->pmax[afi][safi] = 0;
  4075.   peer->pmax_threshold[afi][safi] = 0;
  4076.   peer->pmax_restart[afi][safi] = 0;
  4078.   if (peer_group_member (peer))
  4079.     {
  4080.       if (CHECK_FLAG (peer->group->conf->af_flags[afi][safi],
  4081.   PEER_FLAG_MAX_PREFIX))
  4082. SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
  4083.       else
  4084. UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
  4086.       if (CHECK_FLAG (peer->group->conf->af_flags[afi][safi],
  4087.   PEER_FLAG_MAX_PREFIX_WARNING))
  4088. SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
  4089.       else
  4090. UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
  4092.       peer->pmax[afi][safi] = peer->group->conf->pmax[afi][safi];
  4093.       peer->pmax_threshold[afi][safi] = peer->group->conf->pmax_threshold[afi][safi];
  4094.       peer->pmax_restart[afi][safi] = peer->group->conf->pmax_restart[afi][safi];
  4095.     }
  4097.   if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  4098.     {
  4099.       group = peer->group;
  4100.       LIST_LOOP (group->peer, peer, nn)
  4101. {
  4102.   if (! peer->afc[afi][safi])
  4103.     continue;
  4105.   UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
  4106.   UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
  4107.   peer->pmax[afi][safi] = 0;
  4108.   peer->pmax_threshold[afi][safi] = 0;
  4109.   peer->pmax_restart[afi][safi] = 0;
  4110. }
  4111.     }
  4112.   return 0;
  4113. }
  4115. int
  4116. peer_clear (struct peer *peer)
  4117. {
  4118.   if (! CHECK_FLAG (peer->flags, PEER_FLAG_SHUTDOWN))
  4119.     {
  4120.       peer->v_active_delay = BGP_ACTIVE_DELAY_TIMER;
  4122.       if (CHECK_FLAG (peer->sflags, PEER_STATUS_PREFIX_OVERFLOW))
  4123. {
  4124.   UNSET_FLAG (peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
  4125.   if (peer->t_pmax_restart)
  4126.     {
  4127.       BGP_TIMER_OFF (peer->t_pmax_restart);
  4128.       if (BGP_DEBUG (events, EVENTS))
  4129. zlog_info ("%s Maximum-prefix restart timer canceled", peer->host);
  4130.     }
  4131.   BGP_EVENT_ADD (peer, BGP_Start);
  4132.   return 0;
  4133. }
  4135.       if (CHECK_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT))
  4136. peer_nsf_stop (peer);
  4138.       if (peer->status == Established)
  4139. bgp_notify_send (peer, BGP_NOTIFY_CEASE,
  4140.  BGP_NOTIFY_CEASE_ADMIN_RESET);
  4141.       else
  4142. BGP_EVENT_ADD (peer, BGP_Stop);
  4143.     }
  4144.   return 0;
  4145. }
  4147. int
  4148. peer_clear_soft (struct peer *peer, afi_t afi, safi_t safi,
  4149.  enum bgp_clear_type stype)
  4150. {
  4151.   if (peer->status != Established)
  4152.     return 0;
  4154.   if (! peer->afc[afi][safi])
  4155.     return BGP_ERR_AF_UNCONFIGURED;
  4157.   if (stype == BGP_CLEAR_SOFT_OUT || stype == BGP_CLEAR_SOFT_BOTH)
  4158.     bgp_announce_route (peer, afi, safi);
  4160.   if (stype == BGP_CLEAR_SOFT_IN_ORF_PREFIX)
  4161.     {
  4162.       if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
  4163.   && (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV)
  4164.       || CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_OLD_RCV)))
  4165. {
  4166.   struct bgp_filter *filter = &peer->filter[afi][safi];
  4167.   u_char prefix_type;
  4169.   if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV))
  4170.     prefix_type = ORF_TYPE_PREFIX;
  4171.   else
  4172.     prefix_type = ORF_TYPE_PREFIX_OLD;
  4174.   if (filter->plist[FILTER_IN].plist)
  4175.     {
  4176.       if (CHECK_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND))
  4177. bgp_route_refresh_send (peer, afi, safi,
  4178. prefix_type, REFRESH_DEFER, 1);
  4179.       bgp_route_refresh_send (peer, afi, safi, prefix_type,
  4180.       REFRESH_IMMEDIATE, 0);
  4181.     }
  4182.   else
  4183.     {
  4184.       if (CHECK_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND))
  4185. bgp_route_refresh_send (peer, afi, safi,
  4186. prefix_type, REFRESH_IMMEDIATE, 1);
  4187.       else
  4188. bgp_route_refresh_send (peer, afi, safi, 0, 0, 0);
  4189.     }
  4190.   return 0;
  4191. }
  4192.     }
  4194.   if (stype == BGP_CLEAR_SOFT_IN || stype == BGP_CLEAR_SOFT_BOTH
  4195.       || stype == BGP_CLEAR_SOFT_IN_ORF_PREFIX)
  4196.     {
  4197.       /* If neighbor has soft reconfiguration inbound flag.
  4198.  Use Adj-RIB-In database. */
  4199.       if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
  4200. bgp_soft_reconfig_in (peer, afi, safi);
  4201.       else
  4202. {
  4203.   /* If neighbor has route refresh capability, send route refresh
  4204.      message to the peer. */
  4205.   if (CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_OLD_RCV)
  4206.       || CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV))
  4207.     bgp_route_refresh_send (peer, afi, safi, 0, 0, 0);
  4208.   else
  4209.     return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED;
  4210. }
  4211.     }
  4212.   return 0;
  4213. }
  4215. /* Display peer uptime. */
  4216. char *
  4217. peer_uptime (time_t uptime2, char *buf, size_t len)
  4218. {
  4219.   time_t uptime1;
  4220.   struct tm *tm;
  4222.   /* Check buffer length. */
  4223.   if (len < BGP_UPTIME_LEN)
  4224.     {
  4225.       zlog_warn ("peer_uptime (): buffer shortage %d", len);
  4226.       return "";
  4227.     }
  4229.   /* If there is no connection has been done before print `never'. */
  4230.   if (uptime2 == 0)
  4231.     {
  4232.       snprintf (buf, len, "never   ");
  4233.       return buf;
  4234.     }
  4236.   /* Get current time. */
  4237.   uptime1 = time (NULL);
  4238.   uptime1 -= uptime2;
  4239.   tm = gmtime (&uptime1);
  4241.   /* Making formatted timer strings. */
  4242. #define ONE_DAY_SECOND 60*60*24
  4243. #define ONE_WEEK_SECOND 60*60*24*7
  4245.   if (uptime1 < ONE_DAY_SECOND)
  4246.     snprintf (buf, len, "%02d:%02d:%02d", 
  4247.       tm->tm_hour, tm->tm_min, tm->tm_sec);
  4248.   else if (uptime1 < ONE_WEEK_SECOND)
  4249.     snprintf (buf, len, "%dd%02dh%02dm", 
  4250.       tm->tm_yday, tm->tm_hour, tm->tm_min);
  4251.   else
  4252.     snprintf (buf, len, "%02dw%dd%02dh", 
  4253.       tm->tm_yday/7, tm->tm_yday - ((tm->tm_yday/7) * 7), tm->tm_hour);
  4254.   return buf;
  4255. }
  4257. void
  4258. bgp_config_write_filter (struct vty *vty, struct peer *peer,
  4259.  afi_t afi, safi_t safi)
  4260. {
  4261.   struct bgp_filter *filter;
  4262.   struct bgp_filter *gfilter = NULL;
  4263.   char *addr;
  4264.   int in = FILTER_IN;
  4265.   int out = FILTER_OUT;
  4267.   addr = peer->host;
  4268.   filter = &peer->filter[afi][safi];
  4269.   if (peer_group_member (peer))
  4270.     gfilter = &peer->group->conf->filter[afi][safi];
  4272.   /* distribute-list. */
  4273.   if (filter->dlist[in].name)
  4274.     if (! gfilter || ! gfilter->dlist[in].name
  4275. || strcmp (filter->dlist[in].name, gfilter->dlist[in].name) != 0)
  4276.     vty_out (vty, " neighbor %s distribute-list %s in%s", addr, 
  4277.      filter->dlist[in].name, VTY_NEWLINE);
  4278.   if (filter->dlist[out].name && ! gfilter)
  4279.     vty_out (vty, " neighbor %s distribute-list %s out%s", addr, 
  4280.      filter->dlist[out].name, VTY_NEWLINE);
  4282.   /* prefix-list. */
  4283.   if (filter->plist[in].name)
  4284.     if (! gfilter || ! gfilter->plist[in].name
  4285. || strcmp (filter->plist[in].name, gfilter->plist[in].name) != 0)
  4286.     vty_out (vty, " neighbor %s prefix-list %s in%s", addr, 
  4287.      filter->plist[in].name, VTY_NEWLINE);
  4288.   if (filter->plist[out].name && ! gfilter)
  4289.     vty_out (vty, " neighbor %s prefix-list %s out%s", addr, 
  4290.      filter->plist[out].name, VTY_NEWLINE);
  4292.   /* route-map. */
  4293.   if (filter->map[in].name)
  4294.     if (! gfilter || ! gfilter->map[in].name
  4295. || strcmp (filter->map[in].name, gfilter->map[in].name) != 0)
  4296.       vty_out (vty, " neighbor %s route-map %s in%s", addr, 
  4297.        filter->map[in].name, VTY_NEWLINE);
  4298.   if (filter->map[out].name && ! gfilter)
  4299.     vty_out (vty, " neighbor %s route-map %s out%s", addr, 
  4300.      filter->map[out].name, VTY_NEWLINE);
  4302.   /* unsuppress-map */
  4303.   if (filter->usmap.name && ! gfilter)
  4304.     vty_out (vty, " neighbor %s unsuppress-map %s%s", addr,
  4305.      filter->usmap.name, VTY_NEWLINE);
  4307.   /* filter-list. */
  4308.   if (filter->aslist[in].name)
  4309.     if (! gfilter || ! gfilter->aslist[in].name
  4310. || strcmp (filter->aslist[in].name, gfilter->aslist[in].name) != 0)
  4311.       vty_out (vty, " neighbor %s filter-list %s in%s", addr, 
  4312.        filter->aslist[in].name, VTY_NEWLINE);
  4313.   if (filter->aslist[out].name && ! gfilter)
  4314.     vty_out (vty, " neighbor %s filter-list %s out%s", addr, 
  4315.      filter->aslist[out].name, VTY_NEWLINE);
  4316. }
  4318. /* BGP peer configuration display function. */
  4319. void
  4320. bgp_config_write_peer_global (struct vty *vty, struct bgp *bgp,
  4321.       struct peer *peer)
  4322. {
  4323.   struct peer *group = NULL;
  4324.   char buf[SU_ADDRSTRLEN];
  4325.   char *addr;
  4327.   addr = peer->host;
  4328.   if (peer_group_member (peer))
  4329.     group = peer->group->conf;
  4331.   /* remote-as. */
  4332.   if (peer_group_member (peer))
  4333.     {
  4334.       if (! group->as)
  4335.         vty_out (vty, " neighbor %s remote-as %d%s", addr, peer->as, VTY_NEWLINE);
  4337.       vty_out (vty, " neighbor %s peer-group %s%s", addr, peer->group->name, VTY_NEWLINE);
  4338.     }
  4339.   else
  4340.     {
  4341.       if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
  4342.         vty_out (vty, " neighbor %s peer-group%s", addr, VTY_NEWLINE);
  4343.       if (peer->as)
  4344.         vty_out (vty, " neighbor %s remote-as %d%s", addr, peer->as, VTY_NEWLINE);
  4345.     }
  4347.   /* local-as. */
  4348.   if (peer->change_local_as)
  4349.     if (! peer_group_member (peer))
  4350.       vty_out (vty, " neighbor %s local-as %d%s%s", addr,
  4351.        peer->change_local_as,
  4352.        CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND) ?
  4353.        " no-prepend" : "", VTY_NEWLINE);
  4355.   /* Description. */
  4356.   if (peer->desc)
  4357.     vty_out (vty, " neighbor %s description %s%s", addr, peer->desc, VTY_NEWLINE);
  4359.   /* Shutdown. */
  4360.   if (CHECK_FLAG (peer->flags, PEER_FLAG_SHUTDOWN))
  4361.     if (! peer_group_member (peer) ||
  4362. ! CHECK_FLAG (group->flags, PEER_FLAG_SHUTDOWN))
  4363.       vty_out (vty, " neighbor %s shutdown%s", addr, VTY_NEWLINE);
  4365. #ifdef HAVE_TCP_SIGNATURE
  4366.   /* Password. */
  4367.   if (CHECK_FLAG (peer->flags, PEER_FLAG_PASSWORD))
  4368.     if (! peer_group_member (peer)
  4369. || ! CHECK_FLAG (group->flags, PEER_FLAG_PASSWORD)
  4370. || strcmp (peer->password, group->password) != 0)
  4371.       vty_out (vty, " neighbor %s password %s%s", addr, peer->password, VTY_NEWLINE);
  4372. #endif /* HAVE_TCP_SIGNATURE */
  4374.   /* BGP port. */
  4375.   if (peer->port != BGP_PORT_DEFAULT)
  4376.     vty_out (vty, " neighbor %s port %d%s", addr, peer->port, VTY_NEWLINE);
  4378.   /* Local interface name. */
  4379.   if (peer->ifname)
  4380.     vty_out (vty, " neighbor %s interface %s%s", addr, peer->ifname, VTY_NEWLINE);
  4381.   
  4382.   /* transport connection-mode. */
  4383.   if (CHECK_FLAG (peer->flags, PEER_FLAG_CONNECT_MODE_PASSIVE))
  4384.     if (! peer_group_member (peer) ||
  4385. ! CHECK_FLAG (group->flags, PEER_FLAG_CONNECT_MODE_PASSIVE))
  4386.       vty_out (vty, " neighbor %s transport connection-mode passive%s",
  4387.        addr, VTY_NEWLINE);
  4388.   if (CHECK_FLAG (peer->flags, PEER_FLAG_CONNECT_MODE_ACTIVE))
  4389.     if (! peer_group_member (peer) ||
  4390. ! CHECK_FLAG (group->flags, PEER_FLAG_CONNECT_MODE_ACTIVE))
  4391.       vty_out (vty, " neighbor %s transport connection-mode active%s",
  4392.        addr, VTY_NEWLINE);
  4394.   /* EBGP multihop.  */
  4395.   if (peer_sort (peer) != BGP_PEER_IBGP && peer->ttl != 1)
  4396.     if (! peer_group_member (peer) ||  group->ttl != peer->ttl)
  4397.       vty_out (vty, " neighbor %s ebgp-multihop %d%s", addr, peer->ttl,
  4398.        VTY_NEWLINE);
  4400.   /* disable-connected-check.  */
  4401.   if (CHECK_FLAG (peer->flags, PEER_FLAG_DISABLE_CONNECTED_CHECK))
  4402.     if (! peer_group_member (peer) ||
  4403. ! CHECK_FLAG (group->flags, PEER_FLAG_DISABLE_CONNECTED_CHECK))
  4404.       vty_out (vty, " neighbor %s disable-connected-check%s", addr, VTY_NEWLINE);
  4406.   /* Update-source. */
  4407.   if (peer->update_if)
  4408.     if (! peer_group_member (peer) || ! group->update_if
  4409. || strcmp (group->update_if, peer->update_if) != 0)
  4410.       vty_out (vty, " neighbor %s update-source %s%s", addr,
  4411.        peer->update_if, VTY_NEWLINE);
  4412.   if (peer->update_source)
  4413.     if (! peer_group_member (peer) || ! group->update_source
  4414. || sockunion_cmp (group->update_source, peer->update_source) != 0)
  4415.       vty_out (vty, " neighbor %s update-source %s%s", addr,
  4416.        sockunion2str (peer->update_source, buf, SU_ADDRSTRLEN),
  4417.    VTY_NEWLINE);
  4419.   /* advertisement-interval */
  4420.   if (CHECK_FLAG (peer->config, PEER_CONFIG_ROUTEADV))
  4421.     vty_out (vty, " neighbor %s advertisement-interval %d%s",
  4422.      addr, peer->v_routeadv, VTY_NEWLINE); 
  4424.   /* timers. */
  4425.   if (CHECK_FLAG (peer->config, PEER_CONFIG_TIMER)
  4426.       && ! peer_group_member (peer))
  4427.     vty_out (vty, " neighbor %s timers %d %d%s", addr, 
  4428.      peer->keepalive, peer->holdtime, VTY_NEWLINE);
  4430.   /* Dynamic capability.  */
  4431.   if (CHECK_FLAG (peer->flags, PEER_FLAG_DYNAMIC_CAPABILITY))
  4432.     if (! peer_group_member (peer) ||
  4433. ! CHECK_FLAG (group->flags, PEER_FLAG_DYNAMIC_CAPABILITY))
  4434.       vty_out (vty, " neighbor %s capability dynamic%s", addr, VTY_NEWLINE);
  4436.   /* dont capability negotiation. */
  4437.   if (CHECK_FLAG (peer->flags, PEER_FLAG_DONT_CAPABILITY))
  4438.     if (! peer_group_member (peer) ||
  4439. ! CHECK_FLAG (group->flags, PEER_FLAG_DONT_CAPABILITY))
  4440.       vty_out (vty, " neighbor %s dont-capability-negotiate%s", addr, VTY_NEWLINE);
  4442.   /* override capability negotiation. */
  4443.   if (CHECK_FLAG (peer->flags, PEER_FLAG_OVERRIDE_CAPABILITY))
  4444.     if (! peer_group_member (peer) ||
  4445. ! CHECK_FLAG (group->flags, PEER_FLAG_OVERRIDE_CAPABILITY))
  4446.       vty_out (vty, " neighbor %s override-capability%s", addr, VTY_NEWLINE);
  4448.   /* strict capability negotiation. */
  4449.   if (CHECK_FLAG (peer->flags, PEER_FLAG_STRICT_CAP_MATCH))
  4450.     if (! peer_group_member (peer) ||
  4451. ! CHECK_FLAG (group->flags, PEER_FLAG_STRICT_CAP_MATCH))
  4452.       vty_out (vty, " neighbor %s strict-capability-match%s", addr, VTY_NEWLINE);
  4453. }
  4455. void
  4456. bgp_config_write_peer (struct vty *vty, struct bgp *bgp,
  4457.                        struct peer *peer, afi_t afi, safi_t safi)
  4458. {
  4459.   struct bgp_filter *filter;
  4460.   struct peer *g_peer = NULL;
  4461.   char *addr;
  4463.   filter = &peer->filter[afi][safi];
  4464.   addr = peer->host;
  4465.   if (peer_group_member (peer))
  4466.     g_peer = peer->group->conf;
  4468.   if (peer->afc[afi][safi])
  4469.     {
  4470.       if (peer_group_member (peer))
  4471.         vty_out (vty, " neighbor %s peer-group %s%s", addr,
  4472.                  peer->group->name, VTY_NEWLINE);
  4473.       else
  4474.         vty_out (vty, " neighbor %s activate%s", addr, VTY_NEWLINE);
  4475.     }
  4476.   else
  4477.     {
  4478.       vty_out (vty, " no neighbor %s activate%s", addr, VTY_NEWLINE);
  4479.       return;
  4480.     }
  4482.   /* Route server client */
  4483.   if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT)
  4484.       && ! peer_group_member (peer))
  4485.     vty_out (vty, " neighbor %s route-server-client%s", addr, VTY_NEWLINE);
  4487.   /* Route reflector client */
  4488.   if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_REFLECTOR_CLIENT)
  4489.       && ! peer_group_member (peer))
  4490.     vty_out (vty, " neighbor %s route-reflector-client%s", addr, 
  4491.      VTY_NEWLINE);
  4493.   /* Nexthop self */
  4494.   if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_NEXTHOP_SELF)
  4495.       && ! peer_group_member (peer))
  4496.     vty_out (vty, " neighbor %s next-hop-self%s", addr, VTY_NEWLINE);
  4498.   /* Attribute-unchanged. */
  4499.   if ((CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED)
  4500.       || CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_NEXTHOP_UNCHANGED)
  4501.       || CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
  4502.       && ! peer_group_member (peer))
  4503.     {
  4504.       if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED)
  4505.           && CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_NEXTHOP_UNCHANGED)
  4506.           && CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
  4507. vty_out (vty, " neighbor %s attribute-unchanged%s", addr, VTY_NEWLINE);
  4508.       else
  4509. vty_out (vty, " neighbor %s attribute-unchanged%s%s%s%s", addr, 
  4510.      (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED)) ?
  4511.      " as-path" : "",
  4512.      (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_NEXTHOP_UNCHANGED)) ?
  4513.      " next-hop" : "",
  4514.      (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED)) ?
  4515.      " med" : "", VTY_NEWLINE);
  4516.     }
  4518.   /* Send-community */
  4519.   if (! peer_group_member (peer))
  4520.     {
  4521.       if (bgp_option_check (BGP_OPT_CONFIG_CISCO))
  4522. {
  4523.   if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_COMMUNITY)
  4524.       && peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY))
  4525.     vty_out (vty, " neighbor %s send-community both%s", addr, VTY_NEWLINE);
  4526.   else if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY))
  4527.     vty_out (vty, " neighbor %s send-community extended%s",
  4528.      addr, VTY_NEWLINE);
  4529.   else if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_COMMUNITY))
  4530.     vty_out (vty, " neighbor %s send-community%s", addr, VTY_NEWLINE);
  4531. }
  4532.       else
  4533. {
  4534.   if (! peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_COMMUNITY)
  4535.       && ! peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY))
  4536.     vty_out (vty, " no neighbor %s send-community both%s",
  4537.      addr, VTY_NEWLINE);
  4538.   else if (! peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY))
  4539.     vty_out (vty, " no neighbor %s send-community extended%s",
  4540.      addr, VTY_NEWLINE);
  4541.   else if (! peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_COMMUNITY))
  4542.     vty_out (vty, " no neighbor %s send-community%s",
  4543.      addr, VTY_NEWLINE);
  4544. }
  4545.     }
  4547.   /* Default information */
  4548.   if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_DEFAULT_ORIGINATE)
  4549.       && ! peer_group_member (peer))
  4550.     {
  4551.       vty_out (vty, " neighbor %s default-originate", addr);
  4552.       if (peer->default_rmap[afi][safi].name)
  4553. vty_out (vty, " route-map %s", peer->default_rmap[afi][safi].name);
  4554.       vty_out (vty, "%s", VTY_NEWLINE);
  4555.     }
  4557.   /* Remove private AS */
  4558.   if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_REMOVE_PRIVATE_AS)
  4559.       && ! peer_group_member (peer))
  4560.     vty_out (vty, " neighbor %s remove-private-AS%s",
  4561.      addr, VTY_NEWLINE);
  4563.   /* Weight */
  4564.   if (CHECK_FLAG (peer->af_config[afi][safi], PEER_AF_CONFIG_WEIGHT))
  4565.     if (! peer_group_member (peer) ||
  4566. g_peer->weight[afi][safi] != peer->weight[afi][safi])
  4567.       vty_out (vty, " neighbor %s weight %d%s", addr, peer->weight[afi][safi],
  4568.        VTY_NEWLINE);
  4570.   /* ORF capability */
  4571.   if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
  4572.       || CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
  4573.     if (! peer_group_member (peer))
  4574.     {
  4575.       vty_out (vty, " neighbor %s capability orf prefix-list", addr);
  4577.       if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
  4578.   && CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
  4579. vty_out (vty, " both");
  4580.       else if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM))
  4581. vty_out (vty, " send");
  4582.       else
  4583. vty_out (vty, " receive");
  4584.       vty_out (vty, "%s", VTY_NEWLINE);
  4585.     }
  4587.   /* Allow AS in.  */
  4588.   if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_ALLOWAS_IN))
  4589.     if (! peer_group_member (peer)
  4590. || ! peer_af_flag_check (g_peer, afi, safi, PEER_FLAG_ALLOWAS_IN)
  4591. || peer->allowas_in[afi][safi] != g_peer->allowas_in[afi][safi])
  4592.       {
  4593. if (peer->allowas_in[afi][safi] == 3)
  4594.   vty_out (vty, " neighbor %s allowas-in%s", addr, VTY_NEWLINE);
  4595. else
  4596.   vty_out (vty, " neighbor %s allowas-in %d%s", addr,
  4597.    peer->allowas_in[afi][safi], VTY_NEWLINE);
  4598.       }
  4600.   /* Soft reconfiguration inbound */
  4601.   if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
  4602.     if (! peer_group_member (peer) ||
  4603. ! CHECK_FLAG (g_peer->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
  4604.     vty_out (vty, " neighbor %s soft-reconfiguration inbound%s", addr,
  4605.      VTY_NEWLINE);
  4607.   /* Filter. */
  4608.   bgp_config_write_filter (vty, peer, afi, safi);
  4610.   /* Maximum-prefix */
  4611.   if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX))
  4612.     if (! peer_group_member (peer)
  4613. || g_peer->pmax[afi][safi] != peer->pmax[afi][safi]
  4614. || g_peer->pmax_threshold[afi][safi] != peer->pmax_threshold[afi][safi]
  4615. || g_peer->pmax_restart[afi][safi] != peer->pmax_restart[afi][safi]
  4616. || CHECK_FLAG (g_peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING)
  4617.    != CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING))
  4618.       {
  4619. vty_out (vty, " neighbor %s maximum-prefix %ld", addr, peer->pmax[afi][safi]);
  4620. if (peer->pmax_threshold[afi][safi] != MAXIMUM_PREFIX_THRESHOLD_DEFAULT)
  4621.   vty_out (vty, " %d", peer->pmax_threshold[afi][safi]);
  4622. if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING))
  4623.   vty_out (vty, " warning-only");
  4624. if (peer->pmax_restart[afi][safi])
  4625.   vty_out (vty, " restart %d", peer->pmax_restart[afi][safi]);
  4626. vty_out (vty, "%s", VTY_NEWLINE);
  4627.       }
  4628. }
  4630. /* Display "address-family" configuration header. */
  4631. void
  4632. bgp_config_write_family_header (struct vty *vty, afi_t afi, safi_t safi,
  4633. int *write)
  4634. {
  4635.   if (*write)
  4636.     return;
  4638.   vty_out (vty, "!%s address-family ", VTY_NEWLINE);
  4640.   if (afi == AFI_IP)
  4641.     {
  4642.       if (safi == SAFI_UNICAST)
  4643. vty_out (vty, "ipv4");
  4644.       else if (safi == SAFI_MULTICAST)
  4645. vty_out (vty, "ipv4 multicast");
  4646.       else if (safi == SAFI_MPLS_VPN)
  4647. vty_out (vty, "vpnv4 unicast");
  4648.     }
  4649.   else if (afi == AFI_IP6)
  4650.     vty_out (vty, "ipv6");
  4652.   vty_out (vty, "%s", VTY_NEWLINE);
  4654.   *write = 1;
  4655. }
  4657. /* Address family based peer configuration display.  */
  4658. int
  4659. bgp_config_write_family (struct vty *vty, struct bgp *bgp, afi_t afi,
  4660.  safi_t safi)
  4661. {
  4662.   int write = 0;
  4663.   struct peer *peer;
  4664.   struct peer_group *group;
  4665.   struct listnode *nn;
  4667.   bgp_config_write_redistribute (vty, bgp, afi, safi, &write);
  4669.   LIST_LOOP (bgp->group, group, nn)
  4670.     {
  4671.       if ((! bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4)
  4672.   && afi == AFI_IP && safi == SAFI_UNICAST)
  4673.   || group->conf->afc[afi][safi])
  4674. {
  4675.   bgp_config_write_family_header (vty, afi, safi, &write);
  4676.   bgp_config_write_peer (vty, bgp, group->conf, afi, safi);
  4677. }
  4678.     }
  4679.   LIST_LOOP (bgp->peer, peer, nn)
  4680.     {
  4681.       if ((! bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4)
  4682.   && afi == AFI_IP && safi == SAFI_UNICAST)
  4683.   || peer->afc[afi][safi])
  4684. {
  4685.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
  4686.     {
  4687.       bgp_config_write_family_header (vty, afi, safi, &write);
  4688.       bgp_config_write_peer (vty, bgp, peer, afi, safi);
  4689.     }
  4690. }
  4691.     }
  4693.   bgp_config_write_network (vty, bgp, afi, safi, &write);
  4695.   /* BGP flag dampening. */
  4696.   if (CHECK_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING))
  4697.     {
  4698.       bgp_config_write_family_header (vty, afi, safi, &write);
  4699.       bgp_config_write_damp (vty);
  4700.     }
  4702.   if (write)
  4703.     {
  4704.       /* No auto-summary */
  4705.       if (afi == AFI_IP && (safi == SAFI_UNICAST || safi == SAFI_MULTICAST)
  4706.           && bgp_option_check (BGP_OPT_CONFIG_CISCO))
  4707. vty_out (vty, " no auto-summary%s", VTY_NEWLINE);
  4709.       /* No Synchronization */
  4710.       if ((afi == AFI_IP || afi == AFI_IP6) && safi == SAFI_UNICAST
  4711.   && bgp_option_check (BGP_OPT_CONFIG_CISCO))
  4712. vty_out (vty, " no synchronization%s", VTY_NEWLINE);
  4714.       vty_out (vty, " exit-address-family%s", VTY_NEWLINE);
  4715.     }
  4716.   return write;
  4717. }
  4719. int
  4720. bgp_config_write (struct vty *vty)
  4721. {
  4722.   int write = 0;
  4723.   struct bgp *bgp;
  4724.   struct peer_group *group;
  4725.   struct peer *peer;
  4726.   struct listnode *nn, *nm, *no;
  4728.   /* BGP Multiple instance. */
  4729.   if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE))
  4730.     {    
  4731.       vty_out (vty, "bgp multiple-instance%s", VTY_NEWLINE);
  4732.       write++;
  4733.     }
  4735.   /* BGP Config type. */
  4736.   if (bgp_option_check (BGP_OPT_CONFIG_CISCO))
  4737.     {    
  4738.       vty_out (vty, "bgp config-type cisco%s", VTY_NEWLINE);
  4739.       write++;
  4740.     }
  4742.   /* BGP configuration. */
  4743.   LIST_LOOP (bm->bgp, bgp, nn)
  4744.     {
  4745.       if (write)
  4746. vty_out (vty, "!%s", VTY_NEWLINE);
  4748.       /* Router bgp ASN */
  4749.       vty_out (vty, "router bgp %d", bgp->as);
  4751.       if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE))
  4752. {
  4753.   if (bgp->name)
  4754.     vty_out (vty, " view %s", bgp->name);
  4755. }
  4756.       vty_out (vty, "%s", VTY_NEWLINE);
  4758.       /* BGP fast-external-failover. */
  4759.       if (CHECK_FLAG (bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER))
  4760. vty_out (vty, " no bgp fast-external-failover%s", VTY_NEWLINE); 
  4762.       /* BGP router ID. */
  4763.       if (CHECK_FLAG (bgp->config, BGP_CONFIG_ROUTER_ID))
  4764. vty_out (vty, " bgp router-id %s%s", inet_ntoa (bgp->router_id), 
  4765.  VTY_NEWLINE);
  4767.       /* BGP log-neighbor-changes. */
  4768.       if (bgp_flag_check (bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES))
  4769. vty_out (vty, " bgp log-neighbor-changes%s", VTY_NEWLINE);
  4771.       /* BGP configuration. */
  4772.       if (bgp_flag_check (bgp, BGP_FLAG_ALWAYS_COMPARE_MED))
  4773. vty_out (vty, " bgp always-compare-med%s", VTY_NEWLINE);
  4775.       /* BGP default ipv4-unicast. */
  4776.       if (bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4))
  4777. vty_out (vty, " no bgp default ipv4-unicast%s", VTY_NEWLINE);
  4779.       /* BGP default local-preference. */
  4780.       if (bgp->default_local_pref != BGP_DEFAULT_LOCAL_PREF)
  4781. vty_out (vty, " bgp default local-preference %d%s",
  4782.  bgp->default_local_pref, VTY_NEWLINE);
  4784.       /* BGP client-to-client reflection. */
  4785.       if (bgp_flag_check (bgp, BGP_FLAG_NO_CLIENT_TO_CLIENT))
  4786. vty_out (vty, " no bgp client-to-client reflection%s", VTY_NEWLINE);
  4787.       
  4788.       /* BGP cluster ID. */
  4789.       if (CHECK_FLAG (bgp->config, BGP_CONFIG_CLUSTER_ID))
  4790. vty_out (vty, " bgp cluster-id %s%s", inet_ntoa (bgp->cluster_id),
  4791.  VTY_NEWLINE);
  4793.       /* Confederation identifier */
  4794.       if (CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION))
  4795. vty_out (vty, " bgp confederation identifier %i%s", bgp->confed_id,
  4796.  VTY_NEWLINE);
  4798.       /* Confederation peer */
  4799.       if (bgp->confed_peers_cnt > 0)
  4800. {
  4801.   int i;
  4803.   vty_out (vty, " bgp confederation peers");
  4805.   for (i = 0; i < bgp->confed_peers_cnt; i++)
  4806.     vty_out(vty, " %d", bgp->confed_peers[i]);
  4808.   vty_out (vty, "%s", VTY_NEWLINE);
  4809. }
  4811.       /* BGP enforce-first-as. */
  4812.       if (bgp_flag_check (bgp, BGP_FLAG_NO_ENFORCE_FIRST_AS))
  4813. vty_out (vty, " no bgp enforce-first-as%s", VTY_NEWLINE);
  4815.       /* BGP deterministic-med. */
  4816.       if (bgp_flag_check (bgp, BGP_FLAG_DETERMINISTIC_MED))
  4817. vty_out (vty, " bgp deterministic-med%s", VTY_NEWLINE);
  4818.       
  4819.       /* BGP graceful-restart. */
  4820.       if (bgp->stalepath_time != BGP_DEFAULT_STALEPATH_TIME)
  4821. vty_out (vty, " bgp graceful-restart stalepath-time %d%s",
  4822.  bgp->stalepath_time, VTY_NEWLINE);
  4823.       if (bgp_flag_check (bgp, BGP_FLAG_GRACEFUL_RESTART))
  4824. vty_out (vty, " bgp graceful-restart%s", VTY_NEWLINE);
  4826.       /* BGP bestpath method. */
  4827.       if (bgp_flag_check (bgp, BGP_FLAG_ASPATH_IGNORE))
  4828. vty_out (vty, " bgp bestpath as-path ignore%s", VTY_NEWLINE);
  4829.       if (bgp_flag_check (bgp, BGP_FLAG_MED_CONFED)
  4830.   || bgp_flag_check (bgp, BGP_FLAG_MED_MISSING_AS_WORST))
  4831. {
  4832.   vty_out (vty, " bgp bestpath med");
  4833.   if (bgp_flag_check (bgp, BGP_FLAG_MED_CONFED))
  4834.     vty_out (vty, " confed");
  4835.   if (bgp_flag_check (bgp, BGP_FLAG_MED_MISSING_AS_WORST))
  4836.     vty_out (vty, " missing-as-worst");
  4837.   vty_out (vty, "%s", VTY_NEWLINE);
  4838. }
  4839.       if (bgp_flag_check (bgp, BGP_FLAG_COMPARE_ROUTER_ID))
  4840. vty_out (vty, " bgp bestpath compare-routerid%s", VTY_NEWLINE);
  4841.       if (bgp_flag_check (bgp, BGP_FLAG_COST_COMMUNITY_IGNORE))
  4842. vty_out (vty, " bgp bestpath cost-community ignore%s", VTY_NEWLINE);
  4844.       /* BGP network import check. */
  4845.       if (bgp_flag_check (bgp, BGP_FLAG_IMPORT_CHECK))
  4846. vty_out (vty, " bgp network import-check%s", VTY_NEWLINE);
  4848.       /* BGP scan interval. */
  4849.       bgp_config_write_scan_time (vty);
  4851.       /* BGP timers configuration. */
  4852.       if (bgp->default_keepalive != BGP_DEFAULT_KEEPALIVE
  4853.   && bgp->default_holdtime != BGP_DEFAULT_HOLDTIME)
  4854. vty_out (vty, " timers bgp %d %d%s", bgp->default_keepalive, 
  4855.  bgp->default_holdtime, VTY_NEWLINE);
  4857.       /* Distance configuration. */
  4858.       bgp_config_write_distance (vty, bgp);
  4859.       
  4860.       /* peer-group */
  4861.       LIST_LOOP (bgp->group, group, nm)
  4862. {
  4863.     bgp_config_write_peer_global (vty, bgp, group->conf);
  4864. }
  4866.       /* Normal neighbor configuration. */
  4867.       LIST_LOOP (bgp->peer, peer, no)
  4868. {
  4869.   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
  4870.     bgp_config_write_peer_global (vty, bgp, peer);
  4871. }
  4873.       /* IPv4 unicast configuration.  */
  4874.       write += bgp_config_write_family (vty, bgp, AFI_IP, SAFI_UNICAST);
  4876.       /* IPv4 multicast configuration.  */
  4877.       write += bgp_config_write_family (vty, bgp, AFI_IP, SAFI_MULTICAST);
  4879.       /* IPv4 VPN configuration.  */
  4880.       write += bgp_config_write_family (vty, bgp, AFI_IP, SAFI_MPLS_VPN);
  4882.       /* IPv6 unicast configuration.  */
  4883.       write += bgp_config_write_family (vty, bgp, AFI_IP6, SAFI_UNICAST);
  4885.       write++;
  4886.     }
  4887.   return write;
  4888. }
  4890. void
  4891. bgp_master_init ()
  4892. {
  4893.   memset (&bgp_master, 0, sizeof (struct bgp_master));
  4895.   bm = &bgp_master;
  4896.   bm->bgp = list_new ();
  4897.   bm->port = BGP_PORT_DEFAULT;
  4898.   bm->master = thread_master_create ();
  4899.   bm->start_time = time (NULL);
  4900. #ifdef HAVE_TCP_SIGNATURE
  4901.   bm->sock = -1;
  4902. #endif /* HAVE_TCP_SIGNATURE */
  4903. }
  4905. void
  4906. bgp_init ()
  4907. {
  4908.   void bgp_zebra_init ();
  4909.   void bgp_route_map_init ();
  4910.   void bgp_filter_init ();
  4912.   /* BGP VTY commands installation.  */
  4913.   bgp_vty_init ();
  4915.   /* Create BGP server socket.  */
  4916.   bgp_socket (NULL, bm->port);
  4918.   /* Init zebra. */
  4919.   bgp_zebra_init ();
  4921.   /* BGP inits. */
  4922.   bgp_attr_init ();
  4923.   bgp_debug_init ();
  4924.   bgp_dump_init ();
  4925.   bgp_route_init ();
  4926.   bgp_route_map_init ();
  4927.   bgp_scan_init ();
  4928.   bgp_mplsvpn_init ();
  4930.   /* Access list initialize. */
  4931.   access_list_init ();
  4932.   access_list_add_hook (peer_distribute_update);
  4933.   access_list_delete_hook (peer_distribute_update);
  4935.   /* Filter list initialize. */
  4936.   bgp_filter_init ();
  4937.   as_list_add_hook (peer_aslist_update);
  4938.   as_list_delete_hook (peer_aslist_update);
  4940.   /* Prefix list initialize.*/
  4941.   prefix_list_init ();
  4942.   prefix_list_add_hook (peer_prefix_list_update);
  4943.   prefix_list_delete_hook (peer_prefix_list_update);
  4945.   /* Community list initialize. */
  4946.   bgp_clist = community_list_init ();
  4948. #ifdef HAVE_SNMP
  4949.   bgp_snmp_init ();
  4950. #endif /* HAVE_SNMP */
  4951. }