LCOV - code coverage report
Current view: top level - net - rd.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 96 96 100.0 %
Date: 2026-11-16 02:06:09 Functions: 11 11 100.0 %
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 "net/rd.h"
       7             : 
       8             : #include <string>
       9             : 
      10             : #include "base/parse_object.h"
      11             : #include "base/address.h"
      12             : 
      13             : using std::string;
      14             : 
      15             : RouteDistinguisher RouteDistinguisher::kZeroRd;
      16             : 
      17     1911181 : RouteDistinguisher::RouteDistinguisher() {
      18     1911181 :     memset(data_, 0, kSize);
      19     1911181 : }
      20             : 
      21      188870 : RouteDistinguisher::RouteDistinguisher(const uint8_t *data) {
      22      188870 :     memcpy(data_, data, kSize);
      23      188870 : }
      24             : 
      25      233366 : RouteDistinguisher::RouteDistinguisher(uint32_t address, uint16_t vrf_id) {
      26      233366 :     put_value(data_, 2, TypeIpAddressBased);
      27      233365 :     put_value(data_ + 2, 4, address);
      28      233365 :     put_value(data_ + 6, 2, vrf_id);
      29      233366 : }
      30             : 
      31        1255 : RouteDistinguisher::RouteDistinguisher(bool is_bgpaas, uint32_t asn, uint16_t vmi_index) {
      32        1255 :     put_value(data_, 2, Type4ByteASBased);
      33        1255 :     put_value(data_ + 2, 4, asn);
      34        1255 :     put_value(data_ + 6, 2, vmi_index);
      35        1255 : }
      36             : 
      37           8 : RouteDistinguisher::RouteDistinguisher(uint16_t cluster_seed, uint32_t address,
      38           8 :                                        uint16_t vrf_id) {
      39           8 :     put_value(data_, 2, TypeIpAddressBased);
      40           8 :     put_value(data_ + 2, 2, cluster_seed);
      41           8 :     put_value(data_ + 4, 2, (address & 0xFFFF));
      42           8 :     put_value(data_ + 6, 2, vrf_id);
      43           8 : }
      44             : 
      45       62788 : uint16_t RouteDistinguisher::Type() const {
      46       62788 :     return get_value(data_, 2);
      47             : }
      48             : 
      49       41364 : uint32_t RouteDistinguisher::GetAddress() const {
      50       41364 :     return (Type() == TypeIpAddressBased ? get_value(data_ + 2, 4) : 0);
      51             : }
      52             : 
      53       19958 : uint16_t RouteDistinguisher::GetVrfId() const {
      54       19958 :     return (Type() == TypeIpAddressBased ? get_value(data_ + 6, 2) : 0);
      55             : }
      56             : 
      57     2372063 : string RouteDistinguisher::ToString() const {
      58             :     char temp[32];
      59             : 
      60     2372063 :     uint16_t rd_type = get_value(data_, 2);
      61     2372068 :     if (rd_type == Type2ByteASBased) {
      62      686308 :         uint16_t asn = get_value(data_ + 2, 2);
      63      686327 :         uint32_t value = get_value(data_ + 4, 4);
      64      686331 :         snprintf(temp, sizeof(temp), "%u:%u", asn, value);
      65      686331 :         return string(temp);
      66     1685760 :     } else if (rd_type == TypeIpAddressBased) {
      67     1684144 :         Ip4Address ip(get_value(data_ + 2, 4));
      68     1684141 :         uint16_t value = get_value(data_ + 6, 2);
      69     1684140 :         snprintf(temp, sizeof(temp), ":%u", value);
      70     3368292 :         return ip.to_string() + temp;
      71        1616 :     } else if (rd_type == Type4ByteASBased) {
      72        1614 :         uint32_t asn = get_value(data_ + 2, 4);
      73        1614 :         uint16_t value = get_value(data_ + 6, 2);
      74        1614 :         snprintf(temp, sizeof(temp), "%u:%u", asn, value);
      75        1614 :         return string(temp);
      76             :     } else {
      77           2 :         snprintf(temp, sizeof(temp), "%u:%02x:%02x:%02x:%02x:%02x:%02x",
      78           2 :             rd_type, data_[2], data_[3], data_[4], data_[5], data_[6],
      79           2 :             data_[7]);
      80           2 :         return string(temp);
      81             :     }
      82             : }
      83             : 
      84      179633 : RouteDistinguisher RouteDistinguisher::FromString(
      85             :     const string &str, boost::system::error_code *errorp) {
      86      179633 :     RouteDistinguisher rd;
      87      179633 :     size_t pos = str.rfind(':');
      88      179633 :     if (pos == string::npos) {
      89          34 :         if (errorp != NULL) {
      90           1 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
      91             :         }
      92          34 :         return RouteDistinguisher::kZeroRd;
      93             :     }
      94             : 
      95      179599 :     boost::system::error_code ec;
      96      179599 :     string first(str.substr(0, pos));
      97      179599 :     Ip4Address addr = Ip4Address::from_string(first, ec);
      98             :     int offset;
      99             :     char *endptr;
     100      179599 :     int32_t asn = -1;
     101      179599 :     if (ec.value() != 0) {
     102             :         // Not an IP address, try ASN.
     103       69730 :         asn = strtol(first.c_str(), &endptr, 10);
     104       69730 :         if (asn >= 65535 || *endptr != '\0') {
     105           8 :             if (errorp != NULL) {
     106             :                 *errorp =
     107           8 :                     make_error_code(boost::system::errc::invalid_argument);
     108             :             }
     109           8 :             return RouteDistinguisher::kZeroRd;
     110             :         }
     111             : 
     112       69722 :         put_value(rd.data_, 2, 0);
     113       69722 :         put_value(rd.data_ + 2, 2, asn);
     114       69722 :         offset = 4;
     115             :     } else {
     116      109869 :         put_value(rd.data_, 2, 1);
     117      109869 :         put_value(rd.data_ + 2, 4, addr.to_ulong());
     118      109869 :         offset = 6;
     119             :     }
     120             : 
     121      179591 :     string second(str, pos + 1);
     122      179591 :     uint64_t value = strtol(second.c_str(), &endptr, 10);
     123      179591 :     if (*endptr != '\0') {
     124           4 :         if (errorp != NULL) {
     125           4 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
     126             :         }
     127           4 :         return RouteDistinguisher::kZeroRd;
     128             :     }
     129             : 
     130             :     // ASN 0 is not allowed if the assigned number is not 0.
     131      179587 :     if (asn == 0 && value != 0) {
     132           2 :         if (errorp != NULL) {
     133           2 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
     134             :         }
     135           2 :         return RouteDistinguisher::kZeroRd;
     136             :     }
     137             : 
     138             :     // Check assigned number for type 0.
     139      179585 :     if (offset == 4 && value > 0xFFFFFFFF) {
     140           2 :         if (errorp != NULL) {
     141           2 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
     142             :         }
     143           2 :         return RouteDistinguisher::kZeroRd;
     144             :     }
     145             : 
     146             :     // Check assigned number for type 1.
     147      179583 :     if (offset == 6 && value > 0xFFFF) {
     148          11 :         if (errorp != NULL) {
     149          11 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
     150             :         }
     151          11 :         return RouteDistinguisher::kZeroRd;
     152             :     }
     153             : 
     154      179572 :     put_value(rd.data_ + offset, 8 - offset, value);
     155      179572 :     return rd;
     156      179599 : }
     157             : 
     158    39653499 : int RouteDistinguisher::CompareTo(const RouteDistinguisher &rhs) const {
     159    39653499 :     return memcmp(data_, rhs.data_, kSize);
     160             : }

Generated by: LCOV version 1.14