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