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 "bgp/evpn/evpn_route.h"
7 :
8 : #include <algorithm>
9 : #include <sstream>
10 :
11 : #include "base/string_util.h"
12 : #include "bgp/bgp_server.h"
13 : #include "bgp/evpn/evpn_table.h"
14 :
15 : using std::copy;
16 : using std::string;
17 : using std::vector;
18 :
19 : const EvpnPrefix EvpnPrefix::kNullPrefix;
20 : const uint32_t EvpnPrefix::kInvalidLabel = 0x01000000;
21 : const uint32_t EvpnPrefix::kNullTag = 0;
22 : const uint32_t EvpnPrefix::kMaxTag = 0xFFFFFFFF;
23 : const uint32_t EvpnPrefix::kMaxVni = 0x00FFFFFF;
24 : const int32_t EvpnPrefix::kMaxVniSigned =
25 : static_cast<uint32_t>(EvpnPrefix::kMaxVni);
26 :
27 : const size_t EvpnPrefix::kRdSize = RouteDistinguisher::kSize;
28 : const size_t EvpnPrefix::kEsiSize = EthernetSegmentId::kSize;
29 : const size_t EvpnPrefix::kTagSize = 4;
30 : const size_t EvpnPrefix::kIp4AddrSize = 4;
31 : const size_t EvpnPrefix::kIp6AddrSize = 16;
32 : const size_t EvpnPrefix::kMacSize = MacAddress::size();
33 : const size_t EvpnPrefix::kLabelSize = BgpProtoPrefix::kLabelSize;
34 :
35 : const size_t EvpnPrefix::kMinAutoDiscoveryRouteSize =
36 : kRdSize + kEsiSize + kTagSize;
37 : const size_t EvpnPrefix::kMinMacAdvertisementRouteSize =
38 : kRdSize + kEsiSize + kTagSize + 1 + kMacSize + 1;
39 : const size_t EvpnPrefix::kMinInclusiveMulticastRouteSize =
40 : kRdSize + kTagSize + 1;
41 : const size_t EvpnPrefix::kMinSelectiveMulticastRouteSize =
42 : kRdSize + kTagSize + 3;
43 : const size_t EvpnPrefix::kMinSegmentRouteSize =
44 : kRdSize + kEsiSize + 1;
45 : const size_t EvpnPrefix::kMinInetPrefixRouteSize =
46 : kRdSize + kEsiSize + kTagSize + 1 + 2 * kIp4AddrSize;
47 : const size_t EvpnPrefix::kMinInet6PrefixRouteSize =
48 : kRdSize + kEsiSize + kTagSize + 1 + 2 * kIp6AddrSize;
49 :
50 : //
51 : // Read label from the BgpProtoPrefix.
52 : // If the encapsulation is VXLAN and ethernet tag is non-zero use that as
53 : // the label for backward compatibility with older JUNOS code.
54 : //
55 : // Note that Ethernet AD Routes per ESI always set ethernet tag to kMaxTag
56 : // and their label is supposed to be set to 0 on write and ignored on read.
57 : //
58 2048 : static uint32_t ReadLabel(const BgpProtoPrefix &proto_prefix,
59 : const BgpAttr *attr, size_t offset, uint32_t tag = EvpnPrefix::kNullTag) {
60 2048 : if (!attr)
61 640 : return 0;
62 1408 : const ExtCommunity *extcomm = attr->ext_community();
63 1408 : if (extcomm && extcomm->ContainsTunnelEncapVxlan()) {
64 0 : if (tag) {
65 0 : if (tag == EvpnPrefix::kMaxTag) {
66 0 : return 0;
67 0 : } else if (tag <= EvpnPrefix::kMaxVni) {
68 0 : return tag;
69 : } else {
70 0 : return proto_prefix.ReadLabel(offset, true);
71 : }
72 : } else {
73 0 : return proto_prefix.ReadLabel(offset, true);
74 : }
75 : } else {
76 1408 : return proto_prefix.ReadLabel(offset, false);
77 : }
78 : }
79 :
80 : //
81 : // Write label to the BgpProtoPrefix.
82 : //
83 2340 : static void WriteLabel(BgpProtoPrefix *proto_prefix,
84 : const BgpAttr *attr, size_t offset, uint32_t label) {
85 2340 : const ExtCommunity *extcomm = attr ? attr->ext_community() : NULL;
86 2340 : if (extcomm && extcomm->ContainsTunnelEncapVxlan()) {
87 0 : proto_prefix->WriteLabel(offset, label, true);
88 : } else {
89 2340 : proto_prefix->WriteLabel(offset, label, false);
90 : }
91 2340 : }
92 :
93 : //
94 : // Read gateway address from the BgpProtoPrefix.
95 : //
96 0 : static IpAddress ReadGwAddress(const BgpProtoPrefix &proto_prefix,
97 : size_t gw_offset, size_t ip_size) {
98 0 : assert(ip_size == EvpnPrefix::kIp4AddrSize ||
99 : ip_size == EvpnPrefix::kIp6AddrSize);
100 0 : if (ip_size == EvpnPrefix::kIp4AddrSize) {
101 : Ip4Address::bytes_type bytes;
102 0 : copy(proto_prefix.prefix.begin() + gw_offset,
103 0 : proto_prefix.prefix.begin() + gw_offset + ip_size, bytes.begin());
104 0 : return Ip4Address(bytes);
105 : } else {
106 : Ip6Address::bytes_type bytes;
107 0 : copy(proto_prefix.prefix.begin() + gw_offset,
108 0 : proto_prefix.prefix.begin() + gw_offset + ip_size, bytes.begin());
109 0 : return Ip6Address(bytes);
110 : }
111 : return IpAddress();
112 : }
113 :
114 2049 : EvpnPrefix::EvpnPrefix()
115 2049 : : type_(Unspecified),
116 2049 : tag_(EvpnPrefix::kNullTag),
117 2049 : family_(Address::UNSPEC),
118 2049 : ip_prefixlen_(0) {
119 2049 : }
120 :
121 0 : EvpnPrefix::EvpnPrefix(const RouteDistinguisher &rd,
122 0 : const EthernetSegmentId &esi, uint32_t tag)
123 0 : : type_(AutoDiscoveryRoute),
124 0 : rd_(rd),
125 0 : esi_(esi),
126 0 : tag_(tag),
127 0 : family_(Address::UNSPEC),
128 0 : ip_prefixlen_(0) {
129 0 : }
130 :
131 0 : EvpnPrefix::EvpnPrefix(const RouteDistinguisher &rd,
132 0 : const MacAddress &mac_addr, const IpAddress &ip_address)
133 0 : : type_(MacAdvertisementRoute),
134 0 : rd_(rd),
135 0 : tag_(EvpnPrefix::kNullTag),
136 0 : mac_addr_(mac_addr),
137 0 : family_(Address::UNSPEC),
138 0 : ip_address_(ip_address),
139 0 : ip_prefixlen_(0) {
140 0 : if (ip_address_.is_v4() && !ip_address_.is_unspecified()) {
141 0 : family_ = Address::INET;
142 0 : } else if (ip_address_.is_v6() && !ip_address_.is_unspecified()) {
143 0 : family_ = Address::INET6;
144 : }
145 0 : }
146 :
147 256 : EvpnPrefix::EvpnPrefix(const RouteDistinguisher &rd, uint32_t tag,
148 256 : const MacAddress &mac_addr, const IpAddress &ip_address)
149 256 : : type_(MacAdvertisementRoute), rd_(rd), tag_(tag),
150 256 : mac_addr_(mac_addr), family_(Address::UNSPEC),
151 512 : ip_address_(ip_address), ip_prefixlen_(0) {
152 256 : if (ip_address_.is_v4() && !ip_address_.is_unspecified()) {
153 0 : family_ = Address::INET;
154 256 : } else if (ip_address_.is_v6() && !ip_address_.is_unspecified()) {
155 0 : family_ = Address::INET6;
156 : }
157 256 : }
158 :
159 0 : EvpnPrefix::EvpnPrefix(const RouteDistinguisher &rd, uint32_t tag,
160 0 : const IpAddress &ip_address)
161 0 : : type_(InclusiveMulticastRoute),
162 0 : rd_(rd),
163 0 : tag_(tag),
164 0 : family_(Address::UNSPEC),
165 0 : ip_address_(ip_address),
166 0 : ip_prefixlen_(0) {
167 0 : if (ip_address_.is_v4() && !ip_address_.is_unspecified()) {
168 0 : family_ = Address::INET;
169 0 : } else if (ip_address_.is_v6() && !ip_address_.is_unspecified()) {
170 0 : family_ = Address::INET6;
171 : }
172 0 : }
173 :
174 0 : EvpnPrefix::EvpnPrefix(const RouteDistinguisher &rd,
175 0 : const EthernetSegmentId &esi, const IpAddress &ip_address)
176 0 : : type_(SegmentRoute),
177 0 : rd_(rd),
178 0 : esi_(esi),
179 0 : tag_(EvpnPrefix::kNullTag),
180 0 : family_(Address::UNSPEC),
181 0 : ip_address_(ip_address),
182 0 : ip_prefixlen_(0) {
183 0 : if (ip_address_.is_v4() && !ip_address_.is_unspecified()) {
184 0 : family_ = Address::INET;
185 0 : } else if (ip_address_.is_v6() && !ip_address_.is_unspecified()) {
186 0 : family_ = Address::INET6;
187 : }
188 0 : }
189 :
190 0 : EvpnPrefix::EvpnPrefix(const RouteDistinguisher &rd,
191 0 : const IpAddress &ip_address, uint8_t ip_prefixlen)
192 0 : : type_(IpPrefixRoute),
193 0 : rd_(rd),
194 0 : tag_(0),
195 0 : family_(Address::UNSPEC),
196 0 : ip_address_(ip_address),
197 0 : ip_prefixlen_(ip_prefixlen) {
198 0 : assert(ip_address_.is_v4() || ip_address_.is_v6());
199 0 : if (ip_address_.is_v4()) {
200 0 : family_ = Address::INET;
201 0 : } else if (ip_address_.is_v6()) {
202 0 : family_ = Address::INET6;
203 : }
204 0 : }
205 :
206 0 : EvpnPrefix::EvpnPrefix(const RouteDistinguisher &rd, uint32_t tag,
207 : const IpAddress &source, const IpAddress &group,
208 0 : const IpAddress &ip_address)
209 0 : : type_(SelectiveMulticastRoute),
210 0 : rd_(rd),
211 0 : tag_(tag),
212 0 : family_(Address::UNSPEC),
213 0 : ip_address_(ip_address),
214 0 : source_(source),
215 0 : group_(group),
216 0 : ip_prefixlen_(0), flags_(0x2) {
217 0 : if (ip_address_.is_v4() && !ip_address_.is_unspecified()) {
218 0 : family_ = Address::INET;
219 0 : } else if (ip_address_.is_v6() && !ip_address_.is_unspecified()) {
220 0 : family_ = Address::INET6;
221 : }
222 0 : string ip = group.to_v4().to_string();
223 0 : char *str = const_cast<char *>(ip.c_str());
224 0 : char * mac_ip = strstr(str, ".");
225 0 : std::ostringstream oss;
226 0 : oss << "01:00:5e:" << strtok(mac_ip, ".");
227 0 : oss << ":" << strtok(NULL, ".");
228 0 : oss << ":" << strtok(NULL, "");
229 0 : mac_addr_ = MacAddress::FromString(oss.str(), NULL);
230 0 : }
231 :
232 2048 : int EvpnPrefix::FromProtoPrefix(BgpServer *server,
233 : const BgpProtoPrefix &proto_prefix, const BgpAttr *attr,
234 : const Address::Family family, EvpnPrefix *prefix, BgpAttrPtr *new_attr,
235 : uint32_t *label, uint32_t *l3_label) {
236 2048 : *new_attr = attr;
237 2048 : *label = 0;
238 2048 : if (l3_label)
239 2048 : *l3_label = 0;
240 2048 : prefix->type_ = proto_prefix.type;
241 2048 : size_t nlri_size = proto_prefix.prefix.size();
242 :
243 2048 : switch (prefix->type_) {
244 0 : case AutoDiscoveryRoute: {
245 0 : size_t expected_min_nlri_size =
246 0 : kMinAutoDiscoveryRouteSize + (attr ? kLabelSize : 0);
247 0 : if (nlri_size < expected_min_nlri_size)
248 0 : return -1;
249 0 : size_t rd_offset = 0;
250 0 : prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
251 0 : size_t esi_offset = rd_offset + kRdSize;
252 0 : prefix->esi_ = EthernetSegmentId(&proto_prefix.prefix[esi_offset]);
253 0 : size_t tag_offset = esi_offset + kEsiSize;
254 0 : prefix->tag_ = get_value(&proto_prefix.prefix[tag_offset], kTagSize);
255 0 : size_t label_offset = tag_offset + kTagSize;
256 0 : *label = ReadLabel(proto_prefix, attr, label_offset, prefix->tag_);
257 0 : break;
258 : }
259 2048 : case MacAdvertisementRoute: {
260 2048 : size_t expected_min_nlri_size =
261 2048 : kMinMacAdvertisementRouteSize + (attr ? kLabelSize : 0);
262 2048 : if (nlri_size < expected_min_nlri_size)
263 0 : return -1;
264 2048 : size_t rd_offset = 0;
265 2048 : prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
266 2048 : size_t esi_offset = rd_offset + kRdSize;
267 2048 : if (attr) {
268 1408 : EthernetSegmentId esi(&proto_prefix.prefix[esi_offset]);
269 1408 : *new_attr = server->attr_db()->ReplaceEsiAndLocate(attr, esi);
270 : }
271 2048 : size_t tag_offset = esi_offset + kEsiSize;
272 2048 : prefix->tag_ = get_value(&proto_prefix.prefix[tag_offset], kTagSize);
273 2048 : size_t mac_len_offset = tag_offset + kTagSize;
274 2048 : size_t mac_len = proto_prefix.prefix[mac_len_offset];
275 2048 : if (mac_len != 48)
276 0 : return -1;
277 2048 : size_t mac_offset = mac_len_offset + 1;
278 2048 : prefix->mac_addr_ = MacAddress(&proto_prefix.prefix[mac_offset]);
279 2048 : size_t ip_len_offset = mac_offset + kMacSize;
280 2048 : size_t ip_len = proto_prefix.prefix[ip_len_offset];
281 2048 : if (ip_len != 0 && ip_len != 32 && ip_len != 128)
282 0 : return -1;
283 2048 : size_t ip_size = ip_len / 8;
284 2048 : if (nlri_size < expected_min_nlri_size + ip_size)
285 0 : return -1;
286 2048 : size_t ip_offset = ip_len_offset + 1;
287 2048 : prefix->ReadIpAddress(proto_prefix, ip_offset, ip_size, ip_size);
288 2048 : size_t label_offset = ip_offset + ip_size;
289 2048 : *label = ReadLabel(proto_prefix, attr, label_offset, prefix->tag_);
290 2048 : size_t l3_label_offset = label_offset + kLabelSize;
291 2048 : if (l3_label && nlri_size >= l3_label_offset + kLabelSize) {
292 0 : *l3_label = ReadLabel(proto_prefix, attr, l3_label_offset);
293 : }
294 2048 : break;
295 : }
296 0 : case InclusiveMulticastRoute: {
297 0 : if (nlri_size < kMinInclusiveMulticastRouteSize)
298 0 : return -1;
299 0 : size_t rd_offset = 0;
300 0 : prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
301 0 : size_t tag_offset = rd_offset + kRdSize;
302 0 : prefix->tag_ = get_value(&proto_prefix.prefix[tag_offset], kTagSize);
303 0 : size_t ip_len_offset = tag_offset + kTagSize;
304 0 : size_t ip_len = proto_prefix.prefix[ip_len_offset];
305 0 : if (ip_len != 32 && ip_len != 128)
306 0 : return -1;
307 0 : size_t ip_size = ip_len / 8;
308 0 : if (nlri_size < kMinInclusiveMulticastRouteSize + ip_size)
309 0 : return -1;
310 0 : size_t ip_offset = ip_len_offset + 1;
311 0 : prefix->ReadIpAddress(proto_prefix, ip_offset, ip_size, ip_size);
312 0 : const PmsiTunnel *pmsi_tunnel = attr ? attr->pmsi_tunnel() : NULL;
313 0 : if (pmsi_tunnel &&
314 0 : (pmsi_tunnel->tunnel_type() == PmsiTunnelSpec::IngressReplication ||
315 0 : pmsi_tunnel->tunnel_type() ==
316 : PmsiTunnelSpec::AssistedReplicationContrail)) {
317 0 : const ExtCommunity *extcomm = attr ? attr->ext_community() : NULL;
318 0 : if (extcomm && extcomm->ContainsTunnelEncapVxlan()) {
319 0 : if (prefix->tag_ && prefix->tag_ <= kMaxVni) {
320 0 : *label = prefix->tag_;
321 : } else {
322 0 : *label = pmsi_tunnel->GetLabel(extcomm);
323 : }
324 : } else {
325 0 : *label = pmsi_tunnel->GetLabel(extcomm);
326 : }
327 : }
328 0 : break;
329 : }
330 0 : case SegmentRoute: {
331 0 : if (nlri_size < kMinSegmentRouteSize)
332 0 : return -1;
333 0 : size_t rd_offset = 0;
334 0 : prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
335 0 : size_t esi_offset = rd_offset + kRdSize;
336 0 : prefix->esi_ = EthernetSegmentId(&proto_prefix.prefix[esi_offset]);
337 0 : size_t ip_len_offset = esi_offset + kEsiSize;
338 0 : size_t ip_len = proto_prefix.prefix[ip_len_offset];
339 0 : if (ip_len != 32 && ip_len != 128)
340 0 : return -1;
341 0 : size_t ip_size = ip_len / 8;
342 0 : if (nlri_size < kMinSegmentRouteSize + ip_size)
343 0 : return -1;
344 0 : size_t ip_offset = ip_len_offset + 1;
345 0 : prefix->ReadIpAddress(proto_prefix, ip_offset, ip_size, ip_size);
346 0 : break;
347 : }
348 0 : case IpPrefixRoute: {
349 : size_t ip_size;
350 0 : if (attr) {
351 0 : if (nlri_size == kMinInet6PrefixRouteSize + kLabelSize) {
352 0 : ip_size = kIp6AddrSize;
353 0 : } else if (nlri_size == kMinInetPrefixRouteSize + kLabelSize) {
354 0 : ip_size = kIp4AddrSize;
355 : } else {
356 0 : return -1;
357 : }
358 : } else {
359 0 : if (nlri_size == kMinInet6PrefixRouteSize ||
360 0 : nlri_size == kMinInet6PrefixRouteSize + kLabelSize) {
361 0 : ip_size = kIp6AddrSize;
362 0 : } else if (nlri_size == kMinInetPrefixRouteSize ||
363 0 : nlri_size == kMinInetPrefixRouteSize + kLabelSize) {
364 0 : ip_size = kIp4AddrSize;
365 : } else {
366 0 : return -1;
367 : }
368 : }
369 :
370 0 : size_t rd_offset = 0;
371 0 : prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
372 0 : size_t esi_offset = rd_offset + kRdSize;
373 0 : EthernetSegmentId esi(&proto_prefix.prefix[esi_offset]);
374 0 : if (!esi.IsZero())
375 0 : return -1;
376 0 : size_t tag_offset = esi_offset + kEsiSize;
377 : // Ignore tag for type5 routes.
378 0 : prefix->tag_ = 0;
379 0 : size_t ip_plen_offset = tag_offset + kTagSize;
380 0 : prefix->ip_prefixlen_ = proto_prefix.prefix[ip_plen_offset];
381 0 : if (ip_size == kIp4AddrSize && prefix->ip_prefixlen_ > 32)
382 0 : return -1;
383 0 : if (ip_size == kIp6AddrSize && prefix->ip_prefixlen_ > 128)
384 0 : return -1;
385 0 : size_t ip_offset = ip_plen_offset + 1;
386 0 : size_t ip_psize = (prefix->ip_prefixlen_ + 7) / 8;
387 0 : prefix->ReadIpAddress(proto_prefix, ip_offset, ip_size, ip_psize);
388 0 : size_t gw_offset = ip_offset + ip_size;
389 0 : IpAddress gw_address = ReadGwAddress(proto_prefix, gw_offset, ip_size);
390 0 : if (!gw_address.is_unspecified())
391 0 : return -1;
392 0 : size_t label_offset = gw_offset + ip_size;
393 0 : *label = ReadLabel(proto_prefix, attr, label_offset);
394 0 : break;
395 : }
396 0 : case SelectiveMulticastRoute: {
397 0 : if (nlri_size < kMinSelectiveMulticastRouteSize)
398 0 : return -1;
399 0 : size_t rd_offset = 0;
400 0 : prefix->rd_ = RouteDistinguisher(&proto_prefix.prefix[rd_offset]);
401 0 : size_t tag_offset = rd_offset + kRdSize;
402 0 : prefix->tag_ = get_value(&proto_prefix.prefix[tag_offset], kTagSize);
403 0 : size_t src_len_offset = tag_offset + kTagSize;
404 0 : size_t src_len = proto_prefix.prefix[src_len_offset];
405 0 : if (src_len != 32 && src_len != 128 && src_len != 0)
406 0 : return -1;
407 0 : size_t src_size = src_len / 8;
408 0 : size_t src_offset = src_len_offset + 1;
409 0 : if (src_size > 0) {
410 0 : if (nlri_size < src_offset + src_size)
411 0 : return -1;
412 0 : prefix->ReadSource(proto_prefix, src_offset, src_size);
413 : }
414 0 : size_t grp_len_offset = src_offset + src_size;
415 0 : size_t grp_len = proto_prefix.prefix[grp_len_offset];
416 0 : if (grp_len != 32 && grp_len != 128)
417 0 : return -1;
418 0 : size_t grp_size = grp_len / 8;
419 0 : size_t grp_offset = grp_len_offset + 1;
420 0 : if (nlri_size < grp_offset + grp_size)
421 0 : return -1;
422 0 : prefix->ReadGroup(proto_prefix, grp_offset, grp_size);
423 0 : size_t ip_len_offset = grp_offset + grp_size;
424 0 : size_t ip_len = proto_prefix.prefix[ip_len_offset];
425 0 : if (ip_len != 32 && ip_len != 128)
426 0 : return -1;
427 0 : size_t ip_size = ip_len / 8;
428 0 : size_t ip_offset = ip_len_offset + 1;
429 0 : if (nlri_size < ip_offset + ip_size)
430 0 : return -1;
431 0 : prefix->ReadIpAddress(proto_prefix, ip_offset, ip_size, ip_size);
432 0 : size_t flag_offset = ip_offset + ip_size;
433 0 : if (nlri_size <= flag_offset + 4)
434 0 : prefix->flags_ = get_value(&proto_prefix.prefix[flag_offset], 4);
435 0 : break;
436 : }
437 0 : default: {
438 0 : return -1;
439 : break;
440 : }
441 : }
442 2048 : return 0;
443 : }
444 :
445 : //
446 : // Build the BgpProtoPrefix for this EvpnPrefix.
447 : //
448 : // The ESI for MacAdvertisementRoute is not part of the key and hence
449 : // must be obtained from the BgpAttr. The BgpAttr is NULL and label is
450 : // 0 when withdrawing the route.
451 : //
452 2340 : void EvpnPrefix::BuildProtoPrefix(BgpProtoPrefix *proto_prefix,
453 : const BgpAttr *attr, uint32_t label, uint32_t l3_label) const {
454 2340 : proto_prefix->type = type_;
455 2340 : proto_prefix->prefix.clear();
456 :
457 2340 : switch (type_) {
458 0 : case AutoDiscoveryRoute: {
459 0 : size_t nlri_size = kMinAutoDiscoveryRouteSize + kLabelSize;
460 0 : proto_prefix->prefixlen = nlri_size * 8;
461 0 : proto_prefix->prefix.resize(nlri_size, 0);
462 :
463 0 : size_t rd_offset = 0;
464 0 : copy(rd_.GetData(), rd_.GetData() + kRdSize,
465 0 : proto_prefix->prefix.begin() + rd_offset);
466 0 : size_t esi_offset = rd_offset + kRdSize;
467 0 : copy(esi_.GetData(), esi_.GetData() + kEsiSize,
468 0 : proto_prefix->prefix.begin() + esi_offset);
469 0 : size_t tag_offset = esi_offset + kEsiSize;
470 0 : put_value(&proto_prefix->prefix[tag_offset], kTagSize, tag_);
471 0 : size_t label_offset = tag_offset + kTagSize;
472 0 : WriteLabel(proto_prefix, attr, label_offset, label);
473 0 : break;
474 : }
475 2340 : case MacAdvertisementRoute: {
476 2340 : size_t ip_size = GetIpAddressSize();
477 2340 : size_t nlri_size = kMinMacAdvertisementRouteSize + ip_size + kLabelSize;
478 2340 : if (l3_label)
479 0 : nlri_size += kLabelSize;
480 2340 : proto_prefix->prefixlen = nlri_size * 8;
481 2340 : proto_prefix->prefix.resize(nlri_size, 0);
482 :
483 2340 : size_t rd_offset = 0;
484 2340 : copy(rd_.GetData(), rd_.GetData() + kRdSize,
485 2340 : proto_prefix->prefix.begin() + rd_offset);
486 2340 : size_t esi_offset = rd_offset + kRdSize;
487 2340 : if (attr) {
488 1472 : copy(attr->esi().GetData(), attr->esi().GetData() + kEsiSize,
489 2944 : proto_prefix->prefix.begin() + esi_offset);
490 : }
491 2340 : size_t tag_offset = esi_offset + kEsiSize;
492 2340 : put_value(&proto_prefix->prefix[tag_offset], kTagSize, tag_);
493 2340 : size_t mac_len_offset = tag_offset + kTagSize;
494 2340 : proto_prefix->prefix[mac_len_offset] = 48;
495 2340 : size_t mac_offset = mac_len_offset + 1;
496 2340 : copy(mac_addr_.GetData(), mac_addr_.GetData() + kMacSize,
497 2340 : proto_prefix->prefix.begin() + mac_offset);
498 2340 : size_t ip_len_offset = mac_offset + kMacSize;
499 2340 : proto_prefix->prefix[ip_len_offset] = ip_size * 8;
500 2340 : size_t ip_offset = ip_len_offset + 1;
501 2340 : WriteIpAddress(proto_prefix, ip_offset);
502 2340 : size_t label_offset = ip_offset + ip_size;
503 2340 : WriteLabel(proto_prefix, attr, label_offset, label);
504 2340 : if (l3_label) {
505 0 : size_t l3_label_offset = label_offset + kLabelSize;
506 0 : WriteLabel(proto_prefix, attr, l3_label_offset, l3_label);
507 : }
508 2340 : break;
509 : }
510 0 : case InclusiveMulticastRoute: {
511 0 : size_t ip_size = GetIpAddressSize();
512 0 : size_t nlri_size = kMinInclusiveMulticastRouteSize + ip_size;
513 0 : proto_prefix->prefixlen = nlri_size * 8;
514 0 : proto_prefix->prefix.resize(nlri_size, 0);
515 :
516 0 : size_t rd_offset = 0;
517 0 : copy(rd_.GetData(), rd_.GetData() + kRdSize,
518 0 : proto_prefix->prefix.begin() + rd_offset);
519 0 : size_t tag_offset = rd_offset + kRdSize;
520 0 : put_value(&proto_prefix->prefix[tag_offset], kTagSize, tag_);
521 0 : size_t ip_len_offset = tag_offset + kTagSize;
522 0 : proto_prefix->prefix[ip_len_offset] = ip_size * 8;
523 0 : size_t ip_offset = ip_len_offset + 1;
524 0 : WriteIpAddress(proto_prefix, ip_offset);
525 0 : break;
526 : }
527 0 : case SegmentRoute: {
528 0 : size_t ip_size = GetIpAddressSize();
529 0 : size_t nlri_size = kMinSegmentRouteSize + ip_size;
530 0 : proto_prefix->prefixlen = nlri_size * 8;
531 0 : proto_prefix->prefix.resize(nlri_size, 0);
532 :
533 0 : size_t rd_offset = 0;
534 0 : copy(rd_.GetData(), rd_.GetData() + kRdSize,
535 0 : proto_prefix->prefix.begin() + rd_offset);
536 0 : size_t esi_offset = rd_offset + kRdSize;
537 0 : copy(esi_.GetData(), esi_.GetData() + kEsiSize,
538 0 : proto_prefix->prefix.begin() + esi_offset);
539 0 : size_t ip_len_offset = esi_offset + kEsiSize;
540 0 : proto_prefix->prefix[ip_len_offset] = ip_size * 8;
541 0 : size_t ip_offset = ip_len_offset + 1;
542 0 : WriteIpAddress(proto_prefix, ip_offset);
543 0 : break;
544 : }
545 0 : case IpPrefixRoute: {
546 : size_t ip_size, nlri_size;
547 0 : if (family_ == Address::INET) {
548 0 : ip_size = kIp4AddrSize;
549 0 : nlri_size = kMinInetPrefixRouteSize + kLabelSize;
550 : } else {
551 0 : ip_size = kIp6AddrSize;
552 0 : nlri_size = kMinInet6PrefixRouteSize + kLabelSize;
553 : }
554 0 : proto_prefix->prefixlen = nlri_size * 8;
555 0 : proto_prefix->prefix.resize(nlri_size, 0);
556 :
557 0 : size_t rd_offset = 0;
558 0 : copy(rd_.GetData(), rd_.GetData() + kRdSize,
559 0 : proto_prefix->prefix.begin() + rd_offset);
560 0 : size_t esi_offset = rd_offset + kRdSize;
561 0 : if (attr) {
562 0 : copy(attr->esi().GetData(), attr->esi().GetData() + kEsiSize,
563 0 : proto_prefix->prefix.begin() + esi_offset);
564 : }
565 0 : size_t tag_offset = esi_offset + kEsiSize;
566 : // Tag is not applicable for type5 routes.
567 0 : put_value(&proto_prefix->prefix[tag_offset], kTagSize, 0);
568 0 : size_t ip_plen_offset = tag_offset + kTagSize;
569 0 : proto_prefix->prefix[ip_plen_offset] = ip_prefixlen_;
570 0 : size_t ip_offset = ip_plen_offset + 1;
571 0 : WriteIpAddress(proto_prefix, ip_offset);
572 0 : size_t gw_offset = ip_offset + ip_size;
573 0 : size_t label_offset = gw_offset + ip_size;
574 0 : WriteLabel(proto_prefix, attr, label_offset, label);
575 0 : break;
576 : }
577 0 : case SelectiveMulticastRoute: {
578 0 : size_t ip_size = GetIpAddressSize();
579 0 : size_t nlri_size = kMinSelectiveMulticastRouteSize + 2 * ip_size + 1;
580 0 : if (!source_.is_unspecified())
581 0 : nlri_size += ip_size;
582 0 : proto_prefix->prefixlen = nlri_size * 8;
583 0 : proto_prefix->prefix.resize(nlri_size, 0);
584 :
585 0 : size_t rd_offset = 0;
586 0 : copy(rd_.GetData(), rd_.GetData() + kRdSize,
587 0 : proto_prefix->prefix.begin() + rd_offset);
588 0 : size_t tag_offset = rd_offset + kRdSize;
589 0 : put_value(&proto_prefix->prefix[tag_offset], kTagSize, tag_);
590 0 : size_t src_len_offset = tag_offset + kTagSize;
591 0 : size_t grp_len_offset = src_len_offset + 1;
592 0 : if (source_.is_unspecified()) {
593 0 : proto_prefix->prefix[src_len_offset] = 0;
594 : } else {
595 0 : proto_prefix->prefix[src_len_offset] = ip_size * 8;
596 0 : size_t src_offset = src_len_offset + 1;
597 0 : WriteSource(proto_prefix, src_offset);
598 0 : grp_len_offset += ip_size;
599 : }
600 0 : proto_prefix->prefix[grp_len_offset] = ip_size * 8;
601 0 : size_t grp_offset = grp_len_offset + 1;
602 0 : WriteGroup(proto_prefix, grp_offset);
603 0 : size_t ip_len_offset = grp_offset + ip_size;
604 0 : proto_prefix->prefix[ip_len_offset] = ip_size * 8;
605 0 : size_t ip_offset = ip_len_offset + 1;
606 0 : WriteIpAddress(proto_prefix, ip_offset);
607 0 : size_t flag_offset = ip_offset + ip_size;
608 0 : put_value(&proto_prefix->prefix[flag_offset], 1, flags_);
609 0 : break;
610 : }
611 0 : default: {
612 0 : assert(false);
613 : break;
614 : }
615 : }
616 2340 : }
617 :
618 68008 : int EvpnPrefix::CompareTo(const EvpnPrefix &rhs) const {
619 68008 : KEY_COMPARE(type_, rhs.type_);
620 :
621 68008 : switch (type_) {
622 0 : case AutoDiscoveryRoute:
623 0 : KEY_COMPARE(rd_, rhs.rd_);
624 0 : KEY_COMPARE(esi_, rhs.esi_);
625 0 : KEY_COMPARE(tag_, rhs.tag_);
626 0 : break;
627 68008 : case MacAdvertisementRoute:
628 68008 : KEY_COMPARE(rd_, rhs.rd_);
629 32273 : KEY_COMPARE(tag_, rhs.tag_);
630 32273 : KEY_COMPARE(mac_addr_, rhs.mac_addr_);
631 9569 : KEY_COMPARE(ip_address_, rhs.ip_address_);
632 9569 : break;
633 0 : case InclusiveMulticastRoute:
634 0 : KEY_COMPARE(rd_, rhs.rd_);
635 0 : KEY_COMPARE(tag_, rhs.tag_);
636 0 : KEY_COMPARE(ip_address_, rhs.ip_address_);
637 0 : break;
638 0 : case SegmentRoute:
639 0 : KEY_COMPARE(rd_, rhs.rd_);
640 0 : KEY_COMPARE(esi_, rhs.esi_);
641 0 : KEY_COMPARE(ip_address_, rhs.ip_address_);
642 0 : break;
643 0 : case IpPrefixRoute:
644 0 : KEY_COMPARE(rd_, rhs.rd_);
645 0 : KEY_COMPARE(tag_, rhs.tag_);
646 0 : KEY_COMPARE(ip_address_, rhs.ip_address_);
647 0 : KEY_COMPARE(ip_prefixlen_, rhs.ip_prefixlen_);
648 0 : break;
649 0 : case SelectiveMulticastRoute:
650 0 : KEY_COMPARE(rd_, rhs.rd_);
651 0 : KEY_COMPARE(tag_, rhs.tag_);
652 0 : KEY_COMPARE(source_, rhs.source_);
653 0 : KEY_COMPARE(group_, rhs.group_);
654 0 : KEY_COMPARE(ip_address_, rhs.ip_address_);
655 : default:
656 0 : break;
657 : }
658 :
659 9569 : return 0;
660 : }
661 :
662 : // Check whether 'this' is more specific than rhs.
663 0 : bool EvpnPrefix::IsMoreSpecific(const EvpnPrefix &rhs) const {
664 0 : switch (type_) {
665 0 : case IpPrefixRoute:
666 0 : if (family_ == Address::INET) {
667 0 : return inet_prefix().IsMoreSpecific(rhs.inet_prefix());
668 : } else {
669 0 : return inet6_prefix().IsMoreSpecific(rhs.inet6_prefix());
670 : }
671 : break;
672 0 : default:
673 0 : break;
674 : }
675 0 : return false;
676 : }
677 :
678 0 : bool EvpnPrefix::GetSourceFromString(EvpnPrefix *prefix, const string &str,
679 : size_t pos1, size_t *pos2, boost::system::error_code *errorp) {
680 0 : *pos2 = str.find('-', pos1 + 1);
681 0 : if (*pos2 == string::npos) {
682 0 : if (errorp != NULL) {
683 0 : *errorp = make_error_code(boost::system::errc::invalid_argument);
684 : }
685 0 : return false;
686 : }
687 0 : string temp_str = str.substr(pos1 + 1, *pos2 - pos1 - 1);
688 0 : boost::system::error_code source_err;
689 0 : prefix->source_ = Ip4Address::from_string(temp_str, source_err);
690 0 : if (source_err.failed()) {
691 0 : if (errorp != NULL) {
692 0 : *errorp = source_err;
693 : }
694 0 : return false;
695 : }
696 0 : return true;
697 0 : }
698 :
699 0 : bool EvpnPrefix::GetGroupFromString(EvpnPrefix *prefix, const string &str,
700 : size_t pos1, size_t *pos2, boost::system::error_code *errorp) {
701 0 : *pos2 = str.find('-', pos1 + 1);
702 0 : if (*pos2 == string::npos) {
703 0 : if (errorp != NULL) {
704 0 : *errorp = make_error_code(boost::system::errc::invalid_argument);
705 : }
706 0 : return false;
707 : }
708 0 : string temp_str = str.substr(pos1 + 1, *pos2 - pos1 - 1);
709 0 : boost::system::error_code group_err;
710 0 : prefix->group_ = Ip4Address::from_string(temp_str, group_err);
711 0 : if (group_err.failed()) {
712 0 : if (errorp != NULL) {
713 0 : *errorp = group_err;
714 : }
715 0 : return false;
716 : }
717 0 : return true;
718 0 : }
719 :
720 0 : EvpnPrefix EvpnPrefix::FromString(const string &str,
721 : boost::system::error_code *errorp) {
722 0 : EvpnPrefix prefix;
723 :
724 : // Parse type.
725 0 : size_t pos1 = str.find('-');
726 0 : if (pos1 == string::npos) {
727 0 : if (errorp != NULL) {
728 0 : *errorp = make_error_code(boost::system::errc::invalid_argument);
729 : }
730 0 : return EvpnPrefix::kNullPrefix;
731 : }
732 :
733 0 : string type_str = str.substr(0, pos1);
734 0 : bool ret = stringToInteger(type_str, prefix.type_);
735 0 : if (!ret) {
736 0 : if (errorp != NULL) {
737 0 : *errorp = make_error_code(boost::system::errc::invalid_argument);
738 : }
739 0 : return EvpnPrefix::kNullPrefix;
740 : }
741 :
742 0 : if (prefix.type_ < EvpnPrefix::AutoDiscoveryRoute ||
743 0 : prefix.type_ > EvpnPrefix::SelectiveMulticastRoute) {
744 0 : if (errorp != NULL) {
745 0 : *errorp = make_error_code(boost::system::errc::invalid_argument);
746 : }
747 0 : return EvpnPrefix::kNullPrefix;
748 : }
749 :
750 : // Parse RD.
751 0 : size_t pos2 = str.find('-', pos1 + 1);
752 0 : if (pos2 == string::npos) {
753 0 : if (errorp != NULL) {
754 0 : *errorp = make_error_code(boost::system::errc::invalid_argument);
755 : }
756 0 : return EvpnPrefix::kNullPrefix;
757 : }
758 0 : string rd_str = str.substr(pos1 + 1, pos2 - pos1 - 1);
759 0 : boost::system::error_code rd_err;
760 0 : prefix.rd_ = RouteDistinguisher::FromString(rd_str, &rd_err);
761 0 : if (rd_err.failed()) {
762 0 : if (errorp != NULL) {
763 0 : *errorp = rd_err;
764 : }
765 0 : return EvpnPrefix::kNullPrefix;
766 : }
767 :
768 0 : switch (prefix.type_) {
769 0 : case AutoDiscoveryRoute: {
770 : // Parse ESI.
771 0 : size_t pos3 = str.find('-', pos2 + 1);
772 0 : if (pos3 == string::npos) {
773 0 : if (errorp != NULL) {
774 : *errorp =
775 0 : make_error_code(boost::system::errc::invalid_argument);
776 : }
777 0 : return EvpnPrefix::kNullPrefix;
778 : }
779 0 : string esi_str = str.substr(pos2 + 1, pos3 - pos2 - 1);
780 0 : boost::system::error_code esi_err;
781 0 : prefix.esi_ = EthernetSegmentId::FromString(esi_str, &esi_err);
782 0 : if (esi_err.failed()) {
783 0 : if (errorp != NULL) {
784 0 : *errorp = esi_err;
785 : }
786 0 : return EvpnPrefix::kNullPrefix;
787 : }
788 :
789 : // Parse tag.
790 0 : string tag_str = str.substr(pos3 + 1, string::npos);
791 0 : bool ret = stringToInteger(tag_str, prefix.tag_);
792 0 : if (!ret) {
793 0 : if (errorp != NULL) {
794 : *errorp =
795 0 : make_error_code(boost::system::errc::invalid_argument);
796 : }
797 0 : return EvpnPrefix::kNullPrefix;
798 : }
799 :
800 0 : break;
801 0 : }
802 :
803 0 : case MacAdvertisementRoute: {
804 : // Parse tag.
805 0 : size_t pos3 = str.find('-', pos2 + 1);
806 0 : if (pos3 == string::npos) {
807 0 : if (errorp != NULL) {
808 : *errorp =
809 0 : make_error_code(boost::system::errc::invalid_argument);
810 : }
811 0 : return EvpnPrefix::kNullPrefix;
812 : }
813 0 : string tag_str = str.substr(pos2 + 1, pos3 - pos2 - 1);
814 0 : bool ret = stringToInteger(tag_str, prefix.tag_);
815 0 : if (!ret) {
816 0 : if (errorp != NULL) {
817 : *errorp =
818 0 : make_error_code(boost::system::errc::invalid_argument);
819 : }
820 0 : return EvpnPrefix::kNullPrefix;
821 : }
822 :
823 : // Parse MAC.
824 0 : size_t pos4 = str.rfind(',');
825 0 : string mac_str = str.substr(pos3 + 1, pos4 - pos3 -1);
826 0 : boost::system::error_code mac_err;
827 0 : prefix.mac_addr_ = MacAddress::FromString(mac_str, &mac_err);
828 0 : if (mac_err.failed()) {
829 0 : if (errorp != NULL) {
830 0 : *errorp = mac_err;
831 : }
832 0 : return EvpnPrefix::kNullPrefix;
833 : }
834 :
835 : // Parse IP - treat all 0s as unspecified.
836 0 : string ip_str = str.substr(pos4 + 1, string::npos);
837 0 : boost::system::error_code ip_err;
838 0 : prefix.ip_address_ = IpAddress::from_string(ip_str, ip_err);
839 0 : if (ip_err.failed()) {
840 0 : if (errorp != NULL) {
841 0 : *errorp = ip_err;
842 : }
843 0 : return EvpnPrefix::kNullPrefix;
844 : }
845 0 : if (prefix.ip_address_.is_v4() && !prefix.ip_address_.is_unspecified())
846 0 : prefix.family_ = Address::INET;
847 0 : if (prefix.ip_address_.is_v6() && !prefix.ip_address_.is_unspecified())
848 0 : prefix.family_ = Address::INET6;
849 :
850 0 : break;
851 0 : }
852 :
853 0 : case InclusiveMulticastRoute: {
854 : // Parse tag.
855 0 : size_t pos3 = str.find('-', pos2 + 1);
856 0 : if (pos3 == string::npos) {
857 0 : if (errorp != NULL) {
858 : *errorp =
859 0 : make_error_code(boost::system::errc::invalid_argument);
860 : }
861 0 : return EvpnPrefix::kNullPrefix;
862 : }
863 0 : string tag_str = str.substr(pos2 + 1, pos3 - pos2 - 1);
864 0 : bool ret = stringToInteger(tag_str, prefix.tag_);
865 0 : if (!ret) {
866 0 : if (errorp != NULL) {
867 : *errorp =
868 0 : make_error_code(boost::system::errc::invalid_argument);
869 : }
870 0 : return EvpnPrefix::kNullPrefix;
871 : }
872 :
873 : // Parse IP.
874 0 : string ip_str = str.substr(pos3 + 1, string::npos);
875 0 : boost::system::error_code ip_err;
876 0 : prefix.ip_address_ = IpAddress::from_string(ip_str, ip_err);
877 0 : if (ip_err.failed()) {
878 0 : if (errorp != NULL) {
879 0 : *errorp = ip_err;
880 : }
881 0 : return EvpnPrefix::kNullPrefix;
882 : }
883 0 : prefix.family_ =
884 0 : prefix.ip_address_.is_v4() ? Address::INET : Address::INET6;
885 :
886 0 : break;
887 0 : }
888 :
889 0 : case SegmentRoute: {
890 : // Parse ESI.
891 0 : size_t pos3 = str.find('-', pos2 + 1);
892 0 : if (pos3 == string::npos) {
893 0 : if (errorp != NULL) {
894 : *errorp =
895 0 : make_error_code(boost::system::errc::invalid_argument);
896 : }
897 0 : return EvpnPrefix::kNullPrefix;
898 : }
899 0 : string esi_str = str.substr(pos2 + 1, pos3 - pos2 - 1);
900 0 : boost::system::error_code esi_err;
901 0 : prefix.esi_ = EthernetSegmentId::FromString(esi_str, &esi_err);
902 0 : if (esi_err.failed()) {
903 0 : if (errorp != NULL) {
904 0 : *errorp = esi_err;
905 : }
906 0 : return EvpnPrefix::kNullPrefix;
907 : }
908 :
909 : // Parse IP.
910 0 : string ip_str = str.substr(pos3 + 1, string::npos);
911 0 : boost::system::error_code ip_err;
912 0 : prefix.ip_address_ = IpAddress::from_string(ip_str, ip_err);
913 0 : if (ip_err.failed()) {
914 0 : if (errorp != NULL) {
915 0 : *errorp = ip_err;
916 : }
917 0 : return EvpnPrefix::kNullPrefix;
918 : }
919 0 : prefix.family_ =
920 0 : prefix.ip_address_.is_v4() ? Address::INET : Address::INET6;
921 :
922 0 : break;
923 0 : }
924 :
925 0 : case IpPrefixRoute: {
926 : // Parse tag.
927 0 : size_t pos3 = str.find('-', pos2 + 1);
928 0 : if (pos3 == string::npos) {
929 0 : if (errorp != NULL) {
930 : *errorp =
931 0 : make_error_code(boost::system::errc::invalid_argument);
932 : }
933 0 : return EvpnPrefix::kNullPrefix;
934 : }
935 0 : string tag_str = str.substr(pos2 + 1, pos3 - pos2 - 1);
936 0 : bool ret = stringToInteger(tag_str, prefix.tag_);
937 0 : if (!ret) {
938 0 : if (errorp != NULL) {
939 : *errorp =
940 0 : make_error_code(boost::system::errc::invalid_argument);
941 : }
942 0 : return EvpnPrefix::kNullPrefix;
943 : }
944 :
945 : // Parse IP prefix - first try v4, then v6.
946 0 : string ip_str = str.substr(pos3 + 1, string::npos);
947 0 : boost::system::error_code ip_err;
948 :
949 0 : Ip4Prefix inet_prefix = Ip4Prefix::FromString(ip_str, &ip_err);
950 0 : if (!ip_err) {
951 0 : prefix.family_ = Address::INET;
952 0 : prefix.ip_address_ = inet_prefix.addr();
953 0 : prefix.ip_prefixlen_ = inet_prefix.prefixlen();
954 0 : return prefix;
955 : }
956 :
957 0 : Inet6Prefix inet6_prefix = Inet6Prefix::FromString(ip_str, &ip_err);
958 0 : if (!ip_err) {
959 0 : prefix.family_ = Address::INET6;
960 0 : prefix.ip_address_ = inet6_prefix.addr();
961 0 : prefix.ip_prefixlen_ = inet6_prefix.prefixlen();
962 0 : return prefix;
963 : }
964 :
965 0 : if (errorp != NULL) {
966 0 : *errorp = make_error_code(boost::system::errc::invalid_argument);
967 : }
968 0 : return EvpnPrefix::kNullPrefix;
969 : break;
970 0 : }
971 :
972 0 : case SelectiveMulticastRoute: {
973 : // Parse tag.
974 0 : size_t pos3 = str.find('-', pos2 + 1);
975 0 : if (pos3 == string::npos) {
976 0 : if (errorp != NULL) {
977 : *errorp =
978 0 : make_error_code(boost::system::errc::invalid_argument);
979 : }
980 0 : return EvpnPrefix::kNullPrefix;
981 : }
982 0 : string tag_str = str.substr(pos2 + 1, pos3 - pos2 - 1);
983 0 : bool ret = stringToInteger(tag_str, prefix.tag_);
984 0 : if (!ret) {
985 0 : if (errorp != NULL) {
986 : *errorp =
987 0 : make_error_code(boost::system::errc::invalid_argument);
988 : }
989 0 : return EvpnPrefix::kNullPrefix;
990 : }
991 :
992 : // Look for source.
993 : size_t pos4;
994 0 : if (!GetSourceFromString(&prefix, str, pos3, &pos4, errorp))
995 0 : return EvpnPrefix::kNullPrefix;
996 :
997 : // Look for group.
998 : size_t pos5;
999 0 : if (!GetGroupFromString(&prefix, str, pos4, &pos5, errorp))
1000 0 : return EvpnPrefix::kNullPrefix;
1001 :
1002 : // Parse IP.
1003 0 : string ip_str = str.substr(pos5 + 1, string::npos);
1004 0 : boost::system::error_code ip_err;
1005 0 : prefix.ip_address_ = IpAddress::from_string(ip_str, ip_err);
1006 0 : if (ip_err.failed()) {
1007 0 : if (errorp != NULL) {
1008 0 : *errorp = ip_err;
1009 : }
1010 0 : return EvpnPrefix::kNullPrefix;
1011 : }
1012 0 : prefix.family_ =
1013 0 : prefix.ip_address_.is_v4() ? Address::INET : Address::INET6;
1014 :
1015 0 : break;
1016 0 : }
1017 :
1018 : }
1019 :
1020 0 : return prefix;
1021 0 : }
1022 :
1023 1792 : string EvpnPrefix::ToString() const {
1024 1792 : string str = integerToString(type_);
1025 1792 : str += "-" + rd_.ToString();
1026 1792 : switch (type_) {
1027 0 : case AutoDiscoveryRoute:
1028 0 : str += "-" + esi_.ToString();
1029 0 : str += "-" + integerToString(tag_);
1030 0 : break;
1031 1792 : case MacAdvertisementRoute:
1032 1792 : str += "-" + integerToString(tag_);
1033 1792 : str += "-" + mac_addr_.ToString();
1034 1792 : str += "," + ip_address_.to_string();
1035 1792 : break;
1036 0 : case InclusiveMulticastRoute:
1037 0 : str += "-" + integerToString(tag_);
1038 0 : str += "-" + ip_address_.to_string();
1039 0 : break;
1040 0 : case SegmentRoute:
1041 0 : str += "-" + esi_.ToString();
1042 0 : str += "-" + ip_address_.to_string();
1043 0 : break;
1044 0 : case IpPrefixRoute:
1045 0 : str += "-" + integerToString(tag_);
1046 0 : if (family_ == Address::INET) {
1047 0 : str += "-" + inet_prefix().ToString();
1048 : } else {
1049 0 : str += "-" + inet6_prefix().ToString();
1050 : }
1051 0 : break;
1052 0 : case SelectiveMulticastRoute:
1053 0 : str += "-" + integerToString(tag_);
1054 0 : if (!source_.is_unspecified())
1055 0 : str += "-" + source_.to_string();
1056 0 : str += "-" + group_.to_string();
1057 0 : str += "-" + ip_address_.to_string();
1058 0 : break;
1059 0 : default:
1060 0 : break;
1061 : }
1062 :
1063 1792 : return str;
1064 0 : }
1065 :
1066 512 : string EvpnPrefix::ToXmppIdString() const {
1067 512 : string str;
1068 512 : if (tag_ != 0)
1069 0 : str += integerToString(tag_) + "-";
1070 512 : str += mac_addr_.ToString();
1071 1024 : str += "," + ip_address_.to_string() + "/" +
1072 1536 : integerToString(ip_address_length());
1073 512 : if (!group_.is_unspecified()) {
1074 0 : str += "," + group_.to_string() + "," +
1075 0 : source_.to_string();
1076 : }
1077 512 : return str;
1078 0 : }
1079 :
1080 896 : uint8_t EvpnPrefix::ip_address_length() const {
1081 896 : if (type_ == IpPrefixRoute)
1082 0 : return ip_prefixlen_;
1083 896 : if (family_ == Address::INET)
1084 0 : return 32;
1085 896 : if (family_ == Address::INET6)
1086 0 : return 128;
1087 896 : return 32;
1088 : }
1089 :
1090 2340 : size_t EvpnPrefix::GetIpAddressSize() const {
1091 2340 : if (family_ == Address::INET)
1092 0 : return kIp4AddrSize;
1093 2340 : if (family_ == Address::INET6)
1094 0 : return kIp6AddrSize;
1095 2340 : return 0;
1096 : }
1097 :
1098 0 : void EvpnPrefix::ReadSource(const BgpProtoPrefix &proto_prefix,
1099 : size_t ip_offset, size_t ip_size) {
1100 0 : if (ip_size == 0) {
1101 0 : family_ = Address::UNSPEC;
1102 0 : } else if (ip_size == kIp4AddrSize) {
1103 0 : family_ = Address::INET;
1104 0 : Ip4Address::bytes_type bytes = { { 0 } };
1105 0 : copy(proto_prefix.prefix.begin() + ip_offset,
1106 0 : proto_prefix.prefix.begin() + ip_offset + ip_size, bytes.begin());
1107 0 : source_ = Ip4Address(bytes);
1108 0 : } else if (ip_size == kIp6AddrSize) {
1109 0 : family_ = Address::INET6;
1110 0 : Ip6Address::bytes_type bytes = { { 0 } };
1111 0 : copy(proto_prefix.prefix.begin() + ip_offset,
1112 0 : proto_prefix.prefix.begin() + ip_offset + ip_size, bytes.begin());
1113 0 : source_ = Ip6Address(bytes);
1114 : }
1115 0 : }
1116 :
1117 0 : void EvpnPrefix::ReadGroup(const BgpProtoPrefix &proto_prefix,
1118 : size_t ip_offset, size_t ip_size) {
1119 0 : if (ip_size == 0) {
1120 0 : family_ = Address::UNSPEC;
1121 0 : } else if (ip_size == kIp4AddrSize) {
1122 0 : family_ = Address::INET;
1123 0 : Ip4Address::bytes_type bytes = { { 0 } };
1124 0 : copy(proto_prefix.prefix.begin() + ip_offset,
1125 0 : proto_prefix.prefix.begin() + ip_offset + ip_size, bytes.begin());
1126 0 : group_ = Ip4Address(bytes);
1127 0 : } else if (ip_size == kIp6AddrSize) {
1128 0 : family_ = Address::INET6;
1129 0 : Ip6Address::bytes_type bytes = { { 0 } };
1130 0 : copy(proto_prefix.prefix.begin() + ip_offset,
1131 0 : proto_prefix.prefix.begin() + ip_offset + ip_size, bytes.begin());
1132 0 : group_ = Ip6Address(bytes);
1133 : }
1134 0 : }
1135 :
1136 2048 : void EvpnPrefix::ReadIpAddress(const BgpProtoPrefix &proto_prefix,
1137 : size_t ip_offset, size_t ip_size, size_t ip_psize) {
1138 2048 : assert(ip_psize <= ip_size);
1139 2048 : if (ip_size == 0) {
1140 2048 : family_ = Address::UNSPEC;
1141 0 : } else if (ip_size == kIp4AddrSize) {
1142 0 : family_ = Address::INET;
1143 0 : Ip4Address::bytes_type bytes = { { 0 } };
1144 0 : copy(proto_prefix.prefix.begin() + ip_offset,
1145 0 : proto_prefix.prefix.begin() + ip_offset + ip_psize, bytes.begin());
1146 0 : ip_address_ = Ip4Address(bytes);
1147 0 : } else if (ip_size == kIp6AddrSize) {
1148 0 : family_ = Address::INET6;
1149 0 : Ip6Address::bytes_type bytes = { { 0 } };
1150 0 : copy(proto_prefix.prefix.begin() + ip_offset,
1151 0 : proto_prefix.prefix.begin() + ip_offset + ip_psize, bytes.begin());
1152 0 : ip_address_ = Ip6Address(bytes);
1153 : }
1154 2048 : }
1155 :
1156 2340 : void EvpnPrefix::WriteIpAddress(BgpProtoPrefix *proto_prefix,
1157 : size_t ip_offset) const {
1158 2340 : if (family_ == Address::INET) {
1159 0 : const Ip4Address::bytes_type &bytes = ip_address_.to_v4().to_bytes();
1160 0 : copy(bytes.begin(), bytes.begin() + kIp4AddrSize,
1161 0 : proto_prefix->prefix.begin() + ip_offset);
1162 2340 : } else if (family_ == Address::INET6) {
1163 0 : const Ip6Address::bytes_type &bytes = ip_address_.to_v6().to_bytes();
1164 0 : copy(bytes.begin(), bytes.begin() + kIp6AddrSize,
1165 0 : proto_prefix->prefix.begin() + ip_offset);
1166 : }
1167 2340 : }
1168 :
1169 0 : void EvpnPrefix::WriteSource(BgpProtoPrefix *proto_prefix,
1170 : size_t ip_offset) const {
1171 0 : if (family_ == Address::INET) {
1172 0 : const Ip4Address::bytes_type &bytes = source_.to_v4().to_bytes();
1173 0 : copy(bytes.begin(), bytes.begin() + kIp4AddrSize,
1174 0 : proto_prefix->prefix.begin() + ip_offset);
1175 0 : } else if (family_ == Address::INET6) {
1176 0 : const Ip6Address::bytes_type &bytes = source_.to_v6().to_bytes();
1177 0 : copy(bytes.begin(), bytes.begin() + kIp6AddrSize,
1178 0 : proto_prefix->prefix.begin() + ip_offset);
1179 : }
1180 0 : }
1181 :
1182 0 : void EvpnPrefix::WriteGroup(BgpProtoPrefix *proto_prefix,
1183 : size_t ip_offset) const {
1184 0 : if (family_ == Address::INET) {
1185 0 : const Ip4Address::bytes_type &bytes = group_.to_v4().to_bytes();
1186 0 : copy(bytes.begin(), bytes.begin() + kIp4AddrSize,
1187 0 : proto_prefix->prefix.begin() + ip_offset);
1188 0 : } else if (family_ == Address::INET6) {
1189 0 : const Ip6Address::bytes_type &bytes = group_.to_v6().to_bytes();
1190 0 : copy(bytes.begin(), bytes.begin() + kIp6AddrSize,
1191 0 : proto_prefix->prefix.begin() + ip_offset);
1192 : }
1193 0 : }
1194 :
1195 8801 : EvpnRoute::EvpnRoute(const EvpnPrefix &prefix)
1196 8801 : : prefix_(prefix) {
1197 8801 : }
1198 :
1199 68008 : int EvpnRoute::CompareTo(const Route &rhs) const {
1200 68008 : const EvpnRoute &evpn_rhs = static_cast<const EvpnRoute &>(rhs);
1201 68008 : return prefix_.CompareTo(evpn_rhs.prefix_);
1202 : }
1203 :
1204 1792 : string EvpnRoute::ToString() const {
1205 1792 : return prefix_.ToString();
1206 : }
1207 :
1208 512 : string EvpnRoute::ToXmppIdString() const {
1209 512 : if (xmpp_id_str_.empty())
1210 256 : xmpp_id_str_ = prefix_.ToXmppIdString();
1211 512 : return xmpp_id_str_;
1212 : }
1213 :
1214 640 : bool EvpnRoute::IsValid() const {
1215 640 : if (!BgpRoute::IsValid())
1216 256 : return false;
1217 :
1218 384 : const BgpAttr *attr = BestPath()->GetAttr();
1219 384 : switch (prefix_.type()) {
1220 0 : case EvpnPrefix::AutoDiscoveryRoute: {
1221 0 : if (prefix_.tag() == EvpnPrefix::kMaxTag)
1222 0 : return true;
1223 0 : break;
1224 : }
1225 384 : case EvpnPrefix::MacAdvertisementRoute: {
1226 384 : return true;
1227 : }
1228 0 : case EvpnPrefix::InclusiveMulticastRoute: {
1229 0 : const PmsiTunnel *pmsi_tunnel = attr->pmsi_tunnel();
1230 0 : if (!pmsi_tunnel)
1231 0 : return false;
1232 0 : uint8_t tunnel_type = pmsi_tunnel->tunnel_type();
1233 0 : uint8_t tunnel_flags = pmsi_tunnel->tunnel_flags();
1234 0 : uint8_t ar_type =
1235 : tunnel_flags & PmsiTunnelSpec::AssistedReplicationType;
1236 0 : if (tunnel_type == PmsiTunnelSpec::IngressReplication) {
1237 0 : if (ar_type == PmsiTunnelSpec::RegularNVE)
1238 0 : return true;
1239 0 : if (ar_type == PmsiTunnelSpec::ARReplicator &&
1240 0 : (tunnel_flags & PmsiTunnelSpec::LeafInfoRequired)) {
1241 0 : return true;
1242 : }
1243 0 : return false;
1244 : }
1245 0 : if (tunnel_type == PmsiTunnelSpec::AssistedReplicationContrail &&
1246 : ar_type == PmsiTunnelSpec::ARLeaf) {
1247 0 : return true;
1248 : }
1249 0 : return false;
1250 : }
1251 0 : case EvpnPrefix::SegmentRoute: {
1252 0 : return false;
1253 : }
1254 0 : case EvpnPrefix::IpPrefixRoute: {
1255 0 : return false;
1256 : }
1257 0 : case EvpnPrefix::SelectiveMulticastRoute: {
1258 0 : return false;
1259 : }
1260 0 : default: {
1261 0 : break;
1262 : }
1263 : }
1264 :
1265 0 : return false;
1266 : }
1267 :
1268 0 : void EvpnRoute::SetKey(const DBRequestKey *reqkey) {
1269 0 : const EvpnTable::RequestKey *key =
1270 : static_cast<const EvpnTable::RequestKey *>(reqkey);
1271 0 : prefix_ = key->prefix;
1272 0 : }
1273 :
1274 2340 : void EvpnRoute::BuildProtoPrefix(BgpProtoPrefix *proto_prefix,
1275 : const BgpAttr *attr, uint32_t label, uint32_t l3_label) const {
1276 2340 : prefix_.BuildProtoPrefix(proto_prefix, attr, label, l3_label);
1277 2340 : }
1278 :
1279 1020 : void EvpnRoute::BuildBgpProtoNextHop(vector<uint8_t> &nh,
1280 : IpAddress nexthop) const {
1281 1020 : nh.resize(4);
1282 1020 : const Ip4Address::bytes_type &addr_bytes = nexthop.to_v4().to_bytes();
1283 1020 : copy(addr_bytes.begin(), addr_bytes.end(), nh.begin());
1284 1020 : }
1285 :
1286 4193 : DBEntryBase::KeyPtr EvpnRoute::GetDBRequestKey() const {
1287 4193 : EvpnTable::RequestKey *key = new EvpnTable::RequestKey(GetPrefix(), NULL);
1288 4193 : return KeyPtr(key);
1289 : }
|