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 1908914 : RouteDistinguisher::RouteDistinguisher() {
18 1908914 : memset(data_, 0, kSize);
19 1908914 : }
20 :
21 189114 : RouteDistinguisher::RouteDistinguisher(const uint8_t *data) {
22 189114 : memcpy(data_, data, kSize);
23 189114 : }
24 :
25 233285 : RouteDistinguisher::RouteDistinguisher(uint32_t address, uint16_t vrf_id) {
26 233285 : put_value(data_, 2, TypeIpAddressBased);
27 233285 : put_value(data_ + 2, 4, address);
28 233284 : put_value(data_ + 6, 2, vrf_id);
29 233284 : }
30 :
31 1247 : RouteDistinguisher::RouteDistinguisher(bool is_bgpaas, uint32_t asn, uint16_t vmi_index) {
32 1247 : put_value(data_, 2, Type4ByteASBased);
33 1247 : put_value(data_ + 2, 4, asn);
34 1247 : put_value(data_ + 6, 2, vmi_index);
35 1247 : }
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 62606 : uint16_t RouteDistinguisher::Type() const {
46 62606 : return get_value(data_, 2);
47 : }
48 :
49 41239 : uint32_t RouteDistinguisher::GetAddress() const {
50 41239 : return (Type() == TypeIpAddressBased ? get_value(data_ + 2, 4) : 0);
51 : }
52 :
53 19890 : uint16_t RouteDistinguisher::GetVrfId() const {
54 19890 : return (Type() == TypeIpAddressBased ? get_value(data_ + 6, 2) : 0);
55 : }
56 :
57 2373299 : string RouteDistinguisher::ToString() const {
58 : char temp[32];
59 :
60 2373299 : uint16_t rd_type = get_value(data_, 2);
61 2373324 : if (rd_type == Type2ByteASBased) {
62 687792 : uint16_t asn = get_value(data_ + 2, 2);
63 687801 : uint32_t value = get_value(data_ + 4, 4);
64 687803 : snprintf(temp, sizeof(temp), "%u:%u", asn, value);
65 687803 : return string(temp);
66 1685532 : } else if (rd_type == TypeIpAddressBased) {
67 1683928 : Ip4Address ip(get_value(data_ + 2, 4));
68 1683928 : uint16_t value = get_value(data_ + 6, 2);
69 1683931 : snprintf(temp, sizeof(temp), ":%u", value);
70 3367871 : return ip.to_string() + temp;
71 1604 : } else if (rd_type == Type4ByteASBased) {
72 1602 : uint32_t asn = get_value(data_ + 2, 4);
73 1602 : uint16_t value = get_value(data_ + 6, 2);
74 1602 : snprintf(temp, sizeof(temp), "%u:%u", asn, value);
75 1602 : 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 178660 : RouteDistinguisher RouteDistinguisher::FromString(
85 : const string &str, boost::system::error_code *errorp) {
86 178660 : RouteDistinguisher rd;
87 178660 : size_t pos = str.rfind(':');
88 178660 : 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 178626 : boost::system::error_code ec;
96 178626 : string first(str.substr(0, pos));
97 178626 : Ip4Address addr = Ip4Address::from_string(first, ec);
98 : int offset;
99 : char *endptr;
100 178626 : int32_t asn = -1;
101 178626 : if (ec.value() != 0) {
102 : // Not an IP address, try ASN.
103 69717 : asn = strtol(first.c_str(), &endptr, 10);
104 69717 : 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 69709 : put_value(rd.data_, 2, 0);
113 69709 : put_value(rd.data_ + 2, 2, asn);
114 69709 : offset = 4;
115 : } else {
116 108909 : put_value(rd.data_, 2, 1);
117 108909 : put_value(rd.data_ + 2, 4, addr.to_ulong());
118 108909 : offset = 6;
119 : }
120 :
121 178618 : string second(str, pos + 1);
122 178618 : uint64_t value = strtol(second.c_str(), &endptr, 10);
123 178618 : 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 178614 : 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 178612 : 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 178610 : 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 178599 : put_value(rd.data_ + offset, 8 - offset, value);
155 178599 : return rd;
156 178626 : }
157 :
158 39664003 : int RouteDistinguisher::CompareTo(const RouteDistinguisher &rhs) const {
159 39664003 : return memcmp(data_, rhs.data_, kSize);
160 : }
|
