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 : }
|