LCOV - code coverage report
Current view: top level - bgp - bgp_xmpp_rtarget_manager.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 82 154 53.2 %
Date: 2026-11-16 02:06:09 Functions: 17 23 73.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2016 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : #include "bgp/bgp_xmpp_rtarget_manager.h"
       6             : 
       7             : #include <utility>
       8             : #include <vector>
       9             : 
      10             : #include <boost/foreach.hpp>
      11             : 
      12             : #include "bgp/ipeer.h"
      13             : #include "bgp/bgp_peer_types.h"
      14             : #include "bgp/bgp_server.h"
      15             : #include "bgp/bgp_xmpp_channel.h"
      16             : #include "routing-instance/routing_instance.h"
      17             : 
      18             : using std::make_pair;
      19             : using std::pair;
      20             : using std::string;
      21             : using std::vector;
      22             : 
      23         200 : BgpXmppRTargetManager::BgpXmppRTargetManager(BgpXmppChannel *bgp_xmpp_channel) :
      24         200 :         bgp_xmpp_channel_(bgp_xmpp_channel) {
      25         200 : }
      26             : 
      27         400 : BgpXmppRTargetManager::~BgpXmppRTargetManager() {
      28         400 : }
      29             : 
      30         440 : bool BgpXmppRTargetManager::IsSubscriptionEmpty() const {
      31         440 :     return bgp_xmpp_channel_->IsSubscriptionEmpty();
      32             : }
      33             : 
      34           0 : bool BgpXmppRTargetManager::IsSubscriptionGrStale(
      35             :         RoutingInstance *instance) const {
      36           0 :     return bgp_xmpp_channel_->IsSubscriptionGrStale(instance);
      37             : }
      38             : 
      39           0 : bool BgpXmppRTargetManager::IsSubscriptionLlgrStale(
      40             :         RoutingInstance *instance) const {
      41           0 :     return bgp_xmpp_channel_->IsSubscriptionLlgrStale(instance);
      42             : }
      43             : 
      44        1104 : bool BgpXmppRTargetManager::delete_in_progress() const {
      45        1104 :     return bgp_xmpp_channel_->delete_in_progress();
      46             : }
      47             : 
      48        1824 : const IPeer *BgpXmppRTargetManager::Peer() const {
      49        1824 :     return bgp_xmpp_channel_->Peer();
      50             : }
      51             : 
      52        1824 : void BgpXmppRTargetManager::Enqueue(DBRequest *req) const {
      53             :     RoutingInstanceMgr *instance_mgr =
      54        1824 :         bgp_xmpp_channel_->bgp_server()->routing_instance_mgr();
      55        1824 :     RoutingInstance *master = instance_mgr->GetDefaultRoutingInstance();
      56        1824 :     BgpTable *table = master->GetTable(Address::RTARGET);
      57        1824 :     assert(table);
      58        1824 :     table->Enqueue(req);
      59        1824 : }
      60             : 
      61        2000 : BgpAttrPtr BgpXmppRTargetManager::GetRouteTargetRouteAttr() const {
      62        2000 :     BgpAttrSpec attrs;
      63        2000 :     BgpAttrNextHop nexthop(bgp_xmpp_channel_->bgp_server()->bgp_identifier());
      64        2000 :     attrs.push_back(&nexthop);
      65        2000 :     BgpAttrOrigin origin(BgpAttrOrigin::IGP);
      66        2000 :     attrs.push_back(&origin);
      67        4000 :     return bgp_xmpp_channel_->bgp_server()->attr_db()->Locate(attrs);
      68        2000 : }
      69             : 
      70        1824 : int BgpXmppRTargetManager::local_autonomous_system() const {
      71        1824 :     return bgp_xmpp_channel_->bgp_server()->local_autonomous_system();
      72             : }
      73             : 
      74             : const BgpXmppRTargetManager::RouteTargetList &
      75         440 : BgpXmppRTargetManager::GetSubscribedRTargets(RoutingInstance *instance) const {
      76         440 :     return bgp_xmpp_channel_->GetSubscribedRTargets(instance);
      77             : }
      78             : 
      79         720 : uint32_t BgpXmppRTargetManager::GetRTargetRouteFlag(
      80             :         const RouteTarget &rtarget) const {
      81             :     PublishedRTargetRoutes::const_iterator rt_loc =
      82         720 :         rtarget_routes_.find(rtarget);
      83         720 :     if (rt_loc == rtarget_routes_.end() || rt_loc->second.empty())
      84         720 :         return 0;
      85             : 
      86             :     // Route is [llgr-]stale only if it is stale for all instances in the set.
      87           0 :     uint32_t flags = BgpPath::Stale | BgpPath::LlgrStale;
      88           0 :     BOOST_FOREACH(RoutingInstance *routing_instance, rt_loc->second) {
      89           0 :         if (!IsSubscriptionGrStale(routing_instance))
      90           0 :             flags &= ~BgpPath::Stale;
      91           0 :         if (!IsSubscriptionLlgrStale(routing_instance))
      92           0 :             flags &= ~BgpPath::LlgrStale;
      93           0 :         if (!flags)
      94           0 :             break;
      95             :     }
      96             : 
      97           0 :     return flags;
      98             : }
      99             : 
     100        1824 : void BgpXmppRTargetManager::RTargetRouteOp(as_t asn,
     101             :                                            const RouteTarget &rtarget,
     102             :                                            BgpAttrPtr attr, bool add_change,
     103             :                                            uint32_t flags) const {
     104        1824 :     if (add_change && delete_in_progress())
     105           0 :         return;
     106             : 
     107        1824 :     DBRequest req;
     108        1824 :     RTargetPrefix rt_prefix(asn, rtarget);
     109        1824 :     req.key.reset(new RTargetTable::RequestKey(rt_prefix, Peer()));
     110        1824 :     if (add_change) {
     111             :         // Find correct rtarget route flags if not already known.
     112        1104 :         if (!flags)
     113         720 :             flags = GetRTargetRouteFlag(rtarget);
     114        1104 :         req.data.reset(new RTargetTable::RequestData(attr, flags, 0, 0, 0));
     115        1104 :         req.oper = DBRequest::DB_ENTRY_ADD_CHANGE;
     116             :     } else {
     117         720 :         req.oper = DBRequest::DB_ENTRY_DELETE;
     118             :     }
     119        1824 :     Enqueue(&req);
     120        1824 : }
     121             : 
     122           0 : void BgpXmppRTargetManager::ASNUpdateCallback(as_t old_asn,
     123             :                                               as_t old_local_asn) const {
     124           0 :     if (local_autonomous_system() == (int)old_local_asn)
     125           0 :         return;
     126           0 :     if (IsSubscriptionEmpty())
     127           0 :         return;
     128             : 
     129             :     // Delete the route and add with new local ASN
     130           0 :     BgpAttrPtr attr = GetRouteTargetRouteAttr();
     131           0 :     for (PublishedRTargetRoutes::const_iterator it = rtarget_routes_.begin();
     132           0 :             it != rtarget_routes_.end(); it++) {
     133           0 :         RTargetRouteOp(old_local_asn, it->first, NULL, false);
     134           0 :         RTargetRouteOp(local_autonomous_system(), it->first, attr, true);
     135             :     }
     136           0 : }
     137             : 
     138        1920 : void BgpXmppRTargetManager::AddNewRTargetRoute(RoutingInstance *rtinstance,
     139             :         const RouteTarget &rtarget, BgpAttrPtr attr) {
     140        1920 :     PublishedRTargetRoutes::iterator rt_loc = rtarget_routes_.find(rtarget);
     141        1920 :     if (rt_loc == rtarget_routes_.end()) {
     142             :         pair<PublishedRTargetRoutes::iterator, bool> ret =
     143         720 :             rtarget_routes_.insert(make_pair(rtarget, RoutingInstanceList()));
     144             : 
     145         720 :         rt_loc = ret.first;
     146             : 
     147             :         // Send rtarget route ADD
     148         720 :         RTargetRouteOp(local_autonomous_system(), rtarget, attr, true);
     149             :     }
     150        1920 :     rt_loc->second.insert(rtinstance);
     151        1920 : }
     152             : 
     153         192 : void BgpXmppRTargetManager::DeleteRTargetRoute(
     154             :         RoutingInstance *rtinstance, const RouteTarget &rtarget) {
     155         192 :     PublishedRTargetRoutes::iterator rt_loc = rtarget_routes_.find(rtarget);
     156         192 :     assert(rt_loc != rtarget_routes_.end());
     157         192 :     assert(rt_loc->second.erase(rtinstance));
     158         192 :     if (rt_loc->second.empty()) {
     159          72 :         rtarget_routes_.erase(rtarget);
     160             :         // Send rtarget route DELETE
     161          72 :         RTargetRouteOp(local_autonomous_system(), rtarget, NULL, false);
     162             :     }
     163         192 : }
     164             : 
     165           0 : void BgpXmppRTargetManager::RoutingInstanceCallback(
     166             :         RoutingInstance *rt_instance, RouteTargetList *targets) {
     167             :     // Import list in the routing instance
     168           0 :     const RouteTargetList &new_list = rt_instance->GetImportList();
     169             : 
     170             :     // Previous route target list for which the rtarget route was added
     171           0 :     RouteTargetList *current = targets;
     172           0 :     RouteTargetList::iterator cur_next_it, cur_it;
     173           0 :     cur_it = cur_next_it = current->begin();
     174           0 :     RouteTargetList::const_iterator new_it = new_list.begin();
     175             : 
     176           0 :     pair<RouteTargetList::iterator, bool> r;
     177           0 :     BgpAttrPtr attr = GetRouteTargetRouteAttr();
     178           0 :     while (cur_it != current->end() && new_it != new_list.end()) {
     179           0 :         if (*new_it < *cur_it) {
     180           0 :             r = current->insert(*new_it);
     181           0 :             assert(r.second);
     182           0 :             AddNewRTargetRoute(rt_instance, *new_it, attr);
     183           0 :             new_it++;
     184           0 :         } else if (*new_it > *cur_it) {
     185           0 :             cur_next_it++;
     186           0 :             DeleteRTargetRoute(rt_instance, *cur_it);
     187           0 :             current->erase(cur_it);
     188           0 :             cur_it = cur_next_it;
     189             :         } else {
     190             :             // Update
     191           0 :             cur_it++;
     192           0 :             new_it++;
     193             :         }
     194           0 :         cur_next_it = cur_it;
     195             :     }
     196           0 :     for (; new_it != new_list.end(); ++new_it) {
     197           0 :         r = current->insert(*new_it);
     198           0 :         assert(r.second);
     199           0 :         AddNewRTargetRoute(rt_instance, *new_it, attr);
     200             :     }
     201           0 :     for (cur_next_it = cur_it;
     202           0 :          cur_it != current->end();
     203           0 :          cur_it = cur_next_it) {
     204           0 :         cur_next_it++;
     205           0 :         DeleteRTargetRoute(rt_instance, *cur_it);
     206           0 :         current->erase(cur_it);
     207             :     }
     208           0 : }
     209             : 
     210          80 : void BgpXmppRTargetManager::UpdateRouteTargetRouteFlag(
     211             :         RoutingInstance *routing_instance, const RouteTargetList &targets,
     212             :         uint32_t flags) const {
     213          80 :     BgpAttrPtr attr = GetRouteTargetRouteAttr();
     214         848 :     BOOST_FOREACH(RouteTarget rtarget, targets) {
     215             :         // Update route target route [llgr-]stale flag status.
     216         384 :         RTargetRouteOp(local_autonomous_system(), rtarget, attr, true, flags);
     217             :     }
     218          80 : }
     219             : 
     220         120 : void BgpXmppRTargetManager::Close() {
     221         120 :     if (rtarget_routes_.empty())
     222          48 :         return;
     223             : 
     224          72 :     for (PublishedRTargetRoutes::iterator it = rtarget_routes_.begin();
     225         720 :             it != rtarget_routes_.end(); it++) {
     226         648 :         RTargetRouteOp(local_autonomous_system(), it->first, NULL, false);
     227             :     }
     228          72 :     rtarget_routes_.clear();
     229             : }
     230             : 
     231           0 : void BgpXmppRTargetManager::Stale(const RouteTargetList &targets) const {
     232           0 :     BgpAttrPtr attr = GetRouteTargetRouteAttr();
     233             : 
     234             :     // Update route targets to clear STALE flag.
     235           0 :     BOOST_FOREACH(RouteTarget rtarget, targets) {
     236             :         PublishedRTargetRoutes::const_iterator rt_loc =
     237           0 :             rtarget_routes_.find(rtarget);
     238           0 :         assert(rt_loc != rtarget_routes_.end());
     239             : 
     240             :         // Send rtarget route ADD
     241           0 :         RTargetRouteOp(local_autonomous_system(), rtarget, attr, true);
     242             :     }
     243           0 : }
     244             : 
     245             : // Add/Delete rtarget route for import route target of the routing instance.
     246         440 : void BgpXmppRTargetManager::PublishRTargetRoute(RoutingInstance *rt_instance,
     247             :                                                 bool add_change) {
     248         440 :     if (IsSubscriptionEmpty())
     249           0 :         return;
     250             : 
     251         440 :     if (add_change) {
     252        4240 :         BOOST_FOREACH(RouteTarget rtarget, GetSubscribedRTargets(rt_instance)) {
     253        1920 :             AddNewRTargetRoute(rt_instance, rtarget, GetRouteTargetRouteAttr());
     254             :         }
     255             :     } else {
     256         424 :         BOOST_FOREACH(RouteTarget rtarget, GetSubscribedRTargets(rt_instance)) {
     257         192 :             DeleteRTargetRoute(rt_instance, rtarget);
     258             :         }
     259             :     }
     260             : }
     261             : 
     262           0 : void BgpXmppRTargetManager::FillInfo(BgpNeighborRoutingInstance *instance,
     263             :                                      const RouteTargetList &targets) const {
     264           0 :     vector<string> import_targets;
     265           0 :     BOOST_FOREACH(RouteTarget rt, targets) {
     266           0 :         import_targets.push_back(rt.ToString());
     267             :     }
     268           0 :     instance->set_import_targets(import_targets);
     269           0 : }

Generated by: LCOV version 1.14