LCOV - code coverage report
Current view: top level - bgp/mvpn - mvpn_route.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 0 641 0.0 %
Date: 2026-11-16 02:06:09 Functions: 0 38 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2017 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #include "bgp/mvpn/mvpn_route.h"
       7             : 
       8             : #include <algorithm>
       9             : #include <string>
      10             : #include <vector>
      11             : 
      12             : #include "base/string_util.h"
      13             : #include "bgp/mvpn/mvpn_table.h"
      14             : 
      15             : using boost::system::errc::invalid_argument;
      16             : using boost::system::error_code;
      17             : using std::copy;
      18             : using std::string;
      19             : using std::vector;
      20             : 
      21             : const size_t MvpnPrefix::kRdSize = RouteDistinguisher::kSize;
      22             : const size_t MvpnPrefix::kAsnSize = 4;
      23             : const size_t MvpnPrefix::kIp4AddrSize = Address::kMaxV4Bytes;
      24             : const size_t MvpnPrefix::kIp4AddrBitSize = Address::kMaxV4PrefixLen;
      25             : 
      26             : const size_t MvpnPrefix::kPrefixBytes = 2;
      27             : const size_t MvpnPrefix::kIntraASPMSIADRouteSize = kRdSize + kIp4AddrSize;
      28             : const size_t MvpnPrefix::kInterASPMSIADRouteSize = kRdSize + kAsnSize;
      29             : const size_t MvpnPrefix::kSPMSIADRouteSize =
      30             :                           kRdSize + 2 * (1 + kIp4AddrSize) + kIp4AddrSize;
      31             : const size_t MvpnPrefix::kSourceActiveADRouteSize =
      32             :                                          kRdSize + 2 * (1 + kIp4AddrSize);
      33             : const size_t MvpnPrefix::kSourceTreeJoinRouteSize =
      34             :                               kRdSize + kAsnSize + 2 * (1 + kIp4AddrSize);
      35             : 
      36           0 : MvpnPrefix::MvpnPrefix() : type_(MvpnPrefix::Unspecified), ip_prefixlen_(0),
      37           0 :         asn_(0) {
      38           0 : }
      39             : 
      40           0 : MvpnPrefix::MvpnPrefix(uint8_t type, const RouteDistinguisher &rd,
      41           0 :     const uint32_t asn)
      42           0 :     : type_(type), rd_(rd), ip_prefixlen_(0), asn_(asn) {
      43             : 
      44           0 :     assert(type == InterASPMSIADRoute);
      45           0 : }
      46             : 
      47           0 : MvpnPrefix::MvpnPrefix(uint8_t type, const Ip4Address &originator)
      48           0 :     : type_(type), originator_(originator), ip_prefixlen_(0), asn_(0) {
      49             : 
      50           0 :     assert(type == LeafADRoute);
      51           0 : }
      52             : 
      53           0 : MvpnPrefix::MvpnPrefix(uint8_t type, const RouteDistinguisher &rd,
      54           0 :     const Ip4Address &originator)
      55           0 :     : type_(type), rd_(rd), originator_(originator), ip_prefixlen_(0),
      56           0 :       asn_(0) {
      57             : 
      58           0 :     assert(type == IntraASPMSIADRoute);
      59           0 : }
      60             : 
      61           0 : MvpnPrefix::MvpnPrefix(uint8_t type, const RouteDistinguisher &rd,
      62           0 :     const Ip4Address &group, const Ip4Address &source)
      63           0 :     : type_(type), rd_(rd), group_(group), source_(source),
      64           0 :       ip_prefixlen_(0), asn_(0) {
      65             : 
      66           0 :     assert(type == SourceActiveADRoute);
      67           0 : }
      68             : 
      69           0 : MvpnPrefix::MvpnPrefix(uint8_t type, const RouteDistinguisher &rd,
      70             :     const Ip4Address &originator,
      71           0 :     const Ip4Address &group, const Ip4Address &source)
      72           0 :     : type_(type), rd_(rd), originator_(originator),
      73           0 :       group_(group), source_(source), ip_prefixlen_(0), asn_(0) {
      74             : 
      75           0 :     assert(type == SPMSIADRoute);
      76           0 : }
      77             : 
      78           0 : MvpnPrefix::MvpnPrefix(uint8_t type, const RouteDistinguisher &rd,
      79           0 :     const uint32_t asn, const Ip4Address &group, const Ip4Address &source)
      80           0 :     : type_(type), rd_(rd), group_(group), source_(source), ip_prefixlen_(0),
      81           0 :       asn_(asn) {
      82             : 
      83           0 :     assert((type == SharedTreeJoinRoute) || (type == SourceTreeJoinRoute));
      84           0 : }
      85             : 
      86           0 : Ip4Address MvpnPrefix::GetType3OriginatorFromType4Route() const {
      87           0 :         size_t originator_offset = rt_key_.size() - kIp4AddrSize;
      88             :         return Ip4Address(get_value
      89           0 :                 (&rt_key_[originator_offset], kIp4AddrSize));
      90             : }
      91             : 
      92           0 : int MvpnPrefix::SpmsiAdRouteFromProtoPrefix(const BgpProtoPrefix &proto_prefix,
      93             :     MvpnPrefix *prefix, size_t rd_offset) {
      94           0 :     prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
      95           0 :     size_t source_offset = rd_offset + kRdSize;
      96           0 :     if (proto_prefix.prefix[source_offset++] != kIp4AddrBitSize)
      97           0 :         return -1;
      98           0 :     prefix->source_ = Ip4Address(get_value(
      99           0 :             &proto_prefix.prefix[source_offset], kIp4AddrSize));
     100             : 
     101           0 :     size_t group_offset = source_offset + kIp4AddrSize;
     102           0 :     if (proto_prefix.prefix[group_offset++] != kIp4AddrBitSize)
     103           0 :         return -1;
     104           0 :     prefix->group_ = Ip4Address(get_value(
     105           0 :             &proto_prefix.prefix[group_offset], kIp4AddrSize));
     106           0 :     size_t originator_offset = group_offset + kIp4AddrSize;
     107           0 :     prefix->originator_ = Ip4Address(get_value(
     108           0 :             &proto_prefix.prefix[originator_offset], kIp4AddrSize));
     109           0 :     return 0;
     110             : }
     111             : 
     112           0 : int MvpnPrefix::FromProtoPrefix(const BgpProtoPrefix &proto_prefix,
     113             :     MvpnPrefix *prefix) {
     114           0 :     size_t nlri_size = proto_prefix.prefix.size();
     115             : 
     116           0 :     prefix->type_ = proto_prefix.type;
     117           0 :     switch (prefix->type_) {
     118           0 :     case IntraASPMSIADRoute: {
     119           0 :         size_t expected_nlri_size = kIntraASPMSIADRouteSize;
     120           0 :         if (nlri_size != expected_nlri_size)
     121           0 :             return -1;
     122           0 :         size_t rd_offset = 0;
     123           0 :         prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
     124           0 :         size_t originator_offset = rd_offset + kRdSize;
     125           0 :         prefix->originator_ = Ip4Address(get_value(
     126           0 :             &proto_prefix.prefix[originator_offset], kIp4AddrSize));
     127           0 :         break;
     128             :     }
     129           0 :     case InterASPMSIADRoute: {
     130           0 :         size_t expected_nlri_size = kInterASPMSIADRouteSize;
     131           0 :         if (nlri_size != expected_nlri_size)
     132           0 :             return -1;
     133           0 :         size_t rd_offset = 0;
     134           0 :         prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
     135           0 :         size_t asn_offset = rd_offset + kRdSize;
     136           0 :         prefix->asn_ = get_value(&proto_prefix.prefix[asn_offset], kAsnSize);
     137           0 :         break;
     138             :     }
     139           0 :     case SPMSIADRoute: {
     140           0 :         size_t expected_nlri_size = kSPMSIADRouteSize;
     141           0 :         if (nlri_size != expected_nlri_size)
     142           0 :             return -1;
     143           0 :         if (SpmsiAdRouteFromProtoPrefix(proto_prefix, prefix, 0))
     144           0 :             return -1;
     145           0 :         break;
     146             :     }
     147           0 :     case LeafADRoute: {
     148             :         size_t expected_nlri_size;
     149           0 :         if (proto_prefix.prefix[0] == SPMSIADRoute) {
     150           0 :             expected_nlri_size = kPrefixBytes + kSPMSIADRouteSize +
     151             :                                  kIp4AddrSize;
     152           0 :         } else if (proto_prefix.prefix[0] == InterASPMSIADRoute) {
     153           0 :             expected_nlri_size = kPrefixBytes + kInterASPMSIADRouteSize +
     154             :                                  kIp4AddrSize;
     155             :         } else {
     156           0 :             return -1;
     157             :         }
     158           0 :         if (nlri_size != expected_nlri_size)
     159           0 :             return -1;
     160           0 :         prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[kPrefixBytes]);
     161           0 :         if (proto_prefix.prefix[0] == SPMSIADRoute) {
     162           0 :             if (SpmsiAdRouteFromProtoPrefix(proto_prefix, prefix,
     163             :                                                        kPrefixBytes)) {
     164           0 :                 return -1;
     165             :             }
     166           0 :         } else if (proto_prefix.prefix[0] == InterASPMSIADRoute) {
     167           0 :             size_t asn_offset = kPrefixBytes + kRdSize;
     168           0 :             prefix->asn_ = get_value(&proto_prefix.prefix[asn_offset], kAsnSize);
     169             :         }
     170           0 :         size_t originator_offset = nlri_size - kIp4AddrSize;
     171           0 :         prefix->rt_key_.resize(originator_offset);
     172           0 :         copy(proto_prefix.prefix.begin(), proto_prefix.prefix.begin() +
     173             :                 originator_offset, prefix->rt_key_.begin());
     174           0 :         prefix->originator_ = Ip4Address(get_value(
     175           0 :             &proto_prefix.prefix[originator_offset], kIp4AddrSize));
     176           0 :         break;
     177             :     }
     178           0 :     case SourceActiveADRoute: {
     179           0 :         size_t expected_nlri_size = kSourceActiveADRouteSize;
     180           0 :         if (nlri_size != expected_nlri_size)
     181           0 :             return -1;
     182           0 :         size_t rd_offset = 0;
     183           0 :         prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
     184           0 :         size_t source_offset = rd_offset + kRdSize;
     185           0 :         if (proto_prefix.prefix[source_offset++] != kIp4AddrBitSize)
     186           0 :             return -1;
     187           0 :         prefix->source_ = Ip4Address(get_value(
     188           0 :             &proto_prefix.prefix[source_offset], kIp4AddrSize));
     189             : 
     190           0 :         size_t group_offset = source_offset + kIp4AddrSize;
     191           0 :         if (proto_prefix.prefix[group_offset++] != kIp4AddrBitSize)
     192           0 :             return -1;
     193           0 :         prefix->group_ = Ip4Address(get_value(
     194           0 :             &proto_prefix.prefix[group_offset], kIp4AddrSize));
     195           0 :         break;
     196             :     }
     197           0 :     case SourceTreeJoinRoute:
     198             :     case SharedTreeJoinRoute: {
     199           0 :         size_t expected_nlri_size = kSourceTreeJoinRouteSize;
     200           0 :         if (nlri_size != expected_nlri_size)
     201           0 :             return -1;
     202           0 :         size_t rd_offset = 0;
     203           0 :         prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
     204           0 :         size_t asn_offset = rd_offset + kRdSize;
     205           0 :         uint32_t asn = get_value(&proto_prefix.prefix[asn_offset], kAsnSize);
     206           0 :         prefix->asn_ = asn;
     207           0 :         size_t source_offset = asn_offset + kAsnSize;
     208           0 :         if (proto_prefix.prefix[source_offset++] != kIp4AddrBitSize)
     209           0 :             return -1;
     210           0 :         prefix->source_ = Ip4Address(get_value(
     211           0 :             &proto_prefix.prefix[source_offset], kIp4AddrSize));
     212             : 
     213           0 :         size_t group_offset = source_offset + kIp4AddrSize;
     214           0 :         if (proto_prefix.prefix[group_offset++] != kIp4AddrBitSize)
     215           0 :             return -1;
     216           0 :         prefix->group_ = Ip4Address(get_value(
     217           0 :             &proto_prefix.prefix[group_offset], kIp4AddrSize));
     218           0 :         break;
     219             :     }
     220           0 :     default: {
     221           0 :         return -1;
     222             :     }
     223             :     }
     224             : 
     225           0 :     return 0;
     226             : }
     227             : 
     228           0 : void MvpnPrefix::set_originator(const Ip4Address &originator) {
     229           0 :     originator_ = originator;
     230           0 : }
     231             : 
     232           0 : int MvpnPrefix::FromProtoPrefix(BgpServer *server,
     233             :                                 const BgpProtoPrefix &proto_prefix,
     234             :                                 const BgpAttr *attr,
     235             :                                 const Address::Family family,
     236             :                                 MvpnPrefix *prefix,
     237             :                                 BgpAttrPtr *new_attr, uint32_t *label,
     238             :                                 uint32_t *l3_label) {
     239           0 :     return FromProtoPrefix(proto_prefix, prefix);
     240             : }
     241             : 
     242           0 : void MvpnPrefix::BuildProtoPrefix(BgpProtoPrefix *proto_prefix) const {
     243           0 :     proto_prefix->type = type_;
     244           0 :     proto_prefix->prefix.clear();
     245             : 
     246           0 :     switch (type_) {
     247           0 :     case IntraASPMSIADRoute: {
     248           0 :         size_t nlri_size = kIntraASPMSIADRouteSize;
     249           0 :         proto_prefix->prefixlen = nlri_size * 8;
     250           0 :         proto_prefix->prefix.resize(nlri_size, 0);
     251             : 
     252           0 :         size_t rd_offset = 0;
     253           0 :         copy(rd_.GetData(), rd_.GetData() + kRdSize,
     254           0 :             proto_prefix->prefix.begin() + rd_offset);
     255           0 :         size_t originator_offset = rd_offset + kRdSize;
     256           0 :         const Ip4Address::bytes_type &source_bytes = originator_.to_bytes();
     257           0 :         copy(source_bytes.begin(), source_bytes.begin() + kIp4AddrSize,
     258           0 :             proto_prefix->prefix.begin() + originator_offset);
     259           0 :         break;
     260             :     }
     261           0 :     case InterASPMSIADRoute: {
     262           0 :         size_t nlri_size = kInterASPMSIADRouteSize;
     263           0 :         proto_prefix->prefixlen = nlri_size * 8;
     264           0 :         proto_prefix->prefix.resize(nlri_size, 0);
     265             : 
     266           0 :         size_t rd_offset = 0;
     267           0 :         copy(rd_.GetData(), rd_.GetData() + kRdSize,
     268           0 :             proto_prefix->prefix.begin() + rd_offset);
     269           0 :         size_t asn_offset = rd_offset + kRdSize;
     270           0 :         put_value(&proto_prefix->prefix[asn_offset], kAsnSize, asn_);
     271           0 :         break;
     272             :     }
     273           0 :     case SPMSIADRoute: {
     274           0 :         size_t nlri_size = kSPMSIADRouteSize;
     275           0 :         proto_prefix->prefixlen = nlri_size * 8;
     276           0 :         proto_prefix->prefix.resize(nlri_size, 0);
     277             : 
     278           0 :         size_t rd_offset = 0;
     279           0 :         copy(rd_.GetData(), rd_.GetData() + kRdSize,
     280           0 :             proto_prefix->prefix.begin() + rd_offset);
     281           0 :         size_t source_offset = rd_offset + kRdSize;
     282           0 :         proto_prefix->prefix[source_offset++] = kIp4AddrBitSize;
     283           0 :         const Ip4Address::bytes_type &source_bytes = source_.to_bytes();
     284           0 :         copy(source_bytes.begin(), source_bytes.begin() + kIp4AddrSize,
     285           0 :             proto_prefix->prefix.begin() + source_offset);
     286             : 
     287           0 :         size_t group_offset = source_offset + kIp4AddrSize;
     288           0 :         proto_prefix->prefix[group_offset++] = kIp4AddrBitSize;
     289           0 :         const Ip4Address::bytes_type &group_bytes = group_.to_bytes();
     290           0 :         copy(group_bytes.begin(), group_bytes.begin() + kIp4AddrSize,
     291           0 :             proto_prefix->prefix.begin() + group_offset);
     292             : 
     293           0 :         size_t originator_offset = group_offset + kIp4AddrSize;
     294           0 :         const Ip4Address::bytes_type &originator_bytes = originator_.to_bytes();
     295           0 :         copy(originator_bytes.begin(), originator_bytes.begin() +
     296           0 :                 kIp4AddrSize, proto_prefix->prefix.begin() +
     297             :                 originator_offset);
     298           0 :         break;
     299             :     }
     300           0 :     case LeafADRoute: {
     301           0 :         size_t keySize = rt_key_.size();
     302           0 :         size_t nlri_size = keySize + kIp4AddrSize;
     303           0 :         proto_prefix->prefixlen = nlri_size * 8;
     304           0 :         proto_prefix->prefix.resize(nlri_size, 0);
     305             : 
     306           0 :         copy(rt_key_.begin(), rt_key_.begin() + keySize,
     307             :                 proto_prefix->prefix.begin());
     308             : 
     309           0 :         const Ip4Address::bytes_type &originator_bytes = originator_.to_bytes();
     310           0 :         copy(originator_bytes.begin(), originator_bytes.begin() +
     311           0 :                 kIp4AddrSize, proto_prefix->prefix.begin() + keySize);
     312           0 :         break;
     313             :     }
     314           0 :     case SourceActiveADRoute: {
     315           0 :         size_t nlri_size = kSourceActiveADRouteSize;
     316           0 :         proto_prefix->prefixlen = nlri_size * 8;
     317           0 :         proto_prefix->prefix.resize(nlri_size, 0);
     318             : 
     319           0 :         size_t rd_offset = 0;
     320           0 :         copy(rd_.GetData(), rd_.GetData() + kRdSize,
     321           0 :             proto_prefix->prefix.begin() + rd_offset);
     322           0 :         size_t source_offset = rd_offset + kRdSize;
     323           0 :         proto_prefix->prefix[source_offset++] = kIp4AddrBitSize;
     324           0 :         const Ip4Address::bytes_type &source_bytes = source_.to_bytes();
     325           0 :         copy(source_bytes.begin(), source_bytes.begin() + kIp4AddrSize,
     326           0 :             proto_prefix->prefix.begin() + source_offset);
     327             : 
     328           0 :         size_t group_offset = source_offset + kIp4AddrSize;
     329           0 :         proto_prefix->prefix[group_offset++] = kIp4AddrBitSize;
     330           0 :         const Ip4Address::bytes_type &group_bytes = group_.to_bytes();
     331           0 :         copy(group_bytes.begin(), group_bytes.begin() + kIp4AddrSize,
     332           0 :             proto_prefix->prefix.begin() + group_offset);
     333           0 :         break;
     334             :     }
     335           0 :     case SourceTreeJoinRoute:
     336             :     case SharedTreeJoinRoute: {
     337           0 :         size_t nlri_size = kSourceTreeJoinRouteSize;
     338           0 :         proto_prefix->prefixlen = nlri_size * 8;
     339           0 :         proto_prefix->prefix.resize(nlri_size, 0);
     340             : 
     341           0 :         size_t rd_offset = 0;
     342           0 :         copy(rd_.GetData(), rd_.GetData() + kRdSize,
     343           0 :             proto_prefix->prefix.begin() + rd_offset);
     344           0 :         size_t asn_offset = rd_offset + kRdSize;
     345           0 :         put_value(&proto_prefix->prefix[asn_offset], kAsnSize, asn_);
     346           0 :         size_t source_offset = asn_offset + kAsnSize;
     347           0 :         proto_prefix->prefix[source_offset++] = kIp4AddrBitSize;
     348           0 :         const Ip4Address::bytes_type &source_bytes = source_.to_bytes();
     349           0 :         copy(source_bytes.begin(), source_bytes.begin() + kIp4AddrSize,
     350           0 :             proto_prefix->prefix.begin() + source_offset);
     351             : 
     352           0 :         size_t group_offset = source_offset + kIp4AddrSize;
     353           0 :         proto_prefix->prefix[group_offset++] = kIp4AddrBitSize;
     354           0 :         const Ip4Address::bytes_type &group_bytes = group_.to_bytes();
     355           0 :         copy(group_bytes.begin(), group_bytes.begin() + kIp4AddrSize,
     356           0 :             proto_prefix->prefix.begin() + group_offset);
     357           0 :         break;
     358             :     }
     359           0 :     default: {
     360           0 :         assert(false);
     361             :         break;
     362             :     }
     363             :     }
     364           0 : }
     365             : 
     366           0 : bool MvpnPrefix::GetTypeFromString(MvpnPrefix *prefix, const string &str,
     367             :     error_code *errorp, size_t *pos1) {
     368           0 :     *pos1 = str.find('-');
     369           0 :     if (*pos1 == string::npos) {
     370           0 :         if (errorp != NULL) {
     371           0 :             *errorp = make_error_code(invalid_argument);
     372             :         }
     373           0 :         return false;
     374             :     }
     375           0 :     string temp_str = str.substr(0, *pos1);
     376           0 :     stringToInteger(temp_str, prefix->type_);
     377           0 :     if (!IsValid(prefix->type_)) {
     378           0 :         if (errorp != NULL) {
     379           0 :             *errorp = make_error_code(invalid_argument);
     380             :         }
     381           0 :         return false;
     382             :     }
     383           0 :     return true;
     384           0 : }
     385             : 
     386           0 : bool MvpnPrefix::GetRDFromString(MvpnPrefix *prefix, const string &str,
     387             :         size_t pos1, size_t *pos2, error_code *errorp) {
     388           0 :     *pos2 = str.find(',', pos1 + 1);
     389           0 :     if (*pos2 == string::npos) {
     390           0 :         if (errorp != NULL) {
     391           0 :             *errorp = make_error_code(invalid_argument);
     392             :         }
     393           0 :         return false;
     394             :     }
     395           0 :     string temp_str = str.substr(pos1 + 1, *pos2 - pos1 - 1);
     396           0 :     error_code rd_err;
     397           0 :     prefix->rd_ = RouteDistinguisher::FromString(temp_str, &rd_err);
     398           0 :     if (rd_err.failed()) {
     399           0 :         if (errorp != NULL) {
     400           0 :             *errorp = rd_err;
     401             :         }
     402           0 :         return false;
     403             :     }
     404           0 :     return true;
     405           0 : }
     406             : 
     407           0 : bool MvpnPrefix::GetOriginatorFromString(MvpnPrefix *prefix,
     408             :         const string &str, size_t pos1, error_code *errorp) {
     409           0 :     string temp_str = str.substr(pos1 + 1, string::npos);
     410           0 :     error_code originator_err;
     411           0 :     prefix->originator_ = Ip4Address::from_string(temp_str, originator_err);
     412           0 :     if (originator_err.failed()) {
     413           0 :         if (errorp != NULL) {
     414           0 :             *errorp = originator_err;
     415             :         }
     416           0 :         return false;
     417             :     }
     418           0 :     return true;
     419           0 : }
     420             : 
     421           0 : bool MvpnPrefix::GetSourceFromString(MvpnPrefix *prefix, const string &str,
     422             :         size_t pos1, size_t *pos2, error_code *errorp) {
     423           0 :     *pos2 = str.find(',', pos1 + 1);
     424           0 :     if (*pos2 == string::npos) {
     425           0 :         if (errorp != NULL) {
     426           0 :             *errorp = make_error_code(invalid_argument);
     427             :         }
     428           0 :         return false;
     429             :     }
     430           0 :     string temp_str = str.substr(pos1 + 1, *pos2 - pos1 - 1);
     431           0 :     error_code source_err;
     432           0 :     prefix->source_ = Ip4Address::from_string(temp_str, source_err);
     433           0 :     if (source_err.failed()) {
     434           0 :         if (errorp != NULL) {
     435           0 :             *errorp = source_err;
     436             :         }
     437           0 :         return false;
     438             :     }
     439           0 :     return true;
     440           0 : }
     441             : 
     442           0 : bool MvpnPrefix::GetGroupFromString(MvpnPrefix *prefix, const string &str,
     443             :         size_t pos1, size_t *pos2, error_code *errorp,
     444             :         bool last) {
     445           0 :     *pos2 = str.find(',', pos1 + 1);
     446           0 :     if (!last && *pos2 == string::npos) {
     447           0 :         if (errorp != NULL) {
     448           0 :             *errorp = make_error_code(invalid_argument);
     449             :         }
     450           0 :         return false;
     451             :     }
     452           0 :     string temp_str;
     453           0 :     if (last)
     454           0 :         temp_str = str.substr(pos1 + 1, string::npos);
     455             :     else
     456           0 :         temp_str = str.substr(pos1 + 1, *pos2 - pos1 - 1);
     457           0 :     error_code group_err;
     458           0 :     prefix->group_ = Ip4Address::from_string(temp_str, group_err);
     459           0 :     if (group_err.failed()) {
     460           0 :         if (errorp != NULL) {
     461           0 :             *errorp = group_err;
     462             :         }
     463           0 :         return false;
     464             :     }
     465           0 :     return true;
     466           0 : }
     467             : 
     468           0 : bool MvpnPrefix::GetAsnFromString(MvpnPrefix *prefix, const string &str,
     469             :         size_t pos1, size_t *pos2, error_code *errorp) {
     470           0 :     *pos2 = str.find(',', pos1 + 1);
     471           0 :     if (*pos2 == string::npos) {
     472           0 :         if (errorp != NULL) {
     473           0 :             *errorp = make_error_code(invalid_argument);
     474             :         }
     475           0 :         return false;
     476             :     }
     477           0 :     string temp_str = str.substr(pos1 + 1, *pos2 - pos1 - 1);
     478           0 :     if (!stringToInteger(temp_str, prefix->asn_)) {
     479           0 :         return false;
     480             :     }
     481           0 :     return true;
     482           0 : }
     483             : 
     484           0 : MvpnPrefix MvpnPrefix::FromString(const string &str, error_code *errorp) {
     485           0 :     MvpnPrefix prefix, null_prefix;
     486           0 :     string temp_str;
     487             : 
     488             :     // Look for Type.
     489             :     size_t pos1;
     490           0 :     if (!GetTypeFromString(&prefix, str, errorp, &pos1))
     491           0 :         return null_prefix;
     492             : 
     493           0 :     switch (prefix.type_) {
     494           0 :     case IntraASPMSIADRoute: {
     495             :         // Look for RD.
     496             :         size_t pos2;
     497           0 :         if (!GetRDFromString(&prefix, str, pos1, &pos2, errorp))
     498           0 :             return null_prefix;
     499             :         // rest is originator
     500           0 :         if (!GetOriginatorFromString(&prefix, str, pos2, errorp))
     501           0 :             return null_prefix;
     502           0 :         break;
     503             :     }
     504           0 :     case InterASPMSIADRoute: {
     505             :         // Look for RD.
     506             :         size_t pos2;
     507           0 :         if (!GetRDFromString(&prefix, str, pos1, &pos2, errorp))
     508           0 :             return null_prefix;
     509             :         // rest is asn
     510           0 :         temp_str = str.substr(pos2 + 1, string::npos);
     511           0 :         if (!stringToInteger(temp_str, prefix.asn_)) {
     512           0 :             return null_prefix;
     513             :         }
     514           0 :         break;
     515             :     }
     516           0 :     case SPMSIADRoute: {
     517             :         // Look for RD.
     518             :         size_t pos2;
     519           0 :         if (!GetRDFromString(&prefix, str, pos1, &pos2, errorp))
     520           0 :             return null_prefix;
     521             :         // Look for source.
     522             :         size_t pos3;
     523           0 :         if (!GetSourceFromString(&prefix, str, pos2, &pos3, errorp))
     524           0 :             return null_prefix;
     525             : 
     526             :         // Look for group.
     527             :         size_t pos4;
     528           0 :         if (!GetGroupFromString(&prefix, str, pos3, &pos4, errorp))
     529           0 :             return null_prefix;
     530             : 
     531             :         // rest is originator
     532           0 :         if (!GetOriginatorFromString(&prefix, str, pos4, errorp))
     533           0 :             return null_prefix;
     534           0 :         break;
     535             :     }
     536           0 :     case LeafADRoute: {
     537             :         // First get the originator from the end
     538           0 :         size_t pos_last = str.find_last_of(',');
     539           0 :         if (pos_last == string::npos) {
     540           0 :             if (errorp != NULL) {
     541           0 :                 *errorp = make_error_code(invalid_argument);
     542             :             }
     543           0 :             return null_prefix;
     544             :         }
     545           0 :         if (!GetOriginatorFromString(&prefix, str, pos_last, errorp))
     546           0 :             return null_prefix;
     547           0 :         temp_str = str.substr(pos1 + 1, string::npos);
     548             :         // Look for type.
     549             :         size_t pos2;
     550           0 :         if (!GetTypeFromString(&prefix, temp_str, errorp, &pos2))
     551           0 :             return null_prefix;
     552           0 :         uint8_t src_rt_type = prefix.type_;
     553           0 :         prefix.type_ = LeafADRoute;
     554           0 :         size_t key_size = 0;
     555           0 :         if (src_rt_type == InterASPMSIADRoute) {
     556           0 :             key_size = kPrefixBytes + kInterASPMSIADRouteSize;
     557           0 :             prefix.rt_key_.resize(key_size);
     558           0 :             prefix.rt_key_[0] = InterASPMSIADRoute;
     559           0 :             prefix.rt_key_[1] = kInterASPMSIADRouteSize;
     560           0 :         } else if (src_rt_type == SPMSIADRoute) {
     561           0 :             key_size = kPrefixBytes + kSPMSIADRouteSize;
     562           0 :             prefix.rt_key_.resize(key_size);
     563           0 :             prefix.rt_key_[0] = SPMSIADRoute;
     564           0 :             prefix.rt_key_[1] = kSPMSIADRouteSize;
     565             :         }
     566           0 :         size_t key_offset = 2;
     567             :         // Look for RD.
     568             :         size_t pos3;
     569           0 :         pos2 = pos1 + 1 + pos2;
     570           0 :         if (!GetRDFromString(&prefix, str, pos2, &pos3, errorp))
     571           0 :             return null_prefix;
     572           0 :         copy(prefix.rd_.GetData(), prefix.rd_.GetData() + kRdSize,
     573           0 :                 prefix.rt_key_.begin() + key_offset);
     574           0 :         key_offset += kRdSize;
     575             :         // check if source ip or asn
     576             :         size_t pos4;
     577           0 :         if (src_rt_type == InterASPMSIADRoute) {
     578             :             // check for asn
     579           0 :             if (!GetAsnFromString(&prefix, str, pos3, &pos4, errorp))
     580           0 :                 return null_prefix;
     581           0 :             size_t asn_size = sizeof(prefix.asn_);
     582           0 :             put_value(&prefix.rt_key_[key_offset], asn_size, prefix.asn_);
     583           0 :             break;
     584             :         }
     585           0 :         if (!GetSourceFromString(&prefix, str, pos3, &pos4, errorp))
     586           0 :             return null_prefix;
     587           0 :         const Ip4Address::bytes_type &source_bytes = prefix.source_.to_bytes();
     588           0 :         prefix.rt_key_[key_offset++] = kIp4AddrBitSize;
     589           0 :         copy(source_bytes.begin(), source_bytes.begin() +
     590           0 :                     kIp4AddrSize, prefix.rt_key_.begin() + key_offset);
     591           0 :         key_offset += kIp4AddrSize;
     592             : 
     593             :         // Look for group.
     594             :         size_t pos5;
     595           0 :         if (!GetGroupFromString(&prefix, str, pos4, &pos5, errorp))
     596           0 :             return null_prefix;
     597           0 :         const Ip4Address::bytes_type &group_bytes = prefix.group_.to_bytes();
     598           0 :         prefix.rt_key_[key_offset++] = kIp4AddrBitSize;
     599           0 :         copy(group_bytes.begin(), group_bytes.begin() +
     600           0 :                     kIp4AddrSize, prefix.rt_key_.begin() + key_offset);
     601           0 :         key_offset += kIp4AddrSize;
     602             : 
     603             :         // Look for originator of rt_key and ignore it.
     604           0 :         size_t pos6 = str.find(',', pos5 + 1);
     605           0 :         if (pos6 == string::npos) {
     606           0 :             if (errorp != NULL) {
     607           0 :                 *errorp = make_error_code(invalid_argument);
     608             :             }
     609           0 :             return null_prefix;
     610             :         }
     611           0 :         temp_str = str.substr(pos5 + 1, pos6 - pos5 - 1);
     612           0 :         error_code originator_err;
     613           0 :         Ip4Address ip = Ip4Address::from_string(temp_str, originator_err);
     614           0 :         if (originator_err.failed()) {
     615           0 :             if (errorp != NULL) {
     616           0 :                 *errorp = originator_err;
     617             :             }
     618           0 :             return null_prefix;
     619             :         }
     620           0 :         const Ip4Address::bytes_type &originator_bytes = ip.to_bytes();
     621           0 :         copy(originator_bytes.begin(), originator_bytes.begin() +
     622           0 :                     kIp4AddrSize, prefix.rt_key_.begin() + key_offset);
     623           0 :         break;
     624             :     }
     625           0 :     case SourceActiveADRoute: {
     626             :         // Look for RD.
     627             :         size_t pos2;
     628           0 :         if (!GetRDFromString(&prefix, str, pos1, &pos2, errorp))
     629           0 :             return null_prefix;
     630             :         // Look for source.
     631             :         size_t pos3;
     632           0 :         if (!GetSourceFromString(&prefix, str, pos2, &pos3, errorp))
     633           0 :             return null_prefix;
     634             : 
     635             :         // rest is group.
     636             :         size_t pos4;
     637           0 :         if (!GetGroupFromString(&prefix, str, pos3, &pos4, errorp, true))
     638           0 :             return null_prefix;
     639           0 :         break;
     640             :     }
     641           0 :     case SharedTreeJoinRoute:
     642             :     case SourceTreeJoinRoute: {
     643             :         // Look for RD.
     644             :         size_t pos2;
     645           0 :         if (!GetRDFromString(&prefix, str, pos1, &pos2, errorp))
     646           0 :             return null_prefix;
     647             :         // Look for asn
     648             :         size_t pos3;
     649           0 :         if (!GetAsnFromString(&prefix, str, pos2, &pos3, errorp))
     650           0 :             return null_prefix;
     651             :         // Look for source.
     652             :         size_t pos4;
     653           0 :         if (!GetSourceFromString(&prefix, str, pos3, &pos4, errorp))
     654           0 :             return null_prefix;
     655             : 
     656             :         // rest is group.
     657             :         size_t pos5;
     658           0 :         if (!GetGroupFromString(&prefix, str, pos4, &pos5, errorp, true))
     659           0 :             return null_prefix;
     660           0 :         break;
     661             :     }
     662             :     }
     663             : 
     664           0 :     return prefix;
     665           0 : }
     666             : 
     667           0 : string MvpnPrefix::ToString() const {
     668           0 :     string repr = integerToString(type_);
     669           0 :     switch (type_) {
     670           0 :         case IntraASPMSIADRoute:
     671           0 :             repr += "-" + rd_.ToString();
     672           0 :             repr += "," + originator_.to_string();
     673           0 :             break;
     674           0 :         case InterASPMSIADRoute:
     675           0 :             repr += "-" + rd_.ToString();
     676           0 :             repr += "," + integerToString(asn_);
     677           0 :             break;
     678           0 :         case SPMSIADRoute:
     679           0 :             repr += "-" + rd_.ToString();
     680           0 :             repr += "," + source_.to_string();
     681           0 :             repr += "," + group_.to_string();
     682           0 :             repr += "," + originator_.to_string();
     683           0 :             break;
     684           0 :         case LeafADRoute: {
     685           0 :             size_t key_offset = kPrefixBytes;
     686           0 :             RouteDistinguisher rd(&rt_key_[key_offset]);
     687           0 :             uint8_t rt_type = rt_key_[0];
     688           0 :             if (rt_type == SPMSIADRoute) {
     689           0 :                 repr += "-3";
     690           0 :                 repr += "-" + rd.ToString();
     691           0 :                 key_offset += kRdSize + 1;
     692             :                 Ip4Address ip = Ip4Address(get_value
     693           0 :                                      (&rt_key_[key_offset], kIp4AddrSize));
     694           0 :                 repr += "," + ip.to_string();
     695           0 :                 key_offset += kIp4AddrSize + 1;
     696           0 :                 ip = Ip4Address(get_value (&rt_key_[key_offset], kIp4AddrSize));
     697           0 :                 key_offset += kIp4AddrSize;
     698           0 :                 repr += "," + ip.to_string();
     699           0 :                 ip = Ip4Address(get_value (&rt_key_[key_offset], kIp4AddrSize));
     700           0 :                 repr += "," + ip.to_string();
     701           0 :             } else if (rt_type == InterASPMSIADRoute) {
     702           0 :                 repr += "-2";
     703           0 :                 repr += "-" + rd.ToString();
     704           0 :                 key_offset += kRdSize;
     705           0 :                 uint32_t asn = get_value(&rt_key_[key_offset], kAsnSize);
     706           0 :                 repr += "," + integerToString(asn);
     707             :             }
     708           0 :             repr += "," + originator_.to_string();
     709           0 :             break;
     710             :         }
     711           0 :         case SourceActiveADRoute:
     712           0 :             repr += "-" + rd_.ToString();
     713           0 :             repr += "," + source_.to_string();
     714           0 :             repr += "," + group_.to_string();
     715           0 :             break;
     716           0 :         case SharedTreeJoinRoute:
     717             :         case SourceTreeJoinRoute:
     718           0 :             repr += "-" + rd_.ToString();
     719           0 :             repr += "," + integerToString(asn_);
     720           0 :             repr += "," + source_.to_string();
     721           0 :             repr += "," + group_.to_string();
     722           0 :             break;
     723             :     }
     724           0 :     return repr;
     725           0 : }
     726             : 
     727           0 : int MvpnPrefix::CompareTo(const MvpnPrefix &rhs) const {
     728           0 :     KEY_COMPARE(type_, rhs.type_);
     729             : 
     730           0 :     switch (type_) {
     731           0 :     case IntraASPMSIADRoute:
     732           0 :         KEY_COMPARE(rd_, rhs.rd_);
     733           0 :         KEY_COMPARE(originator_, rhs.originator_);
     734           0 :         break;
     735           0 :     case InterASPMSIADRoute:
     736           0 :         KEY_COMPARE(rd_, rhs.rd_);
     737           0 :         KEY_COMPARE(asn_, rhs.asn_);
     738           0 :         break;
     739           0 :     case SPMSIADRoute:
     740           0 :         KEY_COMPARE(rd_, rhs.rd_);
     741           0 :         KEY_COMPARE(source_, rhs.source_);
     742           0 :         KEY_COMPARE(group_, rhs.group_);
     743           0 :         KEY_COMPARE(originator_, rhs.originator_);
     744           0 :         break;
     745           0 :     case LeafADRoute:
     746           0 :         KEY_COMPARE(rt_key_, rhs.rt_key_);
     747           0 :         KEY_COMPARE(originator_, rhs.originator_);
     748           0 :         break;
     749           0 :     case SourceActiveADRoute:
     750           0 :         KEY_COMPARE(rd_, rhs.rd_);
     751           0 :         KEY_COMPARE(source_, rhs.source_);
     752           0 :         KEY_COMPARE(group_, rhs.group_);
     753           0 :         break;
     754           0 :     case SourceTreeJoinRoute:
     755             :     case SharedTreeJoinRoute:
     756           0 :         KEY_COMPARE(rd_, rhs.rd_);
     757           0 :         KEY_COMPARE(asn_, rhs.asn_);
     758           0 :         KEY_COMPARE(source_, rhs.source_);
     759           0 :         KEY_COMPARE(group_, rhs.group_);
     760           0 :         break;
     761           0 :     default:
     762           0 :         break;
     763             :     }
     764           0 :     return 0;
     765             : }
     766             : 
     767             : // Populate LeafADRoute(Type4) rt_key_ from SPMSIADRoute(Type3)
     768           0 : void MvpnPrefix::SetLeafADPrefixFromSPMSIPrefix(const MvpnPrefix &prefix) {
     769           0 :     assert(prefix.type() == SPMSIADRoute);
     770             : 
     771           0 :     size_t key_size = kPrefixBytes + kSPMSIADRouteSize;
     772           0 :     rt_key_.resize(key_size);
     773           0 :     size_t key_offset = 0;
     774           0 :     rt_key_[key_offset++] = SPMSIADRoute;
     775           0 :     rt_key_[key_offset++] = (uint8_t)kSPMSIADRouteSize;
     776           0 :     copy(prefix.route_distinguisher().GetData(),
     777           0 :             prefix.route_distinguisher().GetData() + kRdSize,
     778           0 :             rt_key_.begin() + key_offset);
     779           0 :     size_t source_offset = key_offset+ kRdSize;
     780           0 :     rt_key_[source_offset++] = kIp4AddrBitSize;
     781           0 :     RouteDistinguisher rd(prefix.route_distinguisher().GetData());
     782           0 :     rd_ = rd;
     783           0 :     const Ip4Address::bytes_type &source_bytes = prefix.source().to_bytes();
     784           0 :     copy(source_bytes.begin(), source_bytes.begin() + kIp4AddrSize,
     785           0 :                                            rt_key_.begin() + source_offset);
     786           0 :     size_t group_offset = source_offset + kIp4AddrSize;
     787           0 :     source_ = Ip4Address(prefix.source().to_ulong());
     788           0 :     rt_key_[group_offset++] = kIp4AddrBitSize;
     789           0 :     const Ip4Address::bytes_type &group_bytes = prefix.group().to_bytes();
     790           0 :     copy(group_bytes.begin(), group_bytes.begin() +
     791           0 :                 kIp4AddrSize, rt_key_.begin() + group_offset);
     792           0 :     size_t originator_offset = group_offset + kIp4AddrSize;
     793           0 :     group_ = Ip4Address(prefix.group().to_ulong());
     794             :     const Ip4Address::bytes_type &originator_bytes =
     795           0 :             prefix.originator().to_bytes();
     796           0 :     copy(originator_bytes.begin(), originator_bytes.begin() +
     797           0 :                 kIp4AddrSize, rt_key_.begin() + originator_offset);
     798           0 : }
     799             : 
     800           0 : void MvpnPrefix::SetSPMSIPrefixFromLeafADPrefix(const MvpnPrefix &prefix) {
     801           0 :     assert(prefix.type() == LeafADRoute);
     802           0 :     RouteDistinguisher rd(prefix.route_distinguisher().GetData());
     803           0 :     rd_ = rd;
     804           0 :     source_ = Ip4Address(prefix.source().to_ulong());
     805           0 :     group_ = Ip4Address(prefix.group().to_ulong());
     806           0 :     originator_ = prefix.GetType3OriginatorFromType4Route();
     807           0 :     type_ = SPMSIADRoute;
     808           0 : }
     809             : 
     810           0 : string MvpnPrefix::ToXmppIdString() const {
     811           0 :     string repr = rd_.ToString();
     812           0 :     repr += ":" + group_.to_string();
     813           0 :     repr += "," + source_.to_string();
     814           0 :     return repr;
     815           0 : }
     816             : 
     817           0 : bool MvpnPrefix::IsValid(uint8_t type) {
     818           0 :     return (type > Unspecified) && (type <= SourceTreeJoinRoute);
     819             : }
     820             : 
     821           0 : bool MvpnPrefix::operator==(const MvpnPrefix &rhs) const {
     822             :     return (
     823           0 :         type_ == rhs.type_ &&
     824           0 :         rd_ == rhs.rd_ &&
     825           0 :         originator_ == rhs.originator_ &&
     826           0 :         group_ == rhs.group_ &&
     827           0 :         source_ == rhs.source_);
     828             : }
     829             : 
     830           0 : MvpnRoute::MvpnRoute(const MvpnPrefix &prefix) : prefix_(prefix) {
     831           0 : }
     832             : 
     833           0 : int MvpnRoute::CompareTo(const Route &rhs) const {
     834           0 :     const MvpnRoute &other = static_cast<const MvpnRoute &>(rhs);
     835           0 :     return prefix_.CompareTo(other.prefix_);
     836             :     KEY_COMPARE(prefix_.type(), other.prefix_.type());
     837             :     KEY_COMPARE(
     838             :         prefix_.route_distinguisher(), other.prefix_.route_distinguisher());
     839             :     KEY_COMPARE(prefix_.originator(), other.prefix_.originator());
     840             :     KEY_COMPARE(prefix_.source(), other.prefix_.source());
     841             :     KEY_COMPARE(prefix_.group(), other.prefix_.group());
     842             :     KEY_COMPARE(prefix_.asn(), other.prefix_.asn());
     843             :     return 0;
     844             : }
     845             : 
     846           0 : string MvpnRoute::ToString() const {
     847           0 :     return prefix_.ToString();
     848             : }
     849             : 
     850           0 : string MvpnRoute::ToXmppIdString() const {
     851           0 :     if (xmpp_id_str_.empty())
     852           0 :         xmpp_id_str_ = prefix_.ToXmppIdString();
     853           0 :     return xmpp_id_str_;
     854             : }
     855             : 
     856           0 : bool MvpnRoute::IsValid() const {
     857           0 :     if (!BgpRoute::IsValid())
     858           0 :         return false;
     859             : 
     860           0 :     return true;
     861             : }
     862             : 
     863           0 : void MvpnRoute::SetKey(const DBRequestKey *reqkey) {
     864           0 :     const MvpnTable::RequestKey *key =
     865             :         static_cast<const MvpnTable::RequestKey *>(reqkey);
     866           0 :     prefix_ = key->prefix;
     867           0 : }
     868             : 
     869           0 : void MvpnRoute::BuildProtoPrefix(BgpProtoPrefix *prefix,
     870             :     const BgpAttr *attr, uint32_t label, uint32_t l3_label) const {
     871           0 :     prefix_.BuildProtoPrefix(prefix);
     872           0 : }
     873             : 
     874           0 : void MvpnRoute::BuildBgpProtoNextHop(
     875             :     vector<uint8_t> &nh, IpAddress nexthop) const {
     876           0 :     nh.resize(4);
     877           0 :     const Ip4Address::bytes_type &addr_bytes = nexthop.to_v4().to_bytes();
     878           0 :     copy(addr_bytes.begin(), addr_bytes.end(), nh.begin());
     879           0 : }
     880             : 
     881           0 : DBEntryBase::KeyPtr MvpnRoute::GetDBRequestKey() const {
     882             :     MvpnTable::RequestKey *key;
     883           0 :     key = new MvpnTable::RequestKey(GetPrefix(), NULL);
     884           0 :     return KeyPtr(key);
     885             : }
     886             : 
     887           0 : const string MvpnPrefix::GetType() const {
     888           0 :     switch (type_) {
     889           0 :         case Unspecified:
     890           0 :             return "Unspecified";
     891           0 :         case IntraASPMSIADRoute:
     892           0 :             return "IntraASPMSIADRoute";
     893           0 :         case InterASPMSIADRoute:
     894           0 :             return "InterASPMSIADRoute";
     895           0 :         case SPMSIADRoute:
     896           0 :             return "SPMSIADRoute";
     897           0 :         case LeafADRoute:
     898           0 :             return "LeafADRoute";
     899           0 :         case SourceActiveADRoute:
     900           0 :             return "SourceActiveADRoute";
     901           0 :         case SharedTreeJoinRoute:
     902           0 :             return "SharedTreeJoinRoute";
     903           0 :         case SourceTreeJoinRoute:
     904           0 :             return "SourceTreeJoinRoute";
     905             :     }
     906           0 :     return "";
     907             : }
     908             : 
     909           0 : const string MvpnRoute::GetType() const {
     910           0 :     return GetPrefix().GetType();
     911             : }

Generated by: LCOV version 1.14