Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "bgp/ermvpn/ermvpn_table.h"
       6             : 
       7             : #include "bgp/ipeer.h"
       8             : #include "bgp/bgp_factory.h"
       9             : #include "bgp/bgp_multicast.h"
      10             : #include "bgp/bgp_mvpn.h"
      11             : #include "bgp/bgp_server.h"
      12             : #include "bgp/bgp_update.h"
      13             : #include "bgp/inet/inet_table.h"
      14             : #include "bgp/origin-vn/origin_vn.h"
      15             : #include "bgp/routing-instance/routing_instance.h"
      16             : 
      17             : using std::unique_ptr;
      18             : using std::string;
      19             : 
      20           0 : size_t ErmVpnTable::HashFunction(const ErmVpnPrefix &prefix) const {
      21           0 :     return boost::hash_value(prefix.group().to_ulong());
      22             : }
      23             : 
      24         128 : ErmVpnTable::ErmVpnTable(DB *db, const string &name)
      25         128 :     : BgpTable(db, name), tree_manager_(NULL), mvpn_project_manager_(NULL) {
      26         128 : }
      27             : 
      28           0 : unique_ptr<DBEntry> ErmVpnTable::AllocEntry(
      29             :     const DBRequestKey *key) const {
      30           0 :     const RequestKey *pfxkey = static_cast<const RequestKey *>(key);
      31           0 :     return unique_ptr<DBEntry> (new ErmVpnRoute(pfxkey->prefix));
      32             : }
      33             : 
      34             : 
      35           0 : unique_ptr<DBEntry> ErmVpnTable::AllocEntryStr(
      36             :     const string &key_str) const {
      37           0 :     ErmVpnPrefix prefix = ErmVpnPrefix::FromString(key_str);
      38           0 :     return unique_ptr<DBEntry> (new ErmVpnRoute(prefix));
      39             : }
      40             : 
      41           0 : size_t ErmVpnTable::Hash(const DBEntry *entry) const {
      42           0 :     const ErmVpnRoute *rt_entry = static_cast<const ErmVpnRoute *>(entry);
      43           0 :     const ErmVpnPrefix &ermvpnprefix = rt_entry->GetPrefix();
      44           0 :     size_t value = ErmVpnTable::HashFunction(ermvpnprefix);
      45           0 :     return value % kPartitionCount;
      46             : }
      47             : 
      48           0 : size_t ErmVpnTable::Hash(const Ip4Address &group) const {
      49           0 :     return boost::hash_value(group.to_ulong()) % kPartitionCount;
      50             : }
      51             : 
      52           0 : size_t ErmVpnTable::Hash(const DBRequestKey *key) const {
      53           0 :     const RequestKey *rkey = static_cast<const RequestKey *>(key);
      54           0 :     Ip4Prefix prefix(rkey->prefix.group(), 32);
      55           0 :     size_t value = InetTable::HashFunction(prefix);
      56           0 :     return value % kPartitionCount;
      57             : }
      58             : 
      59           0 : BgpRoute *ErmVpnTable::TableFind(DBTablePartition *rtp,
      60             :     const DBRequestKey *prefix) {
      61           0 :     const RequestKey *pfxkey = static_cast<const RequestKey *>(prefix);
      62           0 :     ErmVpnRoute rt_key(pfxkey->prefix);
      63           0 :     return static_cast<BgpRoute *>(rtp->Find(&rt_key));
      64           0 : }
      65             : 
      66         128 : DBTableBase *ErmVpnTable::CreateTable(DB *db, const string &name) {
      67         128 :     ErmVpnTable *table = new ErmVpnTable(db, name);
      68         128 :     table->Init();
      69         128 :     return table;
      70             : }
      71             : 
      72           0 : BgpRoute *ErmVpnTable::RouteReplicate(BgpServer *server,
      73             :         BgpTable *src_table, BgpRoute *src_rt, const BgpPath *src_path,
      74             :         ExtCommunityPtr community) {
      75           0 :     assert(src_table->family() == Address::ERMVPN);
      76             : 
      77           0 :     ErmVpnRoute *mroute = dynamic_cast<ErmVpnRoute *>(src_rt);
      78           0 :     assert(mroute);
      79             : 
      80             :     // Native routes are not replicated to other VRFs or to the VPN table.
      81           0 :     if (mroute->GetPrefix().type() == ErmVpnPrefix::NativeRoute)
      82           0 :         return NULL;
      83             : 
      84           0 :     if (!IsMaster()) {
      85             :         // Don't replicate to a VRF from other VRF tables.
      86           0 :         ErmVpnTable *src_ermvpn_table = dynamic_cast<ErmVpnTable *>(src_table);
      87           0 :         if (!src_ermvpn_table->IsMaster())
      88           0 :             return NULL;
      89             : 
      90             :         // Don't replicate to VRF from the VPN table if OriginVn doesn't match.
      91           0 :         if (!community->ContainsOriginVn(server->autonomous_system(),
      92           0 :                     routing_instance()->virtual_network_index()))
      93           0 :             return NULL;
      94             :     }
      95             : 
      96             :     // RD is always zero in the VRF.  When replicating to the VPN table, we
      97             :     // pick up the RD from the SourceRD attribute. The SourceRD is always set
      98             :     // for Local and Global routes that the multicast code adds to a VRF.
      99           0 :     ErmVpnPrefix mprefix(mroute->GetPrefix());
     100           0 :     if (IsMaster()) {
     101           0 :         mprefix.set_route_distinguisher(src_path->GetAttr()->source_rd());
     102             :     } else {
     103           0 :         mprefix.set_route_distinguisher(RouteDistinguisher::kZeroRd);
     104             :     }
     105           0 :     ErmVpnRoute rt_key(mprefix);
     106             : 
     107             :     // Find or create the route.
     108             :     DBTablePartition *rtp =
     109           0 :         static_cast<DBTablePartition *>(GetTablePartition(&rt_key));
     110           0 :     BgpRoute *dest_route = static_cast<BgpRoute *>(rtp->Find(&rt_key));
     111           0 :     if (dest_route == NULL) {
     112           0 :         dest_route = new ErmVpnRoute(mprefix);
     113           0 :         rtp->Add(dest_route);
     114             :     } else {
     115           0 :         dest_route->ClearDelete();
     116             :     }
     117             : 
     118             :     BgpAttrPtr new_attr =
     119             :         server->attr_db()->ReplaceExtCommunityAndLocate(src_path->GetAttr(),
     120           0 :                                                         community);
     121             : 
     122             :     // Check whether peer already has a path.
     123           0 :     BgpPath *dest_path = dest_route->FindSecondaryPath(src_rt,
     124             :             src_path->GetSource(), src_path->GetPeer(),
     125             :             src_path->GetPathId());
     126           0 :     if (dest_path != NULL) {
     127           0 :         if (new_attr != dest_path->GetOriginalAttr() ||
     128           0 :             src_path->GetFlags() != dest_path->GetFlags()) {
     129           0 :             bool success = dest_route->RemoveSecondaryPath(src_rt,
     130             :                 src_path->GetSource(), src_path->GetPeer(),
     131             :                 src_path->GetPathId());
     132           0 :             assert(success);
     133             :         } else {
     134           0 :             return dest_route;
     135             :         }
     136             :     }
     137             : 
     138             :     // Create replicated path and insert it on the route.
     139             :     BgpSecondaryPath *replicated_path =
     140           0 :         new BgpSecondaryPath(src_path->GetPeer(), src_path->GetPathId(),
     141           0 :                              src_path->GetSource(), new_attr,
     142           0 :                              src_path->GetFlags(), src_path->GetLabel());
     143           0 :     replicated_path->SetReplicateInfo(src_table, src_rt);
     144           0 :     dest_route->InsertPath(replicated_path);
     145           0 :     rtp->Notify(dest_route);
     146             : 
     147           0 :     return dest_route;
     148           0 : }
     149             : 
     150           0 : bool ErmVpnTable::Export(RibOut *ribout, Route *route,
     151             :     const RibPeerSet &peerset, UpdateInfoSList &uinfo_slist) {
     152           0 :     if (ribout->IsEncodingBgp()) {
     153           0 :         BgpRoute *bgp_route = static_cast<BgpRoute *> (route);
     154           0 :         UpdateInfo *uinfo = GetUpdateInfo(ribout, bgp_route, peerset);
     155           0 :         if (!uinfo)
     156           0 :             return false;
     157           0 :         uinfo_slist->push_front(*uinfo);
     158           0 :         return true;
     159             :     }
     160             : 
     161           0 :     ErmVpnRoute *ermvpn_route = dynamic_cast<ErmVpnRoute *>(route);
     162           0 :     if (ermvpn_route->GetPrefix().type() != ErmVpnPrefix::NativeRoute &&
     163           0 :             ermvpn_route->GetPrefix().type() != ErmVpnPrefix::GlobalTreeRoute)
     164           0 :         return false;
     165             : 
     166           0 :     if (!tree_manager_ || tree_manager_->deleter()->IsDeleted())
     167           0 :         return false;
     168             : 
     169           0 :     const IPeer *peer = ermvpn_route->BestPath()->GetPeer();
     170           0 :     if (!peer || !ribout->IsRegistered(const_cast<IPeer *>(peer)))
     171           0 :         return false;
     172             : 
     173           0 :     size_t peerbit = ribout->GetPeerIndex(const_cast<IPeer *>(peer));
     174           0 :     if (!peerset.test(peerbit))
     175           0 :         return false;
     176             : 
     177           0 :     UpdateInfo *uinfo = tree_manager_->GetUpdateInfo(ermvpn_route);
     178           0 :     if (!uinfo)
     179           0 :         return false;
     180             : 
     181           0 :     uinfo->target.set(peerbit);
     182           0 :     uinfo_slist->push_front(*uinfo);
     183           0 :     return true;
     184             : }
     185             : 
     186         128 : void ErmVpnTable::CreateTreeManager() {
     187             :     // Don't create the McastTreeManager for the VPN table.
     188         128 :     if (IsMaster() && !server()->mvpn_ipv4_enable())
     189          32 :         return;
     190          96 :     assert(!tree_manager_);
     191          96 :     tree_manager_ = BgpStaticObjectFactory::Create<McastTreeManager>(this);
     192          96 :     tree_manager_->Initialize();
     193             : }
     194             : 
     195          96 : void ErmVpnTable::DestroyTreeManager() {
     196          96 :     assert(tree_manager_);
     197          96 :     tree_manager_->Terminate();
     198          96 :     delete tree_manager_;
     199          96 :     tree_manager_ = NULL;
     200          96 : }
     201             : 
     202           0 : McastTreeManager *ErmVpnTable::GetTreeManager() {
     203           0 :     return tree_manager_;
     204             : }
     205             : 
     206           0 : const McastTreeManager *ErmVpnTable::GetTreeManager() const {
     207           0 :     return tree_manager_;
     208             : }
     209             : 
     210         128 : void ErmVpnTable::set_routing_instance(RoutingInstance *rtinstance) {
     211         128 :     BgpTable::set_routing_instance(rtinstance);
     212         128 :     CreateTreeManager();
     213         128 :     CreateMvpnProjectManager();
     214         128 : }
     215             : 
     216         128 : void ErmVpnTable::CreateMvpnProjectManager() {
     217             :     // Don't create the MvpnProjectManager for the master table.
     218         128 :     if (!server()->mvpn_ipv4_enable() || IsMaster())
     219          32 :         return;
     220          96 :     assert(!mvpn_project_manager_);
     221          96 :     mvpn_project_manager_ = BgpStaticObjectFactory::Create<MvpnProjectManager>(this);
     222          96 :     mvpn_project_manager_->Initialize();
     223             : }
     224             : 
     225          96 : void ErmVpnTable::DestroyMvpnProjectManager() {
     226          96 :     assert(mvpn_project_manager_);
     227          96 :     mvpn_project_manager_->Terminate();
     228          96 :     delete mvpn_project_manager_;
     229          96 :     mvpn_project_manager_ = NULL;
     230          96 : }
     231             : 
     232        1600 : bool ErmVpnTable::IsMaster() const {
     233        1600 :     return routing_instance()->IsMasterRoutingInstance();
     234             : }
     235             : 
     236             : // Find or create the route.
     237           0 : ErmVpnRoute *ErmVpnTable::FindRoute(const ErmVpnPrefix &prefix) {
     238           0 :     ErmVpnRoute rt_key(prefix);
     239             :     DBTablePartition *rtp = static_cast<DBTablePartition *>(
     240           0 :         GetTablePartition(&rt_key));
     241           0 :     return static_cast<ErmVpnRoute *>(rtp->Find(&rt_key));
     242           0 : }
     243             : 
     244           0 : const ErmVpnRoute *ErmVpnTable::FindRoute(const ErmVpnPrefix &prefix) const {
     245             :     return const_cast<ErmVpnRoute *>(
     246           0 :         static_cast<const ErmVpnTable *>(this)->FindRoute(prefix));
     247             : }
     248             : 
     249           0 : void ErmVpnTable::GetMvpnSourceAddress(ErmVpnRoute *ermvpn_rt,
     250             :                                        Ip4Address *address) const {
     251           0 :     if (mvpn_project_manager_)
     252           0 :         mvpn_project_manager_->GetMvpnSourceAddress(ermvpn_rt, address);
     253           0 : }
     254             : 
     255           1 : static void RegisterFactory() {
     256           1 :     DB::RegisterFactory("ermvpn.0", &ErmVpnTable::CreateTable);
     257           1 : }
     258             : 
     259             : MODULE_INITIALIZER(RegisterFactory);