LCOV - code coverage report
Current view: top level - bgp - bgp_server.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 424 789 53.7 %
Date: 2026-11-16 02:06:09 Functions: 47 75 62.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #include "bgp/bgp_server.h"
       7             : 
       8             : #include <sys/resource.h>
       9             : 
      10             : #include <boost/foreach.hpp>
      11             : #include <boost/tuple/tuple.hpp>
      12             : 
      13             : #include "base/connection_info.h"
      14             : #include "base/misc_utils.h"
      15             : #include "base/task_annotations.h"
      16             : #include "bgp/bgp_condition_listener.h"
      17             : #include "bgp/bgp_factory.h"
      18             : #include "bgp/bgp_lifetime.h"
      19             : #include "bgp/bgp_log.h"
      20             : #include "bgp/bgp_membership.h"
      21             : #include "bgp/bgp_peer.h"
      22             : #include "bgp/bgp_ribout_updates.h"
      23             : #include "bgp/rtarget/rtarget_table.h"
      24             : #include "bgp/bgp_session_manager.h"
      25             : #include "bgp/bgp_update_sender.h"
      26             : #include "bgp/peer_stats.h"
      27             : #include "bgp/routing-instance/iservice_chain_mgr.h"
      28             : #include "bgp/routing-instance/istatic_route_mgr.h"
      29             : #include "bgp/routing-instance/peer_manager.h"
      30             : #include "bgp/routing-instance/routepath_replicator.h"
      31             : #include "bgp/routing-instance/routing_instance.h"
      32             : #include "bgp/routing-instance/rtarget_group_mgr.h"
      33             : #include "bgp/routing-policy/routing_policy.h"
      34             : 
      35             : #include "config-client-mgr/config_client_show_types.h"
      36             : #include "control-node/sandesh/control_node_types.h"
      37             : 
      38             : using boost::system::error_code;
      39             : using boost::tie;
      40             : using process::ConnectionState;
      41             : using std::boolalpha;
      42             : using std::make_pair;
      43             : using std::map;
      44             : using std::noboolalpha;
      45             : using std::sort;
      46             : using std::string;
      47             : 
      48             : // The ConfigUpdater serves as glue between the BgpConfigManager and the
      49             : // BgpServer.
      50             : class BgpServer::ConfigUpdater {
      51             : public:
      52          20 :     explicit ConfigUpdater(BgpServer *server) : server_(server) {
      53          20 :         BgpConfigManager::Observers obs;
      54             :         obs.instance = boost::bind(&ConfigUpdater::ProcessInstanceConfig,
      55          20 :             this, _1, _2);
      56             :         obs.protocol = boost::bind(&ConfigUpdater::ProcessProtocolConfig,
      57          20 :             this, _1, _2);
      58             :         obs.neighbor = boost::bind(&ConfigUpdater::ProcessNeighborConfig,
      59          20 :             this, _1, _2);
      60             :         obs.policy = boost::bind(&ConfigUpdater::ProcessRoutingPolicyConfig,
      61          20 :             this, _1, _2);
      62             :         obs.system= boost::bind(&ConfigUpdater::ProcessGlobalSystemConfig,
      63          20 :             this, _1, _2);
      64             :         obs.qos = boost::bind(&ConfigUpdater::ProcessGlobalQosConfig,
      65          20 :             this, _1, _2);
      66          20 :         server->config_manager()->RegisterObservers(obs);
      67          20 :     }
      68             : 
      69           0 :     void ProcessGlobalQosConfig(const BgpGlobalQosConfig *qos,
      70             :         BgpConfigManager::EventType event) {
      71           0 :         if (qos->control_dscp() != server_->global_qos()->control_dscp()) {
      72           0 :             server_->global_qos()->set_control_dscp(qos->control_dscp());
      73           0 :             server_->NotifyDSCPUpdate(qos->control_dscp());
      74             :         }
      75           0 :         server_->global_qos()->set_analytics_dscp(qos->analytics_dscp());
      76           0 :     }
      77             : 
      78          30 :     void ProcessGlobalSystemConfig(const BgpGlobalSystemConfig *new_config,
      79             :             BgpConfigManager::EventType event) {
      80          30 :         bool clear_peers = false;
      81             : 
      82          30 :         if (server_->global_config()->gr_enable() != new_config->gr_enable()) {
      83          30 :             server_->global_config()->set_gr_enable(new_config->gr_enable());
      84          30 :             clear_peers = true;
      85             :         }
      86          30 :         if (server_->global_config()->gr_time() != new_config->gr_time()) {
      87          30 :             server_->global_config()->set_gr_time(new_config->gr_time());
      88          30 :             clear_peers = true;
      89             :         }
      90          30 :         if (server_->global_config()->llgr_time() != new_config->llgr_time()) {
      91          30 :             server_->global_config()->set_llgr_time(new_config->llgr_time());
      92          30 :             clear_peers = true;
      93             :         }
      94          60 :         if (server_->global_config()->end_of_rib_timeout() !=
      95          30 :                 new_config->end_of_rib_timeout()) {
      96          60 :             server_->global_config()->set_end_of_rib_timeout(
      97          30 :                 new_config->end_of_rib_timeout());
      98          30 :             clear_peers = true;
      99             :         }
     100          60 :         if (server_->global_config()->gr_bgp_helper() !=
     101          30 :                 new_config->gr_bgp_helper()) {
     102          60 :             server_->global_config()->set_gr_bgp_helper(
     103          30 :                 new_config->gr_bgp_helper());
     104          30 :             clear_peers = true;
     105             :         }
     106          60 :         if (server_->global_config()->enable_4byte_as() !=
     107          30 :                 new_config->enable_4byte_as()) {
     108           0 :             server_->global_config()->set_enable_4byte_as(
     109           0 :                 new_config->enable_4byte_as());
     110           0 :             clear_peers = true;
     111             :         }
     112             : 
     113          60 :         if (server_->global_config()->fc_enabled() !=
     114          30 :                 new_config->fc_enabled()) {
     115           0 :             server_->global_config()->set_fc_enabled(
     116           0 :                 new_config->fc_enabled());
     117           0 :             clear_peers = true;
     118             :         }
     119             : 
     120          60 :         if (server_->global_config()->nh_check_enabled() !=
     121          30 :                 new_config->nh_check_enabled()) {
     122           0 :             server_->global_config()->set_nh_check_enabled(
     123           0 :                 new_config->nh_check_enabled());
     124           0 :             clear_peers = true;
     125             :         }
     126             : 
     127             :         // Clear peers if there's a change in always-compare-med knob.
     128          60 :         if (server_->global_config()->always_compare_med() !=
     129          30 :             new_config->always_compare_med()) {
     130           0 :             server_->global_config()->set_always_compare_med(
     131           0 :                 new_config->always_compare_med());
     132           0 :             clear_peers = true;
     133             :         }
     134             : 
     135             :         // Process a change in rd-cluster-seed knob.
     136          60 :         if (server_->global_config()->rd_cluster_seed() !=
     137          30 :             new_config->rd_cluster_seed()) {
     138           0 :           server_->global_config()->set_rd_cluster_seed(
     139           0 :               new_config->rd_cluster_seed());
     140             :         }
     141             : 
     142             :         // Process a change in xmpp-hold-time knob.
     143          60 :         if (server_->global_config()->xmpp_hold_time() !=
     144          30 :             new_config->xmpp_hold_time()) {
     145           0 :           server_->global_config()->set_xmpp_hold_time(
     146           0 :               new_config->xmpp_hold_time());
     147             :         }
     148             : 
     149             :         // Process a change in all-tags-are-global knob.
     150          60 :         if (server_->global_config()->all_tags_are_global() !=
     151          30 :             new_config->all_tags_are_global()) {
     152           0 :           server_->global_config()->set_all_tags_are_global(
     153           0 :               new_config->all_tags_are_global());
     154             :         }
     155             : 
     156          30 :         bool clear_bgpaas_peers = false;
     157             : 
     158             :         // Clear bgpaas peers if there's a change in bgpaas-port-start.
     159          60 :         if (server_->global_config()->bgpaas_port_start() !=
     160          30 :                 new_config->bgpaas_port_start()) {
     161          40 :             server_->global_config()->set_bgpaas_port_start(
     162          20 :                 new_config->bgpaas_port_start());
     163          20 :             clear_bgpaas_peers = true;
     164             :         }
     165             : 
     166             :         // Clear bgpaas peers if there's a change in bgpaas-port-end.
     167          60 :         if (server_->global_config()->bgpaas_port_end() !=
     168          30 :                 new_config->bgpaas_port_end()) {
     169          40 :             server_->global_config()->set_bgpaas_port_end(
     170          20 :                 new_config->bgpaas_port_end());
     171          20 :             clear_bgpaas_peers = true;
     172             :         }
     173             : 
     174          30 :         if (clear_peers) {
     175          30 :             RoutingInstanceMgr *ri_mgr = server_->routing_instance_mgr();
     176          30 :             RoutingInstance *rti = ri_mgr->GetDefaultRoutingInstance();
     177          30 :             assert(rti);
     178          30 :             PeerManager *peer_manager = rti->LocatePeerManager();
     179          30 :             peer_manager->ClearAllPeers();
     180             :         }
     181             : 
     182          30 :         if (clear_peers || clear_bgpaas_peers)
     183          30 :             server_->ClearBgpaaSPeers();
     184          30 :     }
     185             : 
     186          20 :     void ProcessProtocolConfig(const BgpProtocolConfig *protocol_config,
     187             :                                BgpConfigManager::EventType event) {
     188          20 :         const string &instance_name = protocol_config->instance_name();
     189             : 
     190             :         // We only support BGP sessions in master instance for now.
     191          20 :         if (instance_name != BgpConfigManager::kMasterInstance) {
     192           0 :             return;
     193             :         }
     194             : 
     195          20 :         if (event == BgpConfigManager::CFG_ADD ||
     196             :             event == BgpConfigManager::CFG_CHANGE) {
     197          20 :             BgpServerConfigUpdate(instance_name, protocol_config);
     198           0 :         } else if (event == BgpConfigManager::CFG_DELETE) {
     199           0 :             BgpServerConfigUpdate(instance_name, NULL);
     200             :         } else {
     201           0 :             assert(false);
     202             :         }
     203             :     }
     204             : 
     205          20 :     void BgpServerConfigUpdate(string instance_name,
     206             :                                const BgpProtocolConfig *config) {
     207          20 :         boost::system::error_code ec;
     208          20 :         uint32_t config_identifier = 0;
     209          20 :         uint32_t config_autonomous_system = 0;
     210          20 :         uint32_t config_local_autonomous_system = 0;
     211          20 :         uint32_t config_hold_time = 0;
     212          20 :         uint32_t config_cluster_id = 0;
     213          20 :         bool config_admin_down = false;
     214          20 :         if (config) {
     215          20 :             config_admin_down = config->admin_down();
     216          20 :             config_identifier = config->identifier();
     217          20 :             config_autonomous_system = config->autonomous_system();
     218          20 :             config_local_autonomous_system = config->local_autonomous_system();
     219          20 :             config_cluster_id = config->cluster_id();
     220          20 :             config_hold_time = config->hold_time();
     221             :         }
     222             : 
     223          20 :         if (server_->admin_down_ != config_admin_down) {
     224           0 :             if (server_->admin_down_) {
     225           0 :                 BGP_LOG_STR(BgpConfig, SandeshLevel::SYS_DEBUG,
     226             :                             BGP_LOG_FLAG_SYSLOG, "Updated Admin Down from " <<
     227             :                             boolalpha << server_->admin_down_ << noboolalpha <<
     228             :                             " to " <<
     229             :                             boolalpha << config_admin_down << noboolalpha);
     230             :             } else {
     231           0 :                 BGP_LOG_NOTICE_STR(BgpConfig, BGP_LOG_FLAG_SYSLOG,
     232             :                             "Updated Admin Down from " <<
     233             :                             boolalpha << server_->admin_down_ << noboolalpha <<
     234             :                             " to " <<
     235             :                             boolalpha << config_admin_down << noboolalpha);
     236             :             }
     237           0 :             server_->admin_down_ = config_admin_down;
     238           0 :             if (server_->admin_down_)
     239           0 :                 server_->NotifyAdminDown();
     240             :         }
     241             : 
     242             :         // We currently do not support bind failures or changes to listen port
     243             :         // in production mode.
     244          20 :         if (config && !server_->session_manager()->Initialize(config->port()) &&
     245           0 :                 !bgp_log_test::unit_test()) {
     246             :             // Disable core file generation and exit.
     247             :             rlimit new_core_limit;
     248           0 :             new_core_limit.rlim_cur = 0;
     249           0 :             new_core_limit.rlim_max = 0;
     250           0 :             setrlimit(RLIMIT_CORE, &new_core_limit);
     251           0 :             BGP_LOG_WARNING_STR(BgpConfig, BGP_LOG_FLAG_SYSLOG,
     252             :                 "Process exit! due to tcp server port " << config->port() <<
     253             :                 " bind failure");
     254           0 :             if (!bgp_log_test::unit_test())
     255           0 :                 kill(getpid(), SIGTERM);
     256             :         }
     257             : 
     258          20 :         Ip4Address identifier(ntohl(config_identifier));
     259          20 :         if (server_->bgp_identifier_ != identifier) {
     260          20 :             if (!server_->bgp_identifier_.is_unspecified()) {
     261           0 :                 BGP_LOG_NOTICE_STR(BgpConfig, BGP_LOG_FLAG_SYSLOG,
     262             :                             "Updated Router ID from " <<
     263             :                             server_->bgp_identifier_.to_string() << " to " <<
     264             :                             identifier.to_string());
     265             :             } else {
     266          20 :                 BGP_LOG_STR(BgpConfig, SandeshLevel::SYS_DEBUG,
     267             :                              BGP_LOG_FLAG_SYSLOG, "Updated Router ID from " <<
     268             :                             server_->bgp_identifier_.to_string() << " to " <<
     269             :                             identifier.to_string());
     270             :             }
     271          20 :             server_->UpdateBgpIdentifier(identifier);
     272             :         }
     273             : 
     274          20 :         bool notify_asn_update = false;
     275          20 :         uint32_t old_asn = server_->autonomous_system_;
     276          20 :         uint32_t old_local_asn = server_->local_autonomous_system_;
     277          20 :         server_->autonomous_system_ = config_autonomous_system;
     278          20 :         if (config_local_autonomous_system) {
     279           0 :             server_->local_autonomous_system_ = config_local_autonomous_system;
     280             :         } else {
     281          20 :             server_->local_autonomous_system_ = config_autonomous_system;
     282             :         }
     283             : 
     284          20 :         if (server_->autonomous_system_ != old_asn) {
     285          20 :             if (old_asn != 0) {
     286           0 :                 BGP_LOG_NOTICE_STR(BgpConfig, BGP_LOG_FLAG_SYSLOG,
     287             :                             "Updated Autonomous System from " << old_asn <<
     288             :                             " to " << server_->autonomous_system_);
     289             :             } else {
     290          20 :                 BGP_LOG_STR(BgpConfig, SandeshLevel::SYS_DEBUG,
     291             :                             BGP_LOG_FLAG_SYSLOG,
     292             :                             "Updated Autonomous System from " << old_asn <<
     293             :                             " to " << server_->autonomous_system_);
     294             :             }
     295          20 :             notify_asn_update = true;
     296             :         }
     297             : 
     298          20 :         if (server_->local_autonomous_system_ != old_local_asn) {
     299          20 :             if (old_local_asn != 0) {
     300           0 :                 BGP_LOG_NOTICE_STR(BgpConfig, BGP_LOG_FLAG_SYSLOG,
     301             :                             "Updated Local Autonomous System from " <<
     302             :                             old_local_asn << " to " <<
     303             :                             server_->local_autonomous_system_);
     304             :             } else {
     305          20 :                 BGP_LOG_STR(BgpConfig, SandeshLevel::SYS_DEBUG,
     306             :                             BGP_LOG_FLAG_SYSLOG,
     307             :                             "Updated Local Autonomous System from " <<
     308             :                             old_local_asn << " to " <<
     309             :                             server_->local_autonomous_system_);
     310             :             }
     311          20 :             notify_asn_update = true;
     312             :         }
     313             : 
     314          20 :         if (notify_asn_update) {
     315          20 :             server_->NotifyASNUpdate(old_asn, old_local_asn);
     316             :         }
     317             : 
     318          20 :         if (server_->hold_time_ != config_hold_time) {
     319           0 :             BGP_LOG_STR(BgpConfig, SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_SYSLOG,
     320             :                         "Updated Hold Time from " <<
     321             :                         server_->hold_time_ << " to " << config_hold_time);
     322           0 :             server_->hold_time_ = config_hold_time;
     323             :         }
     324             : 
     325          20 :         if (server_->cluster_id() != config_cluster_id) {
     326           0 :             BGP_LOG_STR(BgpConfig, SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_SYSLOG,
     327             :                         "Updated Cluster Id from " <<
     328             :                         server_->cluster_id() << " to " << config_cluster_id);
     329           0 :             server_->set_cluster_id(config_cluster_id);
     330           0 :             RoutingInstanceMgr *ri_mgr = server_->routing_instance_mgr();
     331           0 :             RoutingInstance *rti = ri_mgr->GetDefaultRoutingInstance();
     332           0 :             assert(rti);
     333           0 :             PeerManager *peer_manager = rti->LocatePeerManager();
     334           0 :             peer_manager->ClearAllInternalPeers();
     335             :         }
     336             : 
     337          20 :         ConnectionState::GetInstance()->Update();
     338          20 :     }
     339             : 
     340          32 :     void ProcessNeighborConfig(const BgpNeighborConfig *neighbor_config,
     341             :                                BgpConfigManager::EventType event) {
     342          32 :         string instance_name = neighbor_config->instance_name();
     343          32 :         RoutingInstanceMgr *ri_mgr = server_->routing_instance_mgr();
     344          32 :         RoutingInstance *rti = ri_mgr->GetRoutingInstance(instance_name);
     345          32 :         if (!rti)
     346           0 :             return;
     347             : 
     348          32 :         if (event == BgpConfigManager::CFG_ADD ||
     349             :             event == BgpConfigManager::CFG_CHANGE) {
     350          32 :             if (rti->deleted())
     351           0 :                 return;
     352          32 :             PeerManager *peer_manager = rti->LocatePeerManager();
     353          32 :             BgpPeer *peer = peer_manager->PeerLocate(server_, neighbor_config);
     354          32 :             if (peer) {
     355          32 :                 server_->RemovePeer(peer->endpoint(), peer);
     356          32 :                 peer->ConfigUpdate(neighbor_config);
     357          32 :                 server_->InsertPeer(peer->endpoint(), peer);
     358             :             }
     359          32 :         } else if (event == BgpConfigManager::CFG_DELETE) {
     360           0 :             PeerManager *peer_manager = rti->peer_manager();
     361           0 :             if (!peer_manager)
     362           0 :                 return;
     363           0 :             BgpPeer *peer = peer_manager->TriggerPeerDeletion(neighbor_config);
     364           0 :             if (peer) {
     365           0 :                 server_->RemovePeer(peer->endpoint(), peer);
     366             :             }
     367             :         }
     368          32 :     }
     369             : 
     370           0 :     void ProcessRoutingPolicyConfig(const BgpRoutingPolicyConfig *policy_config,
     371             :                                     BgpConfigManager::EventType event) {
     372           0 :         RoutingPolicyMgr *mgr = server_->routing_policy_mgr();
     373           0 :         if (event == BgpConfigManager::CFG_ADD) {
     374           0 :             mgr->CreateRoutingPolicy(policy_config);
     375           0 :         } else if (event == BgpConfigManager::CFG_CHANGE) {
     376           0 :             mgr->UpdateRoutingPolicy(policy_config);
     377           0 :         } else if (event == BgpConfigManager::CFG_DELETE) {
     378           0 :             mgr->DeleteRoutingPolicy(policy_config->name());
     379             :         }
     380           0 :     }
     381             : 
     382         300 :     void ProcessInstanceConfig(const BgpInstanceConfig *instance_config,
     383             :                                BgpConfigManager::EventType event) {
     384         300 :         RoutingInstanceMgr *mgr = server_->routing_instance_mgr();
     385         300 :         if (event == BgpConfigManager::CFG_ADD ||
     386             :             event == BgpConfigManager::CFG_CHANGE) {
     387         300 :             mgr->LocateRoutingInstance(instance_config->name());
     388           0 :         } else if (event == BgpConfigManager::CFG_DELETE) {
     389           0 :             mgr->DeleteRoutingInstance(instance_config->name());
     390             :         }
     391         300 :     }
     392             : 
     393             : private:
     394             :     BgpServer *server_;
     395             : };
     396             : 
     397             : class BgpServer::DeleteActor : public LifetimeActor {
     398             : public:
     399          20 :     explicit DeleteActor(BgpServer *server)
     400          20 :         : LifetimeActor(server->lifetime_manager()), server_(server) {
     401          20 :     }
     402          20 :     virtual bool MayDelete() const {
     403          20 :         CHECK_CONCURRENCY("bgp::Config");
     404          20 :         return server_->session_manager()->MayDelete();
     405             :     }
     406          20 :     virtual void Shutdown() {
     407          20 :         CHECK_CONCURRENCY("bgp::Config");
     408          20 :         server_->session_manager()->Shutdown();
     409          20 :     }
     410          20 :     virtual void Destroy() {
     411          20 :         CHECK_CONCURRENCY("bgp::Config");
     412          20 :         server_->config_manager()->Terminate();
     413          20 :         server_->session_manager()->Terminate();
     414          20 :         TcpServerManager::DeleteServer(server_->session_manager());
     415          20 :         server_->session_mgr_ = NULL;
     416          20 :         server_->set_destroyed();
     417          20 :     }
     418             : 
     419             : private:
     420             :     BgpServer *server_;
     421             : };
     422             : 
     423         688 : bool BgpServer::IsDeleted() const {
     424         688 :     return deleter_->IsDeleted();
     425             : }
     426             : 
     427           0 : void BgpServer::RetryDelete() {
     428           0 :     if (!deleter_->IsDeleted())
     429           0 :         return;
     430           0 :     deleter_->RetryDelete();
     431             : }
     432             : 
     433        4192 : bool BgpServer::IsReadyForDeletion() {
     434        4192 :     CHECK_CONCURRENCY("bgp::Config");
     435             : 
     436        4192 :     static TaskScheduler *scheduler = TaskScheduler::GetInstance();
     437        4192 :     static int db_table_task_id = scheduler->GetTaskId("db::DBTable");
     438             :     static int resolver_path_task_id =
     439        4192 :         scheduler->GetTaskId("bgp::ResolverPath");
     440             :     static int resolver_nexthop_task_id =
     441        4192 :         scheduler->GetTaskId("bgp::ResolverNexthop");
     442             : 
     443             :     // Check if any PathResolver is active.
     444             :     // Need to ensure that there's no pending deletes of BgpPaths added by
     445             :     // PathResolver since they hold pointers to IPeer.
     446        8384 :     if (!scheduler->IsTaskGroupEmpty(resolver_path_task_id) ||
     447        4192 :         !scheduler->IsTaskGroupEmpty(resolver_nexthop_task_id)) {
     448           0 :         return false;
     449             :     }
     450             : 
     451             :     // Check if the membership manager queue is empty.
     452        4192 :     if (!membership_mgr_->IsQueueEmpty()) {
     453         854 :         return false;
     454             :     }
     455             : 
     456             :     // Check if the Service Chain Manager Work Queues are empty.
     457        3338 :     if (!inet_service_chain_mgr_->IsQueueEmpty() ||
     458        3338 :         !inet6_service_chain_mgr_->IsQueueEmpty() ||
     459       10014 :         !evpn_service_chain_mgr_->IsQueueEmpty() ||
     460        3338 :         !evpn6_service_chain_mgr_->IsQueueEmpty()) {
     461           0 :         return false;
     462             :     }
     463             : 
     464             :     // Check if the DB requests queue and change list is empty.
     465        3338 :     if (!db_.IsDBQueueEmpty()) {
     466          21 :         return false;
     467             :     }
     468             : 
     469             :     // Check if the RTargetGroupManager has processed all RTargetRoute updates.
     470             :     // This is done to ensure that the InterestedPeerList of RtargetGroup gets
     471             :     // updated before allowing the peer to get deleted.
     472        3317 :     if (!rtarget_group_mgr_->IsRTargetRoutesProcessed()) {
     473           1 :         return false;
     474             :     }
     475             : 
     476             :     // Check if any db::DBTable task is active.
     477             :     // Need to ensure that there's no pending deletes of BgpPaths added by
     478             :     // the Evpn aliasing module since they hold pointers to IPeer.
     479        3316 :     if (!scheduler->IsTaskGroupEmpty(db_table_task_id)) {
     480         161 :         return false;
     481             :     }
     482             : 
     483        3155 :     return true;
     484             : }
     485             : 
     486          20 : BgpServer::BgpServer(EventManager *evm)
     487          20 :     : admin_down_(false),
     488          20 :       cluster_id_(0),
     489          20 :       autonomous_system_(0),
     490          20 :       local_autonomous_system_(0),
     491          20 :       bgp_identifier_(0),
     492          20 :       bgp_identifier_u32_(0),
     493          20 :       hold_time_(0),
     494          20 :       gr_helper_disable_(false),
     495          20 :       lifetime_manager_(BgpStaticObjectFactory::Create<BgpLifetimeManager>(this,
     496             :           TaskScheduler::GetInstance()->GetTaskId("bgp::Config"))),
     497          20 :       deleter_(new DeleteActor(this)),
     498          20 :       destroyed_(false),
     499          20 :       logging_disabled_(false),
     500          20 :       mvpn_ipv4_enable_(false),
     501          20 :       ignore_aspath_(false),
     502          20 :       aspath_db_(new AsPathDB(this)),
     503          20 :       aspath_4byte_db_(new AsPath4ByteDB(this)),
     504          20 :       as4path_db_(new As4PathDB(this)),
     505          20 :       olist_db_(new BgpOListDB(this)),
     506          20 :       cluster_list_db_(new ClusterListDB(this)),
     507          20 :       comm_db_(new CommunityDB(this)),
     508          20 :       edge_discovery_db_(new EdgeDiscoveryDB(this)),
     509          20 :       edge_forwarding_db_(new EdgeForwardingDB(this)),
     510          20 :       extcomm_db_(new ExtCommunityDB(this)),
     511          20 :       largecomm_db_(new LargeCommunityDB(this)),
     512          20 :       ovnpath_db_(new OriginVnPathDB(this)),
     513          20 :       pmsi_tunnel_db_(new PmsiTunnelDB(this)),
     514          20 :       attr_db_(new BgpAttrDB(this)),
     515          20 :       session_mgr_(BgpStaticObjectFactory::Create<BgpSessionManager>(evm, this)),
     516          20 :       update_sender_(new BgpUpdateSender(this)),
     517          20 :       inst_mgr_(BgpStaticObjectFactory::Create<RoutingInstanceMgr>(this)),
     518          20 :       policy_mgr_(BgpStaticObjectFactory::Create<RoutingPolicyMgr>(this)),
     519          20 :       rtarget_group_mgr_(BgpStaticObjectFactory::Create<RTargetGroupMgr>(this)),
     520          20 :       membership_mgr_(BgpStaticObjectFactory::Create<BgpMembershipManager>(this)),
     521          20 :       inet_condition_listener_(new BgpConditionListener(this)),
     522          20 :       inet6_condition_listener_(new BgpConditionListener(this)),
     523          20 :       evpn_condition_listener_(new BgpConditionListener(this)),
     524          20 :       evpn6_condition_listener_(new BgpConditionListener(this)),
     525          20 :       inetvpn_replicator_(new RoutePathReplicator(this, Address::INETVPN)),
     526          20 :       ermvpn_replicator_(new RoutePathReplicator(this, Address::ERMVPN)),
     527          20 :       mvpn_replicator_(new RoutePathReplicator(this, Address::MVPN)),
     528          20 :       evpn_replicator_(new RoutePathReplicator(this, Address::EVPN)),
     529          20 :       inet6vpn_replicator_(new RoutePathReplicator(this, Address::INET6VPN)),
     530          20 :       inet_service_chain_mgr_(
     531          20 :           BgpStaticObjectFactory::Create<IServiceChainMgr, SCAddress::INET>(this)),
     532          20 :       inet6_service_chain_mgr_(
     533          20 :           BgpStaticObjectFactory::Create<IServiceChainMgr, SCAddress::INET6>(this)),
     534          20 :       evpn_service_chain_mgr_(
     535          20 :           BgpStaticObjectFactory::Create<IServiceChainMgr, SCAddress::EVPN>(this)),
     536          20 :       evpn6_service_chain_mgr_(
     537          20 :           BgpStaticObjectFactory::Create<IServiceChainMgr, SCAddress::EVPN6>(this)),
     538          20 :       global_config_(new BgpGlobalSystemConfig()),
     539          20 :       global_qos_(new BgpGlobalQosConfig()),
     540          20 :       config_mgr_(BgpStaticObjectFactory::Create<BgpConfigManager>(this)),
     541          60 :       updater_(new ConfigUpdater(this)) {
     542          20 :     bgp_count_ = 0;
     543          20 :     num_up_peer_ = 0;
     544          20 :     deleting_count_ = 0;
     545          20 :     bgpaas_count_ = 0;
     546          20 :     num_up_bgpaas_peer_ = 0;
     547          20 :     deleting_bgpaas_count_ = 0;
     548          20 :     message_build_error_ = 0;
     549          20 : }
     550             : 
     551          20 : BgpServer::~BgpServer() {
     552          20 :     assert(deleting_count_ == 0);
     553          20 :     assert(deleting_bgpaas_count_ == 0);
     554          20 :     assert(srt_manager_list_.empty());
     555          20 : }
     556             : 
     557           2 : void BgpServer::Initialize() {
     558           2 :     RibOutUpdates::Initialize();
     559           2 : }
     560             : 
     561           1 : void BgpServer::Terminate() {
     562           1 :     RibOutUpdates::Terminate();
     563           1 : }
     564             : 
     565      141005 : string BgpServer::ToString() const {
     566      141005 :     return bgp_identifier_.to_string();
     567             : }
     568             : 
     569          20 : void BgpServer::Shutdown() {
     570          20 :     deleter_->Delete();
     571          20 : }
     572             : 
     573         120 : LifetimeActor *BgpServer::deleter() {
     574         120 :     return deleter_.get();
     575             : }
     576             : 
     577         120 : bool BgpServer::HasSelfConfiguration() const {
     578         120 :     if (!bgp_identifier_u32())
     579           0 :         return false;
     580         120 :     if (!local_autonomous_system())
     581           0 :         return false;
     582         120 :     if (!autonomous_system())
     583           0 :         return false;
     584         120 :     return true;
     585             : }
     586             : 
     587          32 : int BgpServer::RegisterPeer(BgpPeer *peer) {
     588          32 :     CHECK_CONCURRENCY("bgp::Config");
     589             : 
     590          32 :     if (peer->IsRouterTypeBGPaaS()) {
     591           0 :         bgpaas_count_++;
     592             :     } else {
     593          32 :         bgp_count_++;
     594             :     }
     595             : 
     596          32 :     BgpPeerList::iterator loc;
     597             :     bool result;
     598          32 :     tie(loc, result) = peer_list_.insert(make_pair(peer->peer_name(), peer));
     599          32 :     assert(result);
     600          32 :     assert(loc->second == peer);
     601             : 
     602          32 :     size_t bit = peer_bmap_.find_first();
     603          32 :     if (bit == peer_bmap_.npos) {
     604          32 :         bit = peer_bmap_.size();
     605          32 :         peer_bmap_.resize(bit + 1, true);
     606             :     }
     607          32 :     peer_bmap_.reset(bit);
     608          32 :     return bit;
     609             : }
     610             : 
     611          32 : void BgpServer::UnregisterPeer(BgpPeer *peer) {
     612          32 :     CHECK_CONCURRENCY("bgp::Config");
     613             : 
     614          32 :     if (peer->IsRouterTypeBGPaaS()) {
     615           0 :         assert(bgpaas_count_);
     616           0 :         bgpaas_count_--;
     617             :     } else {
     618          32 :         assert(bgp_count_);
     619          32 :         bgp_count_--;
     620             :     }
     621             : 
     622          32 :     BgpPeerList::iterator loc = peer_list_.find(peer->peer_name());
     623          32 :     assert(loc != peer_list_.end());
     624          32 :     peer_list_.erase(loc);
     625             : 
     626          32 :     peer_bmap_.set(peer->GetIndex());
     627          64 :     for (size_t i = peer_bmap_.size(); i != 0; i--) {
     628          44 :         if (peer_bmap_[i-1] != true) {
     629          12 :             if (i != peer_bmap_.size()) {
     630           3 :                 peer_bmap_.resize(i);
     631             :             }
     632          12 :             return;
     633             :         }
     634             :     }
     635          20 :     peer_bmap_.clear();
     636             : }
     637             : 
     638           0 : BgpPeer *BgpServer::FindPeer(const string &name) {
     639           0 :     BgpPeerList::iterator loc = peer_list_.find(name);
     640           0 :     return (loc != peer_list_.end() ? loc->second : NULL);
     641             : }
     642             : 
     643           0 : BgpPeer *BgpServer::FindNextPeer(const string &name) {
     644           0 :     BgpPeerList::iterator loc = peer_list_.upper_bound(name);
     645           0 :     return (loc != peer_list_.end() ? loc->second : NULL);
     646             : }
     647             : 
     648          32 : void BgpServer::InsertPeer(TcpSession::Endpoint remote, BgpPeer *peer) {
     649          32 :     if (!remote.port() && remote.address().is_unspecified())
     650          32 :         return;
     651           0 :     endpoint_peer_list_.insert(make_pair(remote, peer));
     652             : }
     653             : 
     654          32 : void BgpServer::RemovePeer(TcpSession::Endpoint remote, BgpPeer *peer) {
     655          32 :     EndpointPeerList::iterator loc = endpoint_peer_list_.lower_bound(remote);
     656          32 :     while (loc != endpoint_peer_list_.end() && loc->first == remote) {
     657           0 :         if (loc->second == peer) {
     658           0 :             endpoint_peer_list_.erase(loc);
     659           0 :             break;
     660             :         }
     661           0 :         ++loc;
     662             :     }
     663          32 : }
     664             : 
     665          30 : void BgpServer::ClearBgpaaSPeers() {
     666          30 :     for (auto &i : endpoint_peer_list_) {
     667           0 :         i.second->Clear(BgpProto::Notification::OtherConfigChange);
     668             :     }
     669          30 : }
     670             : 
     671           0 : BgpPeer *BgpServer::FindPeer(TcpSession::Endpoint remote) const {
     672           0 :     EndpointPeerList::const_iterator loc = endpoint_peer_list_.find(remote);
     673           0 :     return (loc == endpoint_peer_list_.end() ? NULL : loc->second);
     674             : }
     675             : 
     676           0 : BgpPeer *BgpServer::FindExactPeer(const BgpPeer *peer) const {
     677             :     EndpointPeerList::const_iterator loc =
     678           0 :         endpoint_peer_list_.lower_bound(peer->endpoint());
     679           0 :     while (loc != endpoint_peer_list_.end() && loc->first == peer->endpoint()) {
     680           0 :         if (loc->second == peer)
     681           0 :             return loc->second;
     682           0 :         ++loc;
     683             :     }
     684           0 :     return NULL;
     685             : }
     686             : 
     687        1325 : const string &BgpServer::localname() const {
     688        1325 :     return config_mgr_->localname();
     689             : }
     690             : 
     691        1224 : boost::asio::io_context *BgpServer::ioservice() {
     692        1224 :     return session_manager()->event_manager()->io_service();
     693             : }
     694             : 
     695           0 : bool BgpServer::IsFastConvergenceEnabled() const {
     696           0 :     return (global_config_->fc_enabled());
     697             : }
     698             : 
     699       36189 : bool BgpServer::IsNextHopCheckEnabled() const {
     700       36189 :     if (!global_config_->fc_enabled())
     701       36182 :         return false;
     702           0 :     return (global_config_->nh_check_enabled());
     703             : }
     704             : 
     705         162 : uint16_t BgpServer::GetGracefulRestartTime() const {
     706         162 :     if (!global_config_->gr_enable())
     707           0 :         return 0;
     708         162 :     return global_config_->gr_time();
     709             : }
     710             : 
     711         324 : uint32_t BgpServer::GetLongLivedGracefulRestartTime() const {
     712         324 :     if (!global_config_->gr_enable())
     713           0 :         return 0;
     714         324 :     return global_config_->llgr_time();
     715             : }
     716             : 
     717           0 : uint16_t BgpServer::GetXmppHoldTime() const {
     718           0 :     if (!global_config_->fc_enabled())
     719           0 :         return XMPP_HOLD_TIME_DEFAULT;
     720           0 :     return global_config_->xmpp_hold_time();
     721             : }
     722             : 
     723         584 : uint32_t BgpServer::GetEndOfRibReceiveTime() const {
     724         584 :     return global_config_->end_of_rib_timeout();
     725             : }
     726             : 
     727         188 : uint32_t BgpServer::GetEndOfRibSendTime() const {
     728         188 :     return global_config_->end_of_rib_timeout();
     729             : }
     730             : 
     731         188 : bool BgpServer::IsServerStartingUp() const {
     732         188 :     return MiscUtils::GetUpTimeSeconds() < 0.20 * GetEndOfRibSendTime();
     733             : }
     734             : 
     735       12696 : bool BgpServer::enable_4byte_as() const {
     736       12696 :     return global_config()->enable_4byte_as();
     737             : }
     738             : 
     739           0 : void BgpServer::set_enable_4byte_as(bool flag) {
     740           0 :     global_config()->set_enable_4byte_as(flag);
     741           0 : }
     742             : 
     743         391 : bool BgpServer::IsGRHelperModeEnabled() const {
     744             : 
     745             :     // Check if disabled in .conf file.
     746         391 :     if (gr_helper_disable_)
     747         176 :         return false;
     748             : 
     749             :     // Check if GR is disabled..
     750         215 :     if (!global_config_->gr_enable())
     751          48 :         return false;
     752             : 
     753             :     // Check from configuration.
     754         168 :     return global_config_->gr_bgp_helper();
     755             : }
     756             : 
     757           0 : uint32_t BgpServer::num_routing_instance() const {
     758           0 :     assert(inst_mgr_.get());
     759           0 :     return inst_mgr_->count();
     760             : }
     761             : 
     762           0 : uint32_t BgpServer::num_deleted_routing_instance() const {
     763           0 :     assert(inst_mgr_.get());
     764           0 :     return inst_mgr_->deleted_count();
     765             : }
     766             : 
     767           0 : uint32_t BgpServer::get_output_queue_depth() const {
     768           0 :     uint32_t out_q_depth = 0;
     769           0 :     for (RoutingInstanceMgr::RoutingInstanceIterator rit = inst_mgr_->begin();
     770           0 :          rit != inst_mgr_->end(); ++rit) {
     771             :         RoutingInstance::RouteTableList const rt_list =
     772           0 :                      rit->second->GetTables();
     773           0 :         for (RoutingInstance::RouteTableList::const_iterator it =
     774           0 :              rt_list.begin(); it != rt_list.end(); ++it) {
     775           0 :             BgpTable *table = it->second;
     776             :             size_t markers;
     777           0 :             out_q_depth += table->GetPendingRiboutsCount(&markers);
     778             :         }
     779           0 :     }
     780           0 :     return out_q_depth;
     781             : }
     782             : 
     783           0 : uint32_t BgpServer::num_service_chains() const {
     784           0 :     return inet_service_chain_mgr_->PendingQueueSize() +
     785           0 :         inet_service_chain_mgr_->ResolvedQueueSize() +
     786           0 :         inet6_service_chain_mgr_->PendingQueueSize() +
     787           0 :         inet6_service_chain_mgr_->ResolvedQueueSize() +
     788           0 :         evpn_service_chain_mgr_->PendingQueueSize() +
     789           0 :         evpn_service_chain_mgr_->ResolvedQueueSize() +
     790           0 :         evpn6_service_chain_mgr_->PendingQueueSize() +
     791           0 :         evpn6_service_chain_mgr_->ResolvedQueueSize();
     792             : }
     793             : 
     794           0 : uint32_t BgpServer::num_down_service_chains() const {
     795           0 :     return inet_service_chain_mgr_->PendingQueueSize() +
     796           0 :         inet_service_chain_mgr_->GetDownServiceChainCount() +
     797           0 :         inet6_service_chain_mgr_->PendingQueueSize() +
     798           0 :         inet6_service_chain_mgr_->GetDownServiceChainCount() +
     799           0 :         evpn_service_chain_mgr_->PendingQueueSize() +
     800           0 :         evpn_service_chain_mgr_->GetDownServiceChainCount() +
     801           0 :         evpn6_service_chain_mgr_->PendingQueueSize() +
     802           0 :         evpn6_service_chain_mgr_->GetDownServiceChainCount();
     803             : }
     804             : 
     805           0 : uint32_t BgpServer::num_static_routes() const {
     806           0 :     return GetStaticRouteCount();
     807             : }
     808             : 
     809           0 : uint32_t BgpServer::num_down_static_routes() const {
     810           0 :     return GetDownStaticRouteCount();
     811             : }
     812             : 
     813           0 : void BgpServer::VisitBgpPeers(BgpServer::VisitorFn fn) const {
     814           0 :     for (BgpPeerList::const_iterator loc = peer_list_.begin();
     815           0 :          loc != peer_list_.end(); ++loc) {
     816           0 :         fn(loc->second);
     817             :     }
     818           0 : }
     819             : 
     820          20 : int BgpServer::RegisterAdminDownCallback(AdminDownCb callback) {
     821          20 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     822          20 :     size_t i = admin_down_bmap_.find_first();
     823          20 :     if (i == admin_down_bmap_.npos) {
     824          20 :         i = admin_down_listeners_.size();
     825          20 :         admin_down_listeners_.push_back(callback);
     826             :     } else {
     827           0 :         admin_down_bmap_.reset(i);
     828           0 :         if (admin_down_bmap_.none()) {
     829           0 :             admin_down_bmap_.clear();
     830             :         }
     831           0 :         admin_down_listeners_[i] = callback;
     832             :     }
     833          20 :     return i;
     834          20 : }
     835             : 
     836          20 : void BgpServer::UnregisterAdminDownCallback(int listener) {
     837          20 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     838          20 :     admin_down_listeners_[listener] = NULL;
     839          20 :     if ((size_t) listener == admin_down_listeners_.size() - 1) {
     840          60 :         while (!admin_down_listeners_.empty() &&
     841          20 :             admin_down_listeners_.back() == NULL) {
     842          20 :             admin_down_listeners_.pop_back();
     843             :         }
     844          20 :         if (admin_down_bmap_.size() > admin_down_listeners_.size()) {
     845           0 :             admin_down_bmap_.resize(admin_down_listeners_.size());
     846             :         }
     847             :     } else {
     848           0 :         if ((size_t) listener >= admin_down_bmap_.size()) {
     849           0 :             admin_down_bmap_.resize(listener + 1);
     850             :         }
     851           0 :         admin_down_bmap_.set(listener);
     852             :     }
     853          20 : }
     854             : 
     855           0 : void BgpServer::NotifyAdminDown() {
     856           0 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     857           0 :     for (AdminDownListenersList::iterator iter = admin_down_listeners_.begin();
     858           0 :          iter != admin_down_listeners_.end(); ++iter) {
     859           0 :         if (*iter != NULL) {
     860           0 :             AdminDownCb cb = *iter;
     861           0 :             (cb)();
     862           0 :         }
     863             :     }
     864           0 : }
     865             : 
     866          40 : int BgpServer::RegisterASNUpdateCallback(ASNUpdateCb callback) {
     867          40 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     868          40 :     size_t i = asn_bmap_.find_first();
     869          40 :     if (i == asn_bmap_.npos) {
     870          40 :         i = asn_listeners_.size();
     871          40 :         asn_listeners_.push_back(callback);
     872             :     } else {
     873           0 :         asn_bmap_.reset(i);
     874           0 :         if (asn_bmap_.none()) {
     875           0 :             asn_bmap_.clear();
     876             :         }
     877           0 :         asn_listeners_[i] = callback;
     878             :     }
     879          40 :     return i;
     880          40 : }
     881             : 
     882          40 : void BgpServer::UnregisterASNUpdateCallback(int listener) {
     883          40 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     884          40 :     asn_listeners_[listener] = NULL;
     885          40 :     if ((size_t) listener == asn_listeners_.size() - 1) {
     886          80 :         while (!asn_listeners_.empty() && asn_listeners_.back() == NULL) {
     887          40 :             asn_listeners_.pop_back();
     888             :         }
     889          40 :         if (asn_bmap_.size() > asn_listeners_.size()) {
     890           0 :             asn_bmap_.resize(asn_listeners_.size());
     891             :         }
     892             :     } else {
     893           0 :         if ((size_t) listener >= asn_bmap_.size()) {
     894           0 :             asn_bmap_.resize(listener + 1);
     895             :         }
     896           0 :         asn_bmap_.set(listener);
     897             :     }
     898          40 : }
     899             : 
     900          20 : void BgpServer::NotifyASNUpdate(as_t old_asn, as_t old_local_asn) {
     901          20 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     902          20 :     for (ASNUpdateListenersList::iterator iter = asn_listeners_.begin();
     903          60 :          iter != asn_listeners_.end(); ++iter) {
     904          40 :         if (*iter != NULL) {
     905          40 :             ASNUpdateCb cb = *iter;
     906          40 :             (cb)(old_asn, old_local_asn);
     907          40 :         }
     908             :     }
     909          20 : }
     910             : 
     911          52 : int BgpServer::RegisterDSCPUpdateCallback(DSCPUpdateCb callback) {
     912          52 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     913          52 :     size_t i = dscp_bmap_.find_first();
     914          52 :     if (i == dscp_bmap_.npos) {
     915          52 :         i = dscp_listeners_.size();
     916          52 :         dscp_listeners_.push_back(callback);
     917             :     } else {
     918           0 :         dscp_bmap_.reset(i);
     919           0 :         if (dscp_bmap_.none()) {
     920           0 :             dscp_bmap_.clear();
     921             :         }
     922           0 :         dscp_listeners_[i] = callback;
     923             :     }
     924          52 :     return i;
     925          52 : }
     926             : 
     927          52 : void BgpServer::UnregisterDSCPUpdateCallback(int listener) {
     928          52 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     929          52 :     dscp_listeners_[listener] = NULL;
     930          52 :     if ((size_t) listener == dscp_listeners_.size() - 1) {
     931          75 :         while (!dscp_listeners_.empty() && dscp_listeners_.back() == NULL) {
     932          52 :             dscp_listeners_.pop_back();
     933             :         }
     934          23 :         if (dscp_bmap_.size() > dscp_listeners_.size()) {
     935          21 :             dscp_bmap_.resize(dscp_listeners_.size());
     936             :         }
     937             :     } else {
     938          29 :         if ((size_t) listener >= dscp_bmap_.size()) {
     939          26 :             dscp_bmap_.resize(listener + 1);
     940             :         }
     941          29 :         dscp_bmap_.set(listener);
     942             :     }
     943          52 : }
     944             : 
     945           0 : void BgpServer::NotifyDSCPUpdate(int new_dscp_value) {
     946           0 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     947           0 :     for (DSCPUpdateListenersList::iterator iter = dscp_listeners_.begin();
     948           0 :          iter != dscp_listeners_.end(); ++iter) {
     949           0 :         if (*iter != NULL) {
     950           0 :             DSCPUpdateCb cb = *iter;
     951           0 :             (cb)(new_dscp_value);
     952           0 :         }
     953             :     }
     954           0 : }
     955             : 
     956          40 : int BgpServer::RegisterIdentifierUpdateCallback(IdentifierUpdateCb callback) {
     957          40 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     958          40 :     size_t i = id_bmap_.find_first();
     959          40 :     if (i == id_bmap_.npos) {
     960          40 :         i = id_listeners_.size();
     961          40 :         id_listeners_.push_back(callback);
     962             :     } else {
     963           0 :         id_bmap_.reset(i);
     964           0 :         if (id_bmap_.none()) {
     965           0 :             id_bmap_.clear();
     966             :         }
     967           0 :         id_listeners_[i] = callback;
     968             :     }
     969          40 :     return i;
     970          40 : }
     971             : 
     972          20 : void BgpServer::UnregisterIdentifierUpdateCallback(int listener) {
     973          20 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     974          20 :     id_listeners_[listener] = NULL;
     975          20 :     if ((size_t) listener == id_listeners_.size() - 1) {
     976           0 :         while (!id_listeners_.empty() && id_listeners_.back() == NULL) {
     977           0 :             id_listeners_.pop_back();
     978             :         }
     979           0 :         if (id_bmap_.size() > id_listeners_.size()) {
     980           0 :             id_bmap_.resize(id_listeners_.size());
     981             :         }
     982             :     } else {
     983          20 :         if ((size_t) listener >= id_bmap_.size()) {
     984          20 :             id_bmap_.resize(listener + 1);
     985             :         }
     986          20 :         id_bmap_.set(listener);
     987             :     }
     988          20 : }
     989             : 
     990          20 : void BgpServer::NotifyIdentifierUpdate(Ip4Address old_identifier) {
     991          20 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     992          20 :     for (IdentifierUpdateListenersList::iterator iter = id_listeners_.begin();
     993          60 :          iter != id_listeners_.end(); ++iter) {
     994          40 :         if (*iter != NULL) {
     995          40 :             IdentifierUpdateCb cb = *iter;
     996          40 :             (cb)(old_identifier);
     997          40 :         }
     998             :     }
     999          20 : }
    1000             : 
    1001           0 : void BgpServer::InsertStaticRouteMgr(IStaticRouteMgr *srt_manager) {
    1002           0 :     CHECK_CONCURRENCY("bgp::Config", "bgp::ConfigHelper");
    1003           0 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
    1004           0 :     srt_manager_list_.insert(srt_manager);
    1005           0 : }
    1006             : 
    1007           0 : void BgpServer::RemoveStaticRouteMgr(IStaticRouteMgr *srt_manager) {
    1008           0 :     CHECK_CONCURRENCY("bgp::Config", "bgp::ConfigHelper");
    1009           0 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
    1010           0 :     srt_manager_list_.erase(srt_manager);
    1011           0 : }
    1012             : 
    1013         959 : void BgpServer::NotifyAllStaticRoutes() {
    1014         959 :     CHECK_CONCURRENCY("bgp::Config", "bgp::ConfigHelper");
    1015         960 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
    1016         960 :     for (StaticRouteMgrList::iterator it = srt_manager_list_.begin();
    1017         960 :          it != srt_manager_list_.end(); ++it) {
    1018           0 :         IStaticRouteMgr *srt_manager = *it;
    1019           0 :         srt_manager->NotifyAllRoutes();
    1020             :     }
    1021         960 : }
    1022             : 
    1023           0 : uint32_t BgpServer::GetStaticRouteCount() const {
    1024           0 :     CHECK_CONCURRENCY("bgp::ShowCommand");
    1025           0 :     uint32_t count = 0;
    1026           0 :     for (StaticRouteMgrList::iterator it = srt_manager_list_.begin();
    1027           0 :          it != srt_manager_list_.end(); ++it) {
    1028           0 :         IStaticRouteMgr *srt_manager = *it;
    1029           0 :         count += srt_manager->GetRouteCount();
    1030             :     }
    1031           0 :     return count;
    1032             : }
    1033             : 
    1034           0 : uint32_t BgpServer::GetDownStaticRouteCount() const {
    1035           0 :     CHECK_CONCURRENCY("bgp::ShowCommand");
    1036           0 :     uint32_t count = 0;
    1037           0 :     for (StaticRouteMgrList::iterator it = srt_manager_list_.begin();
    1038           0 :          it != srt_manager_list_.end(); ++it) {
    1039           0 :         IStaticRouteMgr *srt_manager = *it;
    1040           0 :         count += srt_manager->GetDownRouteCount();
    1041             :     }
    1042           0 :     return count;
    1043             : }
    1044             : 
    1045           0 : void BgpServer::FillPeerStats(const BgpPeer *peer) const {
    1046           0 :     PeerStatsInfo stats;
    1047           0 :     PeerStats::FillPeerDebugStats(peer->peer_stats(), &stats);
    1048             : 
    1049           0 :     BgpPeerInfoData peer_info;
    1050           0 :     peer_info.set_name(peer->ToUVEKey());
    1051           0 :     peer_info.set_peer_stats_info(stats);
    1052           0 :     assert(!peer_info.get_name().empty());
    1053           0 :     BGP_UVE_SEND(BGPPeerInfo, peer_info);
    1054             : 
    1055           0 :     PeerStatsData peer_stats_data;
    1056           0 :     peer_stats_data.set_name(peer->ToUVEKey());
    1057           0 :     peer_stats_data.set_encoding("BGP");
    1058           0 :     PeerStats::FillPeerUpdateStats(peer->peer_stats(), &peer_stats_data);
    1059           0 :     assert(!peer_stats_data.get_name().empty());
    1060           0 :     BGP_UVE_SEND2(PeerStatsUve, peer_stats_data, "ObjectBgpPeer");
    1061             : 
    1062           0 :     PeerFlapInfo flap_info;
    1063           0 :     flap_info.set_flap_count(peer->flap_count());
    1064           0 :     flap_info.set_flap_time(peer->last_flap());
    1065             : 
    1066           0 :     PeerFlapData peer_flap_data;
    1067           0 :     peer_flap_data.set_name(peer->ToUVEKey());
    1068           0 :     peer_flap_data.set_encoding("BGP");
    1069           0 :     peer_flap_data.set_flap_info(flap_info);
    1070           0 :     assert(!peer_flap_data.get_name().empty());
    1071           0 :     BGP_UVE_SEND2(PeerFlap, peer_flap_data, "ObjectBgpPeer");
    1072           0 : }
    1073             : 
    1074           0 : bool BgpServer::CollectStats(BgpRouterState *state, bool first) const {
    1075           0 :     CHECK_CONCURRENCY("bgp::ShowCommand");
    1076             : 
    1077           0 :     VisitBgpPeers(boost::bind(&BgpServer::FillPeerStats, this, _1));
    1078           0 :     bool change = false;
    1079           0 :     uint32_t is_admin_down = admin_down();
    1080           0 :     if (first || is_admin_down != state->get_admin_down()) {
    1081           0 :         state->set_admin_down(is_admin_down);
    1082           0 :         change = true;
    1083             :     }
    1084             : 
    1085           0 :     string router_id = bgp_identifier_string();
    1086           0 :     if (first || router_id != state->get_router_id()) {
    1087           0 :         state->set_router_id(router_id);
    1088           0 :         change = true;
    1089             :     }
    1090             : 
    1091           0 :     uint32_t local_asn = local_autonomous_system();
    1092           0 :     if (first || local_asn != state->get_local_asn()) {
    1093           0 :         state->set_local_asn(local_asn);
    1094           0 :         change = true;
    1095             :     }
    1096             : 
    1097           0 :     uint32_t global_asn = autonomous_system();
    1098           0 :     if (first || global_asn != state->get_global_asn()) {
    1099           0 :         state->set_global_asn(global_asn);
    1100           0 :         change = true;
    1101             :     }
    1102             : 
    1103           0 :     uint32_t num_bgp = num_bgp_peer();
    1104           0 :     if (first || num_bgp != state->get_num_bgp_peer()) {
    1105           0 :         state->set_num_bgp_peer(num_bgp);
    1106           0 :         change = true;
    1107             :     }
    1108             : 
    1109           0 :     uint32_t num_up_bgp_peer = NumUpPeer();
    1110           0 :     if (first || num_up_bgp_peer != state->get_num_up_bgp_peer()) {
    1111           0 :         state->set_num_up_bgp_peer(num_up_bgp_peer);
    1112           0 :         change = true;
    1113             :     }
    1114             : 
    1115           0 :     uint32_t deleting_bgp_peer = num_deleting_bgp_peer();
    1116           0 :     if (first || deleting_bgp_peer != state->get_num_deleting_bgp_peer()) {
    1117           0 :         state->set_num_deleting_bgp_peer(deleting_bgp_peer);
    1118           0 :         change = true;
    1119             :     }
    1120             : 
    1121           0 :     uint32_t num_bgpaas = num_bgpaas_peer();
    1122           0 :     if (first || num_bgpaas != state->get_num_bgpaas_peer()) {
    1123           0 :         state->set_num_bgpaas_peer(num_bgpaas);
    1124           0 :         change = true;
    1125             :     }
    1126             : 
    1127           0 :     uint32_t num_up_bgpaas_peer = NumUpBgpaasPeer();
    1128           0 :     if (first || num_up_bgpaas_peer != state->get_num_up_bgpaas_peer()) {
    1129           0 :         state->set_num_up_bgpaas_peer(num_up_bgpaas_peer);
    1130           0 :         change = true;
    1131             :     }
    1132             : 
    1133           0 :     uint32_t deleting_bgpaas_peer = num_deleting_bgpaas_peer();
    1134           0 :     if (first || deleting_bgpaas_peer !=
    1135           0 :             state->get_num_deleting_bgpaas_peer()) {
    1136           0 :         state->set_num_deleting_bgpaas_peer(deleting_bgpaas_peer);
    1137           0 :         change = true;
    1138             :     }
    1139             : 
    1140           0 :     uint32_t num_ri = num_routing_instance();
    1141           0 :     if (first || num_ri != state->get_num_routing_instance()) {
    1142           0 :         state->set_num_routing_instance(num_ri);
    1143           0 :         change = true;
    1144             :     }
    1145             : 
    1146           0 :     uint32_t num_deleted_ri = num_deleted_routing_instance();
    1147           0 :     if (first || num_deleted_ri != state->get_num_deleted_routing_instance()) {
    1148           0 :         state->set_num_deleted_routing_instance(num_deleted_ri);
    1149           0 :         change = true;
    1150             :     }
    1151             : 
    1152           0 :     uint32_t service_chains = num_service_chains();
    1153           0 :     if (first || service_chains != state->get_num_service_chains()) {
    1154           0 :         state->set_num_service_chains(service_chains);
    1155           0 :         change = true;
    1156             :     }
    1157             : 
    1158           0 :     uint32_t down_service_chains = num_down_service_chains();
    1159           0 :     if (first || down_service_chains != state->get_num_down_service_chains()) {
    1160           0 :         state->set_num_down_service_chains(down_service_chains);
    1161           0 :         change = true;
    1162             :     }
    1163             : 
    1164           0 :     uint32_t static_routes = num_static_routes();
    1165           0 :     if (first || static_routes != state->get_num_static_routes()) {
    1166           0 :         state->set_num_static_routes(static_routes);
    1167           0 :         change = true;
    1168             :     }
    1169             : 
    1170           0 :     uint32_t down_static_routes = num_down_static_routes();
    1171           0 :     if (first || down_static_routes != state->get_num_down_static_routes()) {
    1172           0 :         state->set_num_down_static_routes(down_static_routes);
    1173           0 :         change = true;
    1174             :     }
    1175             : 
    1176           0 :     uint32_t out_load = inst_mgr_->SendTableStatsUve();
    1177           0 :     if (first || out_load != state->get_output_queue_depth()) {
    1178           0 :         state->set_output_queue_depth(out_load);
    1179           0 :         change = true;
    1180             :     }
    1181             : 
    1182           0 :     vector<string> bgp_config_peer_list;
    1183           0 :     BOOST_FOREACH(BgpConfigManager::NeighborMap::value_type value,
    1184             :         config_mgr_->NeighborMapItems(BgpConfigManager::kMasterInstance)) {
    1185           0 :         const BgpNeighborConfig *neighbor = value.second;
    1186           0 :         string name(BgpConfigManager::kMasterInstance);
    1187           0 :         name += ":";
    1188           0 :         name += localname();
    1189           0 :         name += ":";
    1190           0 :         name += neighbor->name();
    1191           0 :         bgp_config_peer_list.push_back(name);
    1192           0 :     }
    1193           0 :     sort(bgp_config_peer_list.begin(), bgp_config_peer_list.end());
    1194           0 :     if (first || bgp_config_peer_list != state->get_bgp_config_peer_list()) {
    1195           0 :         state->set_bgp_config_peer_list(bgp_config_peer_list);
    1196           0 :         change = true;
    1197             :     }
    1198             : 
    1199           0 :     vector<string> bgp_oper_peer_list;
    1200           0 :     const RoutingInstance *rtinstance = inst_mgr_->GetDefaultRoutingInstance();
    1201           0 :     const PeerManager *peer_manager = rtinstance->peer_manager();
    1202           0 :     for (const BgpPeer *peer = peer_manager->NextPeer(BgpPeerKey());
    1203           0 :         peer != NULL; peer = peer_manager->NextPeer(peer->peer_key())) {
    1204           0 :         bgp_oper_peer_list.push_back(peer->ToUVEKey());
    1205             :     }
    1206           0 :     sort(bgp_oper_peer_list.begin(), bgp_oper_peer_list.end());
    1207           0 :     if (first || bgp_oper_peer_list != state->get_bgp_oper_peer_list()) {
    1208           0 :         state->set_bgp_oper_peer_list(bgp_oper_peer_list);
    1209           0 :         change = true;
    1210             :     }
    1211             : 
    1212           0 :     return change;
    1213           0 : }
    1214             : 
    1215           0 : time_t BgpServer::GetRTargetTableLastUpdatedTimeStamp() const {
    1216           0 :     const RoutingInstanceMgr *ri_mgr = routing_instance_mgr();
    1217           0 :     const RTargetTable *rtarget_table = dynamic_cast<const RTargetTable *>(
    1218           0 :             ri_mgr->GetDefaultRoutingInstance()->GetTable(Address::RTARGET));
    1219           0 :     return rtarget_table->last_updated();
    1220             : }
    1221             : 
    1222          20 : void BgpServer::UpdateBgpIdentifier(const Ip4Address &identifier) {
    1223          20 :     Ip4Address old_identifier = bgp_identifier_;
    1224          20 :     bgp_identifier_ = identifier;
    1225          20 :     bgp_identifier_u32_ = identifier.to_ulong();
    1226          20 :     NotifyIdentifierUpdate(old_identifier);
    1227          20 : }

Generated by: LCOV version 1.14