Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "net/rd.h"
       6             : 
       7             : #include <string>
       8             : 
       9             : #include "base/parse_object.h"
      10             : #include "base/address.h"
      11             : 
      12             : using std::string;
      13             : 
      14             : RouteDistinguisher RouteDistinguisher::kZeroRd;
      15             : 
      16     1888776 : RouteDistinguisher::RouteDistinguisher() {
      17     1888776 :     memset(data_, 0, kSize);
      18     1888776 : }
      19             : 
      20      189236 : RouteDistinguisher::RouteDistinguisher(const uint8_t *data) {
      21      189236 :     memcpy(data_, data, kSize);
      22      189236 : }
      23             : 
      24      233382 : RouteDistinguisher::RouteDistinguisher(uint32_t address, uint16_t vrf_id) {
      25      233382 :     put_value(data_, 2, TypeIpAddressBased);
      26      233381 :     put_value(data_ + 2, 4, address);
      27      233381 :     put_value(data_ + 6, 2, vrf_id);
      28      233382 : }
      29             : 
      30        1246 : RouteDistinguisher::RouteDistinguisher(bool is_bgpaas, uint32_t asn, uint16_t vmi_index) {
      31        1246 :     put_value(data_, 2, Type4ByteASBased);
      32        1246 :     put_value(data_ + 2, 4, asn);
      33        1246 :     put_value(data_ + 6, 2, vmi_index);
      34        1246 : }
      35             : 
      36           8 : RouteDistinguisher::RouteDistinguisher(uint16_t cluster_seed, uint32_t address,
      37           8 :                                        uint16_t vrf_id) {
      38           8 :     put_value(data_, 2, TypeIpAddressBased);
      39           8 :     put_value(data_ + 2, 2, cluster_seed);
      40           8 :     put_value(data_ + 4, 2, (address & 0xFFFF));
      41           8 :     put_value(data_ + 6, 2, vrf_id);
      42           8 : }
      43             : 
      44       62862 : uint16_t RouteDistinguisher::Type() const {
      45       62862 :     return get_value(data_, 2);
      46             : }
      47             : 
      48       41411 : uint32_t RouteDistinguisher::GetAddress() const {
      49       41411 :     return (Type() == TypeIpAddressBased ? get_value(data_ + 2, 4) : 0);
      50             : }
      51             : 
      52       19978 : uint16_t RouteDistinguisher::GetVrfId() const {
      53       19978 :     return (Type() == TypeIpAddressBased ? get_value(data_ + 6, 2) : 0);
      54             : }
      55             : 
      56     2356294 : string RouteDistinguisher::ToString() const {
      57             :     char temp[32];
      58             : 
      59     2356294 :     uint16_t rd_type = get_value(data_, 2);
      60     2356326 :     if (rd_type == Type2ByteASBased) {
      61      672071 :         uint16_t asn = get_value(data_ + 2, 2);
      62      672075 :         uint32_t value = get_value(data_ + 4, 4);
      63      672077 :         snprintf(temp, sizeof(temp), "%u:%u", asn, value);
      64      672077 :         return string(temp);
      65     1684255 :     } else if (rd_type == TypeIpAddressBased) {
      66     1682650 :         Ip4Address ip(get_value(data_ + 2, 4));
      67     1682646 :         uint16_t value = get_value(data_ + 6, 2);
      68     1682645 :         snprintf(temp, sizeof(temp), ":%u", value);
      69     3365299 :         return ip.to_string() + temp;
      70        1605 :     } else if (rd_type == Type4ByteASBased) {
      71        1603 :         uint32_t asn = get_value(data_ + 2, 4);
      72        1603 :         uint16_t value = get_value(data_ + 6, 2);
      73        1603 :         snprintf(temp, sizeof(temp), "%u:%u", asn, value);
      74        1603 :         return string(temp);
      75             :     } else {
      76           2 :         snprintf(temp, sizeof(temp), "%u:%02x:%02x:%02x:%02x:%02x:%02x",
      77           2 :             rd_type, data_[2], data_[3], data_[4], data_[5], data_[6],
      78           2 :             data_[7]);
      79           2 :         return string(temp);
      80             :     }
      81             : }
      82             : 
      83      177193 : RouteDistinguisher RouteDistinguisher::FromString(
      84             :     const string &str, boost::system::error_code *errorp) {
      85      177193 :     RouteDistinguisher rd;
      86      177193 :     size_t pos = str.rfind(':');
      87      177193 :     if (pos == string::npos) {
      88          33 :         if (errorp != NULL) {
      89           1 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
      90             :         }
      91          33 :         return RouteDistinguisher::kZeroRd;
      92             :     }
      93             : 
      94      177160 :     boost::system::error_code ec;
      95      177160 :     string first(str.substr(0, pos));
      96      177160 :     Ip4Address addr = Ip4Address::from_string(first, ec);
      97             :     int offset;
      98             :     char *endptr;
      99      177160 :     int32_t asn = -1;
     100      177160 :     if (ec.value() != 0) {
     101             :         // Not an IP address, try ASN.
     102       69751 :         asn = strtol(first.c_str(), &endptr, 10);
     103       69751 :         if (asn >= 65535 || *endptr != '\0') {
     104           8 :             if (errorp != NULL) {
     105             :                 *errorp =
     106           8 :                     make_error_code(boost::system::errc::invalid_argument);
     107             :             }
     108           8 :             return RouteDistinguisher::kZeroRd;
     109             :         }
     110             : 
     111       69743 :         put_value(rd.data_, 2, 0);
     112       69743 :         put_value(rd.data_ + 2, 2, asn);
     113       69743 :         offset = 4;
     114             :     } else {
     115      107409 :         put_value(rd.data_, 2, 1);
     116      107409 :         put_value(rd.data_ + 2, 4, addr.to_ulong());
     117      107409 :         offset = 6;
     118             :     }
     119             : 
     120      177152 :     string second(str, pos + 1);
     121      177152 :     uint64_t value = strtol(second.c_str(), &endptr, 10);
     122      177152 :     if (*endptr != '\0') {
     123           4 :         if (errorp != NULL) {
     124           4 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
     125             :         }
     126           4 :         return RouteDistinguisher::kZeroRd;
     127             :     }
     128             : 
     129             :     // ASN 0 is not allowed if the assigned number is not 0.
     130      177148 :     if (asn == 0 && value != 0) {
     131           2 :         if (errorp != NULL) {
     132           2 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
     133             :         }
     134           2 :         return RouteDistinguisher::kZeroRd;
     135             :     }
     136             : 
     137             :     // Check assigned number for type 0.
     138      177146 :     if (offset == 4 && value > 0xFFFFFFFF) {
     139           2 :         if (errorp != NULL) {
     140           2 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
     141             :         }
     142           2 :         return RouteDistinguisher::kZeroRd;
     143             :     }
     144             : 
     145             :     // Check assigned number for type 1.
     146      177144 :     if (offset == 6 && value > 0xFFFF) {
     147          11 :         if (errorp != NULL) {
     148          11 :             *errorp = make_error_code(boost::system::errc::invalid_argument);
     149             :         }
     150          11 :         return RouteDistinguisher::kZeroRd;
     151             :     }
     152             : 
     153      177133 :     put_value(rd.data_ + offset, 8 - offset, value);
     154      177133 :     return rd;
     155      177160 : }
     156             : 
     157    39070909 : int RouteDistinguisher::CompareTo(const RouteDistinguisher &rhs) const {
     158    39070909 :     return memcmp(data_, rhs.data_, kSize);
     159             : }