]>
Commit | Line | Data |
---|---|---|
718e3744 | 1 | /* AS path management routines. |
896014f4 DL |
2 | * Copyright (C) 1996, 97, 98, 99 Kunihiro Ishiguro |
3 | * Copyright (C) 2005 Sun Microsystems, Inc. | |
4 | * | |
5 | * This file is part of GNU Zebra. | |
6 | * | |
7 | * GNU Zebra is free software; you can redistribute it and/or modify it | |
8 | * under the terms of the GNU General Public License as published by the | |
9 | * Free Software Foundation; either version 2, or (at your option) any | |
10 | * later version. | |
11 | * | |
12 | * GNU Zebra is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License along | |
18 | * with this program; see the file COPYING; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
20 | */ | |
718e3744 | 21 | |
22 | #include <zebra.h> | |
23 | ||
24 | #include "hash.h" | |
25 | #include "memory.h" | |
26 | #include "vector.h" | |
718e3744 | 27 | #include "log.h" |
fe69a505 | 28 | #include "stream.h" |
4dcadbef | 29 | #include "command.h" |
0b2aa3a0 | 30 | #include "jhash.h" |
3f9c7369 | 31 | #include "queue.h" |
039f3a34 | 32 | #include "filter.h" |
718e3744 | 33 | |
34 | #include "bgpd/bgpd.h" | |
35 | #include "bgpd/bgp_aspath.h" | |
0b2aa3a0 PJ |
36 | #include "bgpd/bgp_debug.h" |
37 | #include "bgpd/bgp_attr.h" | |
559aaa30 | 38 | #include "bgpd/bgp_errors.h" |
6b0655a2 | 39 | |
718e3744 | 40 | /* Attr. Flags and Attr. Type Code. */ |
ade6974d | 41 | #define AS_HEADER_SIZE 2 |
718e3744 | 42 | |
0b2aa3a0 | 43 | /* Now FOUR octets are used for AS value. */ |
0d6f7fd6 | 44 | #define AS_VALUE_SIZE sizeof(as_t) |
0b2aa3a0 | 45 | /* This is the old one */ |
0d6f7fd6 | 46 | #define AS16_VALUE_SIZE sizeof(as16_t) |
718e3744 | 47 | |
fe69a505 | 48 | /* Maximum protocol segment length value */ |
49 | #define AS_SEGMENT_MAX 255 | |
50 | ||
51 | /* The following length and size macros relate specifically to Quagga's | |
52 | * internal representation of AS-Segments, not per se to the on-wire | |
53 | * sizes and lengths. At present (200508) they sort of match, however | |
54 | * the ONLY functions which should now about the on-wire syntax are | |
55 | * aspath_put, assegment_put and assegment_parse. | |
0b2aa3a0 PJ |
56 | * |
57 | * aspath_put returns bytes written, the only definitive record of | |
58 | * size of wire-format attribute.. | |
fe69a505 | 59 | */ |
60 | ||
61 | /* Calculated size in bytes of ASN segment data to hold N ASN's */ | |
d62a17ae | 62 | #define ASSEGMENT_DATA_SIZE(N, S) \ |
63 | ((N) * ((S) ? AS_VALUE_SIZE : AS16_VALUE_SIZE)) | |
718e3744 | 64 | |
fe69a505 | 65 | /* Calculated size of segment struct to hold N ASN's */ |
0b2aa3a0 | 66 | #define ASSEGMENT_SIZE(N,S) (AS_HEADER_SIZE + ASSEGMENT_DATA_SIZE (N,S)) |
fe69a505 | 67 | |
68 | /* AS segment octet length. */ | |
0b2aa3a0 | 69 | #define ASSEGMENT_LEN(X,S) ASSEGMENT_SIZE((X)->length,S) |
fe69a505 | 70 | |
71 | /* AS_SEQUENCE segments can be packed together */ | |
72 | /* Can the types of X and Y be considered for packing? */ | |
d62a17ae | 73 | #define ASSEGMENT_TYPES_PACKABLE(X, Y) \ |
74 | (((X)->type == (Y)->type) && ((X)->type == AS_SEQUENCE)) | |
fe69a505 | 75 | /* Types and length of X,Y suitable for packing? */ |
d62a17ae | 76 | #define ASSEGMENTS_PACKABLE(X, Y) \ |
77 | (ASSEGMENT_TYPES_PACKABLE((X), (Y)) \ | |
78 | && (((X)->length + (Y)->length) <= AS_SEGMENT_MAX)) | |
fe69a505 | 79 | |
d62a17ae | 80 | /* As segment header - the on-wire representation |
fe69a505 | 81 | * NOT the internal representation! |
82 | */ | |
d62a17ae | 83 | struct assegment_header { |
d7c0a89a QY |
84 | uint8_t type; |
85 | uint8_t length; | |
718e3744 | 86 | }; |
87 | ||
88 | /* Hash for aspath. This is the top level structure of AS path. */ | |
da88ea82 | 89 | static struct hash *ashash; |
8fdc32ab | 90 | |
91 | /* Stream for SNMP. See aspath_snmp_pathseg */ | |
92 | static struct stream *snmp_stream; | |
6b0655a2 | 93 | |
f669f7d2 | 94 | /* Callers are required to initialize the memory */ |
d62a17ae | 95 | static as_t *assegment_data_new(int num) |
fe69a505 | 96 | { |
d62a17ae | 97 | return (XMALLOC(MTYPE_AS_SEG_DATA, ASSEGMENT_DATA_SIZE(num, 1))); |
fe69a505 | 98 | } |
99 | ||
d62a17ae | 100 | static void assegment_data_free(as_t *asdata) |
289d2501 | 101 | { |
d62a17ae | 102 | XFREE(MTYPE_AS_SEG_DATA, asdata); |
289d2501 LB |
103 | } |
104 | ||
2b64873d DL |
105 | const char *const aspath_segment_type_str[] = { |
106 | "as-invalid", "as-set", "as-sequence", "as-confed-sequence", | |
107 | "as-confed-set" | |
108 | }; | |
f1aa5d8a | 109 | |
fe69a505 | 110 | /* Get a new segment. Note that 0 is an allowed length, |
111 | * and will result in a segment with no allocated data segment. | |
112 | * the caller should immediately assign data to the segment, as the segment | |
113 | * otherwise is not generally valid | |
114 | */ | |
d7c0a89a | 115 | static struct assegment *assegment_new(uint8_t type, unsigned short length) |
d62a17ae | 116 | { |
117 | struct assegment *new; | |
118 | ||
119 | new = XCALLOC(MTYPE_AS_SEG, sizeof(struct assegment)); | |
120 | ||
121 | if (length) | |
122 | new->as = assegment_data_new(length); | |
123 | ||
124 | new->length = length; | |
125 | new->type = type; | |
126 | ||
127 | return new; | |
128 | } | |
129 | ||
130 | static void assegment_free(struct assegment *seg) | |
131 | { | |
132 | if (!seg) | |
133 | return; | |
134 | ||
8fa77bc6 | 135 | assegment_data_free(seg->as); |
d62a17ae | 136 | memset(seg, 0xfe, sizeof(struct assegment)); |
137 | XFREE(MTYPE_AS_SEG, seg); | |
138 | ||
139 | return; | |
fe69a505 | 140 | } |
141 | ||
142 | /* free entire chain of segments */ | |
d62a17ae | 143 | static void assegment_free_all(struct assegment *seg) |
fe69a505 | 144 | { |
d62a17ae | 145 | struct assegment *prev; |
146 | ||
147 | while (seg) { | |
148 | prev = seg; | |
149 | seg = seg->next; | |
150 | assegment_free(prev); | |
151 | } | |
fe69a505 | 152 | } |
153 | ||
154 | /* Duplicate just the given assegment and its data */ | |
d62a17ae | 155 | static struct assegment *assegment_dup(struct assegment *seg) |
fe69a505 | 156 | { |
d62a17ae | 157 | struct assegment *new; |
158 | ||
159 | new = assegment_new(seg->type, seg->length); | |
160 | memcpy(new->as, seg->as, ASSEGMENT_DATA_SIZE(new->length, 1)); | |
161 | ||
162 | return new; | |
fe69a505 | 163 | } |
164 | ||
165 | /* Duplicate entire chain of assegments, return the head */ | |
d62a17ae | 166 | static struct assegment *assegment_dup_all(struct assegment *seg) |
167 | { | |
168 | struct assegment *new = NULL; | |
169 | struct assegment *head = NULL; | |
170 | ||
171 | while (seg) { | |
172 | if (head) { | |
173 | new->next = assegment_dup(seg); | |
174 | new = new->next; | |
175 | } else | |
176 | head = new = assegment_dup(seg); | |
177 | ||
178 | seg = seg->next; | |
179 | } | |
180 | return head; | |
fe69a505 | 181 | } |
182 | ||
183 | /* prepend the as number to given segment, given num of times */ | |
d62a17ae | 184 | static struct assegment *assegment_prepend_asns(struct assegment *seg, |
185 | as_t asnum, int num) | |
fe69a505 | 186 | { |
d62a17ae | 187 | as_t *newas; |
188 | int i; | |
fe69a505 | 189 | |
d62a17ae | 190 | if (!num) |
191 | return seg; | |
f669f7d2 | 192 | |
d62a17ae | 193 | if (num >= AS_SEGMENT_MAX) |
194 | return seg; /* we don't do huge prepends */ | |
f669f7d2 | 195 | |
4953391b DA |
196 | newas = assegment_data_new(seg->length + num); |
197 | if (newas == NULL) | |
d62a17ae | 198 | return seg; |
199 | ||
200 | for (i = 0; i < num; i++) | |
201 | newas[i] = asnum; | |
202 | ||
203 | memcpy(newas + num, seg->as, ASSEGMENT_DATA_SIZE(seg->length, 1)); | |
204 | assegment_data_free(seg->as); | |
205 | seg->as = newas; | |
206 | seg->length += num; | |
207 | ||
208 | return seg; | |
fe69a505 | 209 | } |
210 | ||
211 | /* append given array of as numbers to the segment */ | |
d62a17ae | 212 | static struct assegment *assegment_append_asns(struct assegment *seg, |
213 | as_t *asnos, int num) | |
fe69a505 | 214 | { |
d62a17ae | 215 | as_t *newas; |
fe69a505 | 216 | |
e00d8008 NT |
217 | if (!seg) |
218 | return seg; | |
219 | ||
d62a17ae | 220 | newas = XREALLOC(MTYPE_AS_SEG_DATA, seg->as, |
221 | ASSEGMENT_DATA_SIZE(seg->length + num, 1)); | |
222 | ||
0ce1ca80 DS |
223 | seg->as = newas; |
224 | memcpy(seg->as + seg->length, asnos, | |
225 | ASSEGMENT_DATA_SIZE(num, 1)); | |
226 | seg->length += num; | |
227 | return seg; | |
fe69a505 | 228 | } |
229 | ||
d62a17ae | 230 | static int int_cmp(const void *p1, const void *p2) |
fe69a505 | 231 | { |
d62a17ae | 232 | const as_t *as1 = p1; |
233 | const as_t *as2 = p2; | |
234 | ||
235 | return (*as1 == *as2) ? 0 : ((*as1 > *as2) ? 1 : -1); | |
fe69a505 | 236 | } |
237 | ||
238 | /* normalise the segment. | |
239 | * In particular, merge runs of AS_SEQUENCEs into one segment | |
240 | * Internally, we do not care about the wire segment length limit, and | |
241 | * we want each distinct AS_PATHs to have the exact same internal | |
242 | * representation - eg, so that our hashing actually works.. | |
243 | */ | |
d62a17ae | 244 | static struct assegment *assegment_normalise(struct assegment *head) |
245 | { | |
246 | struct assegment *seg = head, *pin; | |
247 | struct assegment *tmp; | |
248 | ||
249 | if (!head) | |
250 | return head; | |
251 | ||
252 | while (seg) { | |
253 | pin = seg; | |
254 | ||
255 | /* Sort values SET segments, for determinism in paths to aid | |
256 | * creation of hash values / path comparisons | |
257 | * and because it helps other lesser implementations ;) | |
258 | */ | |
259 | if (seg->type == AS_SET || seg->type == AS_CONFED_SET) { | |
260 | int tail = 0; | |
261 | int i; | |
262 | ||
263 | qsort(seg->as, seg->length, sizeof(as_t), int_cmp); | |
264 | ||
265 | /* weed out dupes */ | |
266 | for (i = 1; i < seg->length; i++) { | |
267 | if (seg->as[tail] == seg->as[i]) | |
268 | continue; | |
269 | ||
270 | tail++; | |
271 | if (tail < i) | |
272 | seg->as[tail] = seg->as[i]; | |
273 | } | |
274 | /* seg->length can be 0.. */ | |
275 | if (seg->length) | |
276 | seg->length = tail + 1; | |
277 | } | |
278 | ||
279 | /* read ahead from the current, pinned segment while the | |
280 | * segments | |
281 | * are packable/mergeable. Append all following packable | |
282 | * segments | |
283 | * to the segment we have pinned and remove these appended | |
284 | * segments. | |
285 | */ | |
286 | while (pin->next && ASSEGMENT_TYPES_PACKABLE(pin, pin->next)) { | |
287 | tmp = pin->next; | |
288 | seg = pin->next; | |
289 | ||
290 | /* append the next sequence to the pinned sequence */ | |
291 | pin = assegment_append_asns(pin, seg->as, seg->length); | |
292 | ||
293 | /* bypass the next sequence */ | |
294 | pin->next = seg->next; | |
295 | ||
296 | /* get rid of the now referenceless segment */ | |
297 | assegment_free(tmp); | |
298 | } | |
299 | ||
300 | seg = pin->next; | |
0b2aa3a0 | 301 | } |
d62a17ae | 302 | return head; |
718e3744 | 303 | } |
304 | ||
d62a17ae | 305 | static struct aspath *aspath_new(void) |
718e3744 | 306 | { |
d62a17ae | 307 | return XCALLOC(MTYPE_AS_PATH, sizeof(struct aspath)); |
308 | } | |
f1aa5d8a | 309 | |
d62a17ae | 310 | /* Free AS path structure. */ |
311 | void aspath_free(struct aspath *aspath) | |
312 | { | |
313 | if (!aspath) | |
314 | return; | |
315 | if (aspath->segments) | |
316 | assegment_free_all(aspath->segments); | |
0a22ddfb | 317 | XFREE(MTYPE_AS_STR, aspath->str); |
d62a17ae | 318 | |
319 | if (aspath->json) { | |
320 | json_object_free(aspath->json); | |
321 | aspath->json = NULL; | |
322 | } | |
f1aa5d8a | 323 | |
d62a17ae | 324 | XFREE(MTYPE_AS_PATH, aspath); |
718e3744 | 325 | } |
326 | ||
327 | /* Unintern aspath from AS path bucket. */ | |
d62a17ae | 328 | void aspath_unintern(struct aspath **aspath) |
718e3744 | 329 | { |
d62a17ae | 330 | struct aspath *ret; |
b7b3e63c DA |
331 | struct aspath *asp; |
332 | ||
333 | if (!*aspath) | |
334 | return; | |
335 | ||
336 | asp = *aspath; | |
d62a17ae | 337 | |
338 | if (asp->refcnt) | |
339 | asp->refcnt--; | |
718e3744 | 340 | |
d62a17ae | 341 | if (asp->refcnt == 0) { |
342 | /* This aspath must exist in aspath hash table. */ | |
343 | ret = hash_release(ashash, asp); | |
344 | assert(ret != NULL); | |
345 | aspath_free(asp); | |
346 | *aspath = NULL; | |
347 | } | |
718e3744 | 348 | } |
349 | ||
350 | /* Return the start or end delimiters for a particular Segment type */ | |
351 | #define AS_SEG_START 0 | |
352 | #define AS_SEG_END 1 | |
d7c0a89a | 353 | static char aspath_delimiter_char(uint8_t type, uint8_t which) |
d62a17ae | 354 | { |
355 | int i; | |
356 | struct { | |
357 | int type; | |
358 | char start; | |
359 | char end; | |
360 | } aspath_delim_char[] = {{AS_SET, '{', '}'}, | |
361 | {AS_CONFED_SET, '[', ']'}, | |
362 | {AS_CONFED_SEQUENCE, '(', ')'}, | |
363 | {0}}; | |
364 | ||
365 | for (i = 0; aspath_delim_char[i].type != 0; i++) { | |
366 | if (aspath_delim_char[i].type == type) { | |
367 | if (which == AS_SEG_START) | |
368 | return aspath_delim_char[i].start; | |
369 | else if (which == AS_SEG_END) | |
370 | return aspath_delim_char[i].end; | |
371 | } | |
718e3744 | 372 | } |
d62a17ae | 373 | return ' '; |
718e3744 | 374 | } |
375 | ||
014b670e | 376 | /* countup asns from this segment and index onward */ |
d62a17ae | 377 | static int assegment_count_asns(struct assegment *seg, int from) |
378 | { | |
379 | int count = 0; | |
380 | while (seg) { | |
381 | if (!from) | |
382 | count += seg->length; | |
383 | else { | |
384 | count += (seg->length - from); | |
385 | from = 0; | |
386 | } | |
387 | seg = seg->next; | |
388 | } | |
389 | return count; | |
390 | } | |
391 | ||
392 | unsigned int aspath_count_confeds(struct aspath *aspath) | |
393 | { | |
394 | int count = 0; | |
395 | struct assegment *seg = aspath->segments; | |
396 | ||
397 | while (seg) { | |
398 | if (seg->type == AS_CONFED_SEQUENCE) | |
399 | count += seg->length; | |
400 | else if (seg->type == AS_CONFED_SET) | |
401 | count++; | |
402 | ||
403 | seg = seg->next; | |
404 | } | |
405 | return count; | |
406 | } | |
407 | ||
408 | unsigned int aspath_count_hops(const struct aspath *aspath) | |
409 | { | |
410 | int count = 0; | |
411 | struct assegment *seg = aspath->segments; | |
412 | ||
413 | while (seg) { | |
414 | if (seg->type == AS_SEQUENCE) | |
415 | count += seg->length; | |
416 | else if (seg->type == AS_SET) | |
417 | count++; | |
418 | ||
419 | seg = seg->next; | |
420 | } | |
421 | return count; | |
fe69a505 | 422 | } |
423 | ||
fb29348a DA |
424 | /* Check if aspath has AS_SET or AS_CONFED_SET */ |
425 | bool aspath_check_as_sets(struct aspath *aspath) | |
426 | { | |
427 | struct assegment *seg = aspath->segments; | |
428 | ||
429 | while (seg) { | |
430 | if (seg->type == AS_SET || seg->type == AS_CONFED_SET) | |
431 | return true; | |
432 | seg = seg->next; | |
433 | } | |
434 | return false; | |
435 | } | |
436 | ||
33d022bc DA |
437 | /* Check if aspath has BGP_AS_ZERO */ |
438 | bool aspath_check_as_zero(struct aspath *aspath) | |
439 | { | |
440 | struct assegment *seg = aspath->segments; | |
441 | unsigned int i; | |
442 | ||
443 | while (seg) { | |
444 | for (i = 0; i < seg->length; i++) | |
445 | if (seg->as[i] == BGP_AS_ZERO) | |
446 | return true; | |
447 | seg = seg->next; | |
448 | } | |
449 | ||
450 | return false; | |
451 | } | |
452 | ||
0b2aa3a0 PJ |
453 | /* Estimate size aspath /might/ take if encoded into an |
454 | * ASPATH attribute. | |
455 | * | |
456 | * This is a quick estimate, not definitive! aspath_put() | |
457 | * may return a different number!! | |
458 | */ | |
d62a17ae | 459 | unsigned int aspath_size(struct aspath *aspath) |
fe69a505 | 460 | { |
d62a17ae | 461 | int size = 0; |
462 | struct assegment *seg = aspath->segments; | |
463 | ||
464 | while (seg) { | |
465 | size += ASSEGMENT_SIZE(seg->length, 1); | |
466 | seg = seg->next; | |
467 | } | |
468 | return size; | |
fe69a505 | 469 | } |
470 | ||
2815e61f | 471 | /* Return highest public ASN in path */ |
d62a17ae | 472 | as_t aspath_highest(struct aspath *aspath) |
473 | { | |
474 | struct assegment *seg = aspath->segments; | |
475 | as_t highest = 0; | |
476 | unsigned int i; | |
477 | ||
478 | while (seg) { | |
479 | for (i = 0; i < seg->length; i++) | |
480 | if (seg->as[i] > highest | |
481 | && !BGP_AS_IS_PRIVATE(seg->as[i])) | |
482 | highest = seg->as[i]; | |
483 | seg = seg->next; | |
484 | } | |
485 | return highest; | |
2815e61f PJ |
486 | } |
487 | ||
bc3dd427 | 488 | /* Return the left-most ASN in path */ |
d62a17ae | 489 | as_t aspath_leftmost(struct aspath *aspath) |
bc3dd427 | 490 | { |
d62a17ae | 491 | struct assegment *seg = aspath->segments; |
492 | as_t leftmost = 0; | |
bc3dd427 | 493 | |
d62a17ae | 494 | if (seg && seg->length && seg->type == AS_SEQUENCE) |
495 | leftmost = seg->as[0]; | |
bc3dd427 | 496 | |
d62a17ae | 497 | return leftmost; |
bc3dd427 DW |
498 | } |
499 | ||
0b2aa3a0 | 500 | /* Return 1 if there are any 4-byte ASes in the path */ |
3967f0a8 | 501 | bool aspath_has_as4(struct aspath *aspath) |
d62a17ae | 502 | { |
503 | struct assegment *seg = aspath->segments; | |
504 | unsigned int i; | |
505 | ||
506 | while (seg) { | |
507 | for (i = 0; i < seg->length; i++) | |
508 | if (seg->as[i] > BGP_AS_MAX) | |
3967f0a8 | 509 | return true; |
d62a17ae | 510 | seg = seg->next; |
511 | } | |
3967f0a8 | 512 | return false; |
0b2aa3a0 PJ |
513 | } |
514 | ||
718e3744 | 515 | /* Convert aspath structure to string expression. */ |
68e1a55b | 516 | static void aspath_make_str_count(struct aspath *as, bool make_json) |
d62a17ae | 517 | { |
518 | struct assegment *seg; | |
519 | int str_size; | |
520 | int len = 0; | |
521 | char *str_buf; | |
522 | json_object *jaspath_segments = NULL; | |
523 | json_object *jseg = NULL; | |
524 | json_object *jseg_list = NULL; | |
525 | ||
68e1a55b DS |
526 | if (make_json) { |
527 | as->json = json_object_new_object(); | |
528 | jaspath_segments = json_object_new_array(); | |
529 | } | |
d62a17ae | 530 | |
531 | /* Empty aspath. */ | |
532 | if (!as->segments) { | |
68e1a55b DS |
533 | if (make_json) { |
534 | json_object_string_add(as->json, "string", "Local"); | |
996c9314 LB |
535 | json_object_object_add(as->json, "segments", |
536 | jaspath_segments); | |
68e1a55b DS |
537 | json_object_int_add(as->json, "length", 0); |
538 | } | |
d62a17ae | 539 | as->str = XMALLOC(MTYPE_AS_STR, 1); |
540 | as->str[0] = '\0'; | |
541 | as->str_len = 0; | |
542 | return; | |
543 | } | |
544 | ||
545 | seg = as->segments; | |
546 | ||
8afb9d8a | 547 | /* ASN takes 5 to 10 chars plus separator, see below. |
d62a17ae | 548 | * If there is one differing segment type, we need an additional |
549 | * 2 chars for segment delimiters, and the final '\0'. | |
550 | * Hopefully this is large enough to avoid hitting the realloc | |
551 | * code below for most common sequences. | |
552 | * | |
553 | * This was changed to 10 after the well-known BGP assertion, which | |
554 | * had hit some parts of the Internet in May of 2009. | |
555 | */ | |
014b670e | 556 | #define ASN_STR_LEN (10 + 1) |
d62a17ae | 557 | str_size = MAX(assegment_count_asns(seg, 0) * ASN_STR_LEN + 2 + 1, |
558 | ASPATH_STR_DEFAULT_LEN); | |
559 | str_buf = XMALLOC(MTYPE_AS_STR, str_size); | |
560 | ||
561 | while (seg) { | |
562 | int i; | |
8afb9d8a | 563 | char separator; |
d62a17ae | 564 | |
8afb9d8a | 565 | /* Check AS type validity. Set separator for segment */ |
d62a17ae | 566 | switch (seg->type) { |
567 | case AS_SET: | |
568 | case AS_CONFED_SET: | |
8afb9d8a | 569 | separator = ','; |
d62a17ae | 570 | break; |
571 | case AS_SEQUENCE: | |
572 | case AS_CONFED_SEQUENCE: | |
8afb9d8a | 573 | separator = ' '; |
d62a17ae | 574 | break; |
575 | default: | |
576 | XFREE(MTYPE_AS_STR, str_buf); | |
577 | as->str = NULL; | |
578 | as->str_len = 0; | |
579 | json_object_free(as->json); | |
580 | as->json = NULL; | |
68e1a55b | 581 | |
d62a17ae | 582 | return; |
583 | } | |
584 | ||
585 | /* We might need to increase str_buf, particularly if path has | |
586 | * differing segments types, our initial guesstimate above will | |
8afb9d8a | 587 | * have been wrong. Need 10 chars for ASN, a separator each and |
d62a17ae | 588 | * potentially two segment delimiters, plus a space between each |
589 | * segment and trailing zero. | |
590 | * | |
591 | * This definitely didn't work with the value of 5 bytes and | |
592 | * 32-bit ASNs. | |
593 | */ | |
014b670e | 594 | #define SEGMENT_STR_LEN(X) (((X)->length * ASN_STR_LEN) + 2 + 1 + 1) |
d62a17ae | 595 | if ((len + SEGMENT_STR_LEN(seg)) > str_size) { |
596 | str_size = len + SEGMENT_STR_LEN(seg); | |
597 | str_buf = XREALLOC(MTYPE_AS_STR, str_buf, str_size); | |
598 | } | |
014b670e DO |
599 | #undef ASN_STR_LEN |
600 | #undef SEGMENT_STR_LEN | |
d62a17ae | 601 | |
602 | if (seg->type != AS_SEQUENCE) | |
603 | len += snprintf( | |
604 | str_buf + len, str_size - len, "%c", | |
605 | aspath_delimiter_char(seg->type, AS_SEG_START)); | |
606 | ||
68e1a55b DS |
607 | if (make_json) |
608 | jseg_list = json_object_new_array(); | |
d62a17ae | 609 | |
8afb9d8a | 610 | /* write out the ASNs, with their separators, bar the last one*/ |
d62a17ae | 611 | for (i = 0; i < seg->length; i++) { |
68e1a55b | 612 | if (make_json) |
996c9314 LB |
613 | json_object_array_add( |
614 | jseg_list, | |
ca9e5ab3 | 615 | json_object_new_int64(seg->as[i])); |
d62a17ae | 616 | |
617 | len += snprintf(str_buf + len, str_size - len, "%u", | |
618 | seg->as[i]); | |
619 | ||
620 | if (i < (seg->length - 1)) | |
621 | len += snprintf(str_buf + len, str_size - len, | |
8afb9d8a | 622 | "%c", separator); |
d62a17ae | 623 | } |
624 | ||
68e1a55b DS |
625 | if (make_json) { |
626 | jseg = json_object_new_object(); | |
996c9314 LB |
627 | json_object_string_add( |
628 | jseg, "type", | |
629 | aspath_segment_type_str[seg->type]); | |
68e1a55b DS |
630 | json_object_object_add(jseg, "list", jseg_list); |
631 | json_object_array_add(jaspath_segments, jseg); | |
632 | } | |
d62a17ae | 633 | |
634 | if (seg->type != AS_SEQUENCE) | |
635 | len += snprintf( | |
636 | str_buf + len, str_size - len, "%c", | |
637 | aspath_delimiter_char(seg->type, AS_SEG_END)); | |
638 | if (seg->next) | |
639 | len += snprintf(str_buf + len, str_size - len, " "); | |
640 | ||
641 | seg = seg->next; | |
642 | } | |
643 | ||
644 | assert(len < str_size); | |
645 | ||
646 | str_buf[len] = '\0'; | |
647 | as->str = str_buf; | |
648 | as->str_len = len; | |
649 | ||
68e1a55b DS |
650 | if (make_json) { |
651 | json_object_string_add(as->json, "string", str_buf); | |
652 | json_object_object_add(as->json, "segments", jaspath_segments); | |
653 | json_object_int_add(as->json, "length", aspath_count_hops(as)); | |
654 | } | |
655 | ||
d62a17ae | 656 | return; |
657 | } | |
658 | ||
68e1a55b | 659 | void aspath_str_update(struct aspath *as, bool make_json) |
d62a17ae | 660 | { |
0a22ddfb | 661 | XFREE(MTYPE_AS_STR, as->str); |
d62a17ae | 662 | |
663 | if (as->json) { | |
664 | json_object_free(as->json); | |
665 | as->json = NULL; | |
666 | } | |
667 | ||
68e1a55b | 668 | aspath_make_str_count(as, make_json); |
fe69a505 | 669 | } |
670 | ||
718e3744 | 671 | /* Intern allocated AS path. */ |
d62a17ae | 672 | struct aspath *aspath_intern(struct aspath *aspath) |
718e3744 | 673 | { |
d62a17ae | 674 | struct aspath *find; |
f669f7d2 | 675 | |
d62a17ae | 676 | /* Assert this AS path structure is not interned and has the string |
677 | representation built. */ | |
678 | assert(aspath->refcnt == 0); | |
679 | assert(aspath->str); | |
718e3744 | 680 | |
d62a17ae | 681 | /* Check AS path hash. */ |
682 | find = hash_get(ashash, aspath, hash_alloc_intern); | |
683 | if (find != aspath) | |
684 | aspath_free(aspath); | |
718e3744 | 685 | |
d62a17ae | 686 | find->refcnt++; |
718e3744 | 687 | |
d62a17ae | 688 | return find; |
718e3744 | 689 | } |
690 | ||
691 | /* Duplicate aspath structure. Created same aspath structure but | |
692 | reference count and AS path string is cleared. */ | |
d62a17ae | 693 | struct aspath *aspath_dup(struct aspath *aspath) |
718e3744 | 694 | { |
d62a17ae | 695 | unsigned short buflen = aspath->str_len + 1; |
696 | struct aspath *new; | |
718e3744 | 697 | |
d62a17ae | 698 | new = XCALLOC(MTYPE_AS_PATH, sizeof(struct aspath)); |
699 | new->json = NULL; | |
718e3744 | 700 | |
d62a17ae | 701 | if (aspath->segments) |
702 | new->segments = assegment_dup_all(aspath->segments); | |
718e3744 | 703 | |
d62a17ae | 704 | if (!aspath->str) |
705 | return new; | |
f669f7d2 | 706 | |
d62a17ae | 707 | new->str = XMALLOC(MTYPE_AS_STR, buflen); |
708 | new->str_len = aspath->str_len; | |
f669f7d2 | 709 | |
d62a17ae | 710 | /* copy the string data */ |
711 | if (aspath->str_len > 0) | |
712 | memcpy(new->str, aspath->str, buflen); | |
713 | else | |
714 | new->str[0] = '\0'; | |
718e3744 | 715 | |
d62a17ae | 716 | return new; |
718e3744 | 717 | } |
718 | ||
d62a17ae | 719 | static void *aspath_hash_alloc(void *arg) |
718e3744 | 720 | { |
d62a17ae | 721 | const struct aspath *aspath = arg; |
722 | struct aspath *new; | |
718e3744 | 723 | |
d62a17ae | 724 | /* Malformed AS path value. */ |
725 | assert(aspath->str); | |
718e3744 | 726 | |
d62a17ae | 727 | /* New aspath structure is needed. */ |
728 | new = XMALLOC(MTYPE_AS_PATH, sizeof(struct aspath)); | |
f669f7d2 | 729 | |
d62a17ae | 730 | /* Reuse segments and string representation */ |
731 | new->refcnt = 0; | |
732 | new->segments = aspath->segments; | |
733 | new->str = aspath->str; | |
734 | new->str_len = aspath->str_len; | |
735 | new->json = aspath->json; | |
f669f7d2 | 736 | |
d62a17ae | 737 | return new; |
718e3744 | 738 | } |
739 | ||
ab005298 | 740 | /* parse as-segment byte stream in struct assegment */ |
d62a17ae | 741 | static int assegments_parse(struct stream *s, size_t length, |
742 | struct assegment **result, int use32bit) | |
743 | { | |
744 | struct assegment_header segh; | |
745 | struct assegment *seg, *prev = NULL, *head = NULL; | |
746 | size_t bytes = 0; | |
747 | ||
748 | /* empty aspath (ie iBGP or somesuch) */ | |
749 | if (length == 0) | |
750 | return 0; | |
751 | ||
752 | if (BGP_DEBUG(as4, AS4_SEGMENT)) | |
753 | zlog_debug( | |
754 | "[AS4SEG] Parse aspath segment: got total byte length %lu", | |
755 | (unsigned long)length); | |
756 | /* basic checks */ | |
757 | if ((STREAM_READABLE(s) < length) | |
758 | || (STREAM_READABLE(s) < AS_HEADER_SIZE) | |
759 | || (length % AS16_VALUE_SIZE)) | |
760 | return -1; | |
761 | ||
762 | while (bytes < length) { | |
763 | int i; | |
764 | size_t seg_size; | |
765 | ||
766 | if ((length - bytes) <= AS_HEADER_SIZE) { | |
767 | if (head) | |
768 | assegment_free_all(head); | |
769 | return -1; | |
770 | } | |
771 | ||
772 | /* softly softly, get the header first on its own */ | |
773 | segh.type = stream_getc(s); | |
774 | segh.length = stream_getc(s); | |
775 | ||
776 | seg_size = ASSEGMENT_SIZE(segh.length, use32bit); | |
777 | ||
778 | if (BGP_DEBUG(as4, AS4_SEGMENT)) | |
779 | zlog_debug( | |
780 | "[AS4SEG] Parse aspath segment: got type %d, length %d", | |
781 | segh.type, segh.length); | |
782 | ||
783 | /* check it.. */ | |
784 | if (((bytes + seg_size) > length) | |
785 | /* 1771bis 4.3b: seg length contains one or more */ | |
786 | || (segh.length == 0) | |
787 | /* Paranoia in case someone changes type of segment length. | |
788 | * Shift both values by 0x10 to make the comparison operate | |
789 | * on more, than 8 bits (otherwise it's a warning, bug | |
790 | * #564). | |
791 | */ | |
0d6f7fd6 | 792 | || ((sizeof(segh.length) > 1) |
d62a17ae | 793 | && (0x10 + segh.length > 0x10 + AS_SEGMENT_MAX))) { |
794 | if (head) | |
795 | assegment_free_all(head); | |
796 | return -1; | |
797 | } | |
798 | ||
799 | switch (segh.type) { | |
800 | case AS_SEQUENCE: | |
801 | case AS_SET: | |
802 | case AS_CONFED_SEQUENCE: | |
803 | case AS_CONFED_SET: | |
804 | break; | |
805 | default: | |
806 | if (head) | |
807 | assegment_free_all(head); | |
808 | return -1; | |
809 | } | |
810 | ||
811 | /* now its safe to trust lengths */ | |
812 | seg = assegment_new(segh.type, segh.length); | |
813 | ||
814 | if (head) | |
815 | prev->next = seg; | |
816 | else /* it's the first segment */ | |
1bb379bf | 817 | head = seg; |
d62a17ae | 818 | |
819 | for (i = 0; i < segh.length; i++) | |
820 | seg->as[i] = | |
821 | (use32bit) ? stream_getl(s) : stream_getw(s); | |
822 | ||
823 | bytes += seg_size; | |
824 | ||
825 | if (BGP_DEBUG(as4, AS4_SEGMENT)) | |
826 | zlog_debug( | |
827 | "[AS4SEG] Parse aspath segment: Bytes now: %lu", | |
828 | (unsigned long)bytes); | |
829 | ||
830 | prev = seg; | |
831 | } | |
832 | ||
833 | *result = assegment_normalise(head); | |
834 | return 0; | |
fe69a505 | 835 | } |
836 | ||
ab005298 PJ |
837 | /* AS path parse function. pnt is a pointer to byte stream and length |
838 | is length of byte stream. If there is same AS path in the the AS | |
d62a17ae | 839 | path hash then return it else make new AS path structure. |
840 | ||
b881c707 | 841 | On error NULL is returned. |
cddb8112 | 842 | */ |
d62a17ae | 843 | struct aspath *aspath_parse(struct stream *s, size_t length, int use32bit) |
844 | { | |
845 | struct aspath as; | |
846 | struct aspath *find; | |
847 | ||
848 | /* If length is odd it's malformed AS path. */ | |
849 | /* Nit-picking: if (use32bit == 0) it is malformed if odd, | |
850 | * otherwise its malformed when length is larger than 2 and (length-2) | |
851 | * is not dividable by 4. | |
852 | * But... this time we're lazy | |
853 | */ | |
854 | if (length % AS16_VALUE_SIZE) | |
855 | return NULL; | |
856 | ||
6006b807 | 857 | memset(&as, 0, sizeof(as)); |
d62a17ae | 858 | if (assegments_parse(s, length, &as.segments, use32bit) < 0) |
859 | return NULL; | |
860 | ||
861 | /* If already same aspath exist then return it. */ | |
862 | find = hash_get(ashash, &as, aspath_hash_alloc); | |
863 | ||
d62a17ae | 864 | /* if the aspath was already hashed free temporary memory. */ |
865 | if (find->refcnt) { | |
866 | assegment_free_all(as.segments); | |
867 | /* aspath_key_make() always updates the string */ | |
868 | XFREE(MTYPE_AS_STR, as.str); | |
869 | if (as.json) { | |
870 | json_object_free(as.json); | |
871 | as.json = NULL; | |
872 | } | |
4390a8ee | 873 | } |
f669f7d2 | 874 | |
d62a17ae | 875 | find->refcnt++; |
718e3744 | 876 | |
d62a17ae | 877 | return find; |
718e3744 | 878 | } |
879 | ||
d62a17ae | 880 | static void assegment_data_put(struct stream *s, as_t *as, int num, |
881 | int use32bit) | |
fe69a505 | 882 | { |
d62a17ae | 883 | int i; |
884 | assert(num <= AS_SEGMENT_MAX); | |
885 | ||
886 | for (i = 0; i < num; i++) | |
887 | if (use32bit) | |
888 | stream_putl(s, as[i]); | |
889 | else { | |
890 | if (as[i] <= BGP_AS_MAX) | |
891 | stream_putw(s, as[i]); | |
892 | else | |
893 | stream_putw(s, BGP_AS_TRANS); | |
894 | } | |
fe69a505 | 895 | } |
718e3744 | 896 | |
d7c0a89a | 897 | static size_t assegment_header_put(struct stream *s, uint8_t type, int length) |
718e3744 | 898 | { |
d62a17ae | 899 | size_t lenp; |
900 | assert(length <= AS_SEGMENT_MAX); | |
901 | stream_putc(s, type); | |
902 | lenp = stream_get_endp(s); | |
903 | stream_putc(s, length); | |
904 | return lenp; | |
fe69a505 | 905 | } |
718e3744 | 906 | |
fe69a505 | 907 | /* write aspath data to stream */ |
d62a17ae | 908 | size_t aspath_put(struct stream *s, struct aspath *as, int use32bit) |
909 | { | |
910 | struct assegment *seg = as->segments; | |
911 | size_t bytes = 0; | |
912 | ||
913 | if (!seg || seg->length == 0) | |
914 | return 0; | |
915 | ||
9c73cd41 DA |
916 | /* |
917 | * Hey, what do we do when we have > STREAM_WRITABLE(s) here? | |
918 | * At the moment, we would write out a partial aspath, and our | |
919 | * peer | |
920 | * will complain and drop the session :-/ | |
921 | * | |
922 | * The general assumption here is that many things tested will | |
923 | * never happen. And, in real live, up to now, they have not. | |
924 | */ | |
925 | while (seg && (ASSEGMENT_LEN(seg, use32bit) <= STREAM_WRITEABLE(s))) { | |
926 | struct assegment *next = seg->next; | |
927 | int written = 0; | |
928 | int asns_packed = 0; | |
929 | size_t lenp; | |
930 | ||
931 | /* Overlength segments have to be split up */ | |
932 | while ((seg->length - written) > AS_SEGMENT_MAX) { | |
933 | assegment_header_put(s, seg->type, AS_SEGMENT_MAX); | |
d62a17ae | 934 | assegment_data_put(s, (seg->as + written), |
9c73cd41 DA |
935 | AS_SEGMENT_MAX, use32bit); |
936 | written += AS_SEGMENT_MAX; | |
937 | bytes += ASSEGMENT_SIZE(AS_SEGMENT_MAX, use32bit); | |
938 | } | |
d62a17ae | 939 | |
9c73cd41 DA |
940 | /* write the final segment, probably is also the first |
941 | */ | |
942 | lenp = assegment_header_put(s, seg->type, | |
943 | seg->length - written); | |
944 | assegment_data_put(s, (seg->as + written), | |
945 | seg->length - written, use32bit); | |
946 | ||
947 | /* Sequence-type segments can be 'packed' together | |
948 | * Case of a segment which was overlength and split up | |
949 | * will be missed here, but that doesn't matter. | |
950 | */ | |
951 | while (next && ASSEGMENTS_PACKABLE(seg, next)) { | |
952 | /* NB: We should never normally get here given | |
953 | * we | |
954 | * normalise aspath data when parse them. | |
955 | * However, better | |
956 | * safe than sorry. We potentially could call | |
957 | * assegment_normalise here instead, but it's | |
958 | * cheaper and | |
959 | * easier to do it on the fly here rather than | |
960 | * go through | |
961 | * the segment list twice every time we write | |
962 | * out | |
963 | * aspath's. | |
d62a17ae | 964 | */ |
d62a17ae | 965 | |
9c73cd41 DA |
966 | /* Next segment's data can fit in this one */ |
967 | assegment_data_put(s, next->as, next->length, use32bit); | |
968 | ||
969 | /* update the length of the segment header */ | |
970 | stream_putc_at(s, lenp, | |
971 | seg->length - written + next->length); | |
972 | asns_packed += next->length; | |
973 | ||
974 | next = next->next; | |
d62a17ae | 975 | } |
9c73cd41 DA |
976 | |
977 | bytes += ASSEGMENT_SIZE(seg->length - written + asns_packed, | |
978 | use32bit); | |
979 | seg = next; | |
d62a17ae | 980 | } |
981 | return bytes; | |
fe69a505 | 982 | } |
983 | ||
984 | /* This is for SNMP BGP4PATHATTRASPATHSEGMENT | |
985 | * We have no way to manage the storage, so we use a static stream | |
986 | * wrapper around aspath_put. | |
987 | */ | |
d7c0a89a | 988 | uint8_t *aspath_snmp_pathseg(struct aspath *as, size_t *varlen) |
fe69a505 | 989 | { |
990 | #define SNMP_PATHSEG_MAX 1024 | |
8fdc32ab | 991 | |
d62a17ae | 992 | if (!snmp_stream) |
993 | snmp_stream = stream_new(SNMP_PATHSEG_MAX); | |
994 | else | |
995 | stream_reset(snmp_stream); | |
996 | ||
997 | if (!as) { | |
998 | *varlen = 0; | |
999 | return NULL; | |
1000 | } | |
1001 | aspath_put(snmp_stream, as, 0); /* use 16 bit for now here */ | |
1002 | ||
1003 | *varlen = stream_get_endp(snmp_stream); | |
1004 | return stream_pnt(snmp_stream); | |
1005 | } | |
1006 | ||
d62a17ae | 1007 | static struct assegment *aspath_aggregate_as_set_add(struct aspath *aspath, |
1008 | struct assegment *asset, | |
1009 | as_t as) | |
1010 | { | |
1011 | int i; | |
1012 | ||
1013 | /* If this is first AS set member, create new as-set segment. */ | |
1014 | if (asset == NULL) { | |
1015 | asset = assegment_new(AS_SET, 1); | |
1016 | if (!aspath->segments) | |
1017 | aspath->segments = asset; | |
1018 | else { | |
1019 | struct assegment *seg = aspath->segments; | |
1020 | while (seg->next) | |
1021 | seg = seg->next; | |
1022 | seg->next = asset; | |
1023 | } | |
1024 | asset->type = AS_SET; | |
1025 | asset->length = 1; | |
1026 | asset->as[0] = as; | |
1027 | } else { | |
1028 | /* Check this AS value already exists or not. */ | |
1029 | for (i = 0; i < asset->length; i++) | |
1030 | if (asset->as[i] == as) | |
1031 | return asset; | |
1032 | ||
1033 | asset->length++; | |
1034 | asset->as = XREALLOC(MTYPE_AS_SEG_DATA, asset->as, | |
1035 | asset->length * AS_VALUE_SIZE); | |
1036 | asset->as[asset->length - 1] = as; | |
1037 | } | |
1038 | ||
1039 | ||
1040 | return asset; | |
718e3744 | 1041 | } |
1042 | ||
1043 | /* Modify as1 using as2 for aggregation. */ | |
d62a17ae | 1044 | struct aspath *aspath_aggregate(struct aspath *as1, struct aspath *as2) |
1045 | { | |
1046 | int i; | |
1047 | int minlen = 0; | |
1048 | int match = 0; | |
1049 | int from; | |
1050 | struct assegment *seg1 = as1->segments; | |
1051 | struct assegment *seg2 = as2->segments; | |
1052 | struct aspath *aspath = NULL; | |
1053 | struct assegment *asset = NULL; | |
1054 | struct assegment *prevseg = NULL; | |
1055 | ||
1056 | /* First of all check common leading sequence. */ | |
1057 | while (seg1 && seg2) { | |
1058 | /* Check segment type. */ | |
1059 | if (seg1->type != seg2->type) | |
1060 | break; | |
1061 | ||
1062 | /* Minimum segment length. */ | |
7a8ce9d5 | 1063 | minlen = MIN(seg1->length, seg2->length); |
d62a17ae | 1064 | |
1065 | for (match = 0; match < minlen; match++) | |
1066 | if (seg1->as[match] != seg2->as[match]) | |
1067 | break; | |
1068 | ||
1069 | if (match) { | |
1070 | struct assegment *seg = assegment_new(seg1->type, 0); | |
1071 | ||
1072 | seg = assegment_append_asns(seg, seg1->as, match); | |
1073 | ||
1074 | if (!aspath) { | |
1075 | aspath = aspath_new(); | |
1076 | aspath->segments = seg; | |
1077 | } else | |
1078 | prevseg->next = seg; | |
1079 | ||
1080 | prevseg = seg; | |
1081 | } | |
1082 | ||
1083 | if (match != minlen || match != seg1->length | |
1084 | || seg1->length != seg2->length) | |
1085 | break; | |
1086 | /* We are moving on to the next segment to reset match */ | |
1087 | else | |
1088 | match = 0; | |
1089 | ||
1090 | seg1 = seg1->next; | |
1091 | seg2 = seg2->next; | |
1092 | } | |
1093 | ||
1094 | if (!aspath) | |
1095 | aspath = aspath_new(); | |
1096 | ||
1097 | /* Make as-set using rest of all information. */ | |
1098 | from = match; | |
1099 | while (seg1) { | |
1100 | for (i = from; i < seg1->length; i++) | |
1101 | asset = aspath_aggregate_as_set_add(aspath, asset, | |
1102 | seg1->as[i]); | |
1103 | ||
1104 | from = 0; | |
1105 | seg1 = seg1->next; | |
718e3744 | 1106 | } |
1107 | ||
d62a17ae | 1108 | from = match; |
1109 | while (seg2) { | |
1110 | for (i = from; i < seg2->length; i++) | |
1111 | asset = aspath_aggregate_as_set_add(aspath, asset, | |
1112 | seg2->as[i]); | |
1113 | ||
1114 | from = 0; | |
1115 | seg2 = seg2->next; | |
1116 | } | |
1117 | ||
1118 | assegment_normalise(aspath->segments); | |
68e1a55b | 1119 | aspath_str_update(aspath, false); |
d62a17ae | 1120 | return aspath; |
718e3744 | 1121 | } |
1122 | ||
1123 | /* When a BGP router receives an UPDATE with an MP_REACH_NLRI | |
1124 | attribute, check the leftmost AS number in the AS_PATH attribute is | |
d62a17ae | 1125 | or not the peer's AS number. */ |
3967f0a8 | 1126 | bool aspath_firstas_check(struct aspath *aspath, as_t asno) |
718e3744 | 1127 | { |
d62a17ae | 1128 | if ((aspath == NULL) || (aspath->segments == NULL)) |
3967f0a8 | 1129 | return false; |
d62a17ae | 1130 | |
1131 | if (aspath->segments && (aspath->segments->type == AS_SEQUENCE) | |
1132 | && (aspath->segments->as[0] == asno)) | |
3967f0a8 | 1133 | return true; |
718e3744 | 1134 | |
3967f0a8 | 1135 | return false; |
718e3744 | 1136 | } |
1137 | ||
d62a17ae | 1138 | unsigned int aspath_get_first_as(struct aspath *aspath) |
06370dac | 1139 | { |
d62a17ae | 1140 | if (aspath == NULL || aspath->segments == NULL) |
1141 | return 0; | |
06370dac | 1142 | |
d62a17ae | 1143 | return aspath->segments->as[0]; |
06370dac DW |
1144 | } |
1145 | ||
d62a17ae | 1146 | unsigned int aspath_get_last_as(struct aspath *aspath) |
aac9ef6c | 1147 | { |
d62a17ae | 1148 | int i; |
1149 | unsigned int last_as = 0; | |
1150 | const struct assegment *seg; | |
aac9ef6c | 1151 | |
d62a17ae | 1152 | if (aspath == NULL || aspath->segments == NULL) |
1153 | return last_as; | |
aac9ef6c | 1154 | |
d62a17ae | 1155 | seg = aspath->segments; |
aac9ef6c | 1156 | |
d62a17ae | 1157 | while (seg) { |
1158 | if (seg->type == AS_SEQUENCE || seg->type == AS_CONFED_SEQUENCE) | |
1159 | for (i = 0; i < seg->length; i++) | |
1160 | last_as = seg->as[i]; | |
1161 | seg = seg->next; | |
1162 | } | |
aac9ef6c | 1163 | |
d62a17ae | 1164 | return last_as; |
aac9ef6c DW |
1165 | } |
1166 | ||
1f742f21 | 1167 | /* AS path loop check. If aspath contains asno then return >= 1. */ |
d62a17ae | 1168 | int aspath_loop_check(struct aspath *aspath, as_t asno) |
1169 | { | |
1170 | struct assegment *seg; | |
1171 | int count = 0; | |
1172 | ||
1173 | if ((aspath == NULL) || (aspath->segments == NULL)) | |
1174 | return 0; | |
1175 | ||
1176 | seg = aspath->segments; | |
1177 | ||
1178 | while (seg) { | |
1179 | int i; | |
1180 | ||
1181 | for (i = 0; i < seg->length; i++) | |
1182 | if (seg->as[i] == asno) | |
1183 | count++; | |
1184 | ||
1185 | seg = seg->next; | |
1186 | } | |
1187 | return count; | |
718e3744 | 1188 | } |
1189 | ||
1190 | /* When all of AS path is private AS return 1. */ | |
3967f0a8 | 1191 | bool aspath_private_as_check(struct aspath *aspath) |
718e3744 | 1192 | { |
d62a17ae | 1193 | struct assegment *seg; |
5000f21c | 1194 | |
d62a17ae | 1195 | if (!(aspath && aspath->segments)) |
3967f0a8 | 1196 | return false; |
5000f21c | 1197 | |
d62a17ae | 1198 | seg = aspath->segments; |
718e3744 | 1199 | |
d62a17ae | 1200 | while (seg) { |
1201 | int i; | |
5000f21c | 1202 | |
d62a17ae | 1203 | for (i = 0; i < seg->length; i++) { |
1204 | if (!BGP_AS_IS_PRIVATE(seg->as[i])) | |
3967f0a8 | 1205 | return false; |
d62a17ae | 1206 | } |
1207 | seg = seg->next; | |
718e3744 | 1208 | } |
3967f0a8 | 1209 | return true; |
718e3744 | 1210 | } |
1211 | ||
c7122e14 | 1212 | /* Replace all instances of the target ASN with our own ASN */ |
d62a17ae | 1213 | struct aspath *aspath_replace_specific_asn(struct aspath *aspath, |
1214 | as_t target_asn, as_t our_asn) | |
c7122e14 | 1215 | { |
d62a17ae | 1216 | struct aspath *new; |
1217 | struct assegment *seg; | |
c7122e14 | 1218 | |
d62a17ae | 1219 | new = aspath_dup(aspath); |
1220 | seg = new->segments; | |
c7122e14 | 1221 | |
d62a17ae | 1222 | while (seg) { |
1223 | int i; | |
c7122e14 | 1224 | |
d62a17ae | 1225 | for (i = 0; i < seg->length; i++) { |
1226 | if (seg->as[i] == target_asn) | |
1227 | seg->as[i] = our_asn; | |
1228 | } | |
1229 | seg = seg->next; | |
c7122e14 | 1230 | } |
c7122e14 | 1231 | |
77e3d821 DA |
1232 | aspath_str_update(new, false); |
1233 | return new; | |
1234 | } | |
1235 | ||
1236 | /* Replace all ASNs with our own ASN */ | |
1237 | struct aspath *aspath_replace_all_asn(struct aspath *aspath, as_t our_asn) | |
1238 | { | |
1239 | struct aspath *new; | |
1240 | struct assegment *seg; | |
1241 | ||
1242 | new = aspath_dup(aspath); | |
1243 | seg = new->segments; | |
1244 | ||
1245 | while (seg) { | |
1246 | int i; | |
1247 | ||
1248 | for (i = 0; i < seg->length; i++) | |
1249 | seg->as[i] = our_asn; | |
1250 | ||
1251 | seg = seg->next; | |
1252 | } | |
1253 | ||
68e1a55b | 1254 | aspath_str_update(new, false); |
d62a17ae | 1255 | return new; |
c7122e14 DS |
1256 | } |
1257 | ||
5000f21c | 1258 | /* Replace all private ASNs with our own ASN */ |
bf26b80e DS |
1259 | struct aspath *aspath_replace_private_asns(struct aspath *aspath, as_t asn, |
1260 | as_t peer_asn) | |
5000f21c | 1261 | { |
d62a17ae | 1262 | struct aspath *new; |
1263 | struct assegment *seg; | |
5000f21c | 1264 | |
d62a17ae | 1265 | new = aspath_dup(aspath); |
1266 | seg = new->segments; | |
5000f21c | 1267 | |
d62a17ae | 1268 | while (seg) { |
1269 | int i; | |
5000f21c | 1270 | |
d62a17ae | 1271 | for (i = 0; i < seg->length; i++) { |
bf26b80e DS |
1272 | /* Don't replace if public ASN or peer's ASN */ |
1273 | if (BGP_AS_IS_PRIVATE(seg->as[i]) | |
1274 | && (seg->as[i] != peer_asn)) | |
d62a17ae | 1275 | seg->as[i] = asn; |
1276 | } | |
1277 | seg = seg->next; | |
5000f21c | 1278 | } |
5000f21c | 1279 | |
68e1a55b | 1280 | aspath_str_update(new, false); |
d62a17ae | 1281 | return new; |
5000f21c DS |
1282 | } |
1283 | ||
1284 | /* Remove all private ASNs */ | |
bf26b80e | 1285 | struct aspath *aspath_remove_private_asns(struct aspath *aspath, as_t peer_asn) |
d62a17ae | 1286 | { |
1287 | struct aspath *new; | |
1288 | struct assegment *seg; | |
1289 | struct assegment *new_seg; | |
1290 | struct assegment *last_new_seg; | |
1291 | int i; | |
1292 | int j; | |
1293 | int public = 0; | |
179d5a0e | 1294 | int peer = 0; |
d62a17ae | 1295 | |
1296 | new = XCALLOC(MTYPE_AS_PATH, sizeof(struct aspath)); | |
1297 | ||
1298 | new->json = NULL; | |
1299 | new_seg = NULL; | |
1300 | last_new_seg = NULL; | |
1301 | seg = aspath->segments; | |
1302 | while (seg) { | |
179d5a0e TA |
1303 | public = 0; |
1304 | peer = 0; | |
d62a17ae | 1305 | for (i = 0; i < seg->length; i++) { |
1306 | // ASN is public | |
179d5a0e TA |
1307 | if (!BGP_AS_IS_PRIVATE(seg->as[i])) |
1308 | public++; | |
1309 | /* ASN matches peer's. | |
1310 | * Don't double-count if peer_asn is public. | |
1311 | */ | |
1312 | else if (seg->as[i] == peer_asn) | |
1313 | peer++; | |
d62a17ae | 1314 | } |
1315 | ||
d62a17ae | 1316 | // The entire segment is public so copy it |
bf26b80e | 1317 | if (public == seg->length) |
d62a17ae | 1318 | new_seg = assegment_dup(seg); |
d62a17ae | 1319 | |
1320 | // The segment is a mix of public and private ASNs. Copy as many | |
1321 | // spots as | |
1322 | // there are public ASNs then come back and fill in only the | |
1323 | // public ASNs. | |
1324 | else { | |
179d5a0e TA |
1325 | /* length needs to account for all retained ASNs |
1326 | * (public or peer_asn), not just public | |
1327 | */ | |
1328 | new_seg = assegment_new(seg->type, (public + peer)); | |
d62a17ae | 1329 | j = 0; |
1330 | for (i = 0; i < seg->length; i++) { | |
bf26b80e DS |
1331 | // keep ASN if public or matches peer's ASN |
1332 | if (!BGP_AS_IS_PRIVATE(seg->as[i]) | |
1333 | || (seg->as[i] == peer_asn)) { | |
d62a17ae | 1334 | new_seg->as[j] = seg->as[i]; |
1335 | j++; | |
1336 | } | |
1337 | } | |
1338 | } | |
1339 | ||
1340 | // This is the first segment so set the aspath segments pointer | |
1341 | // to this one | |
1342 | if (!last_new_seg) | |
1343 | new->segments = new_seg; | |
1344 | else | |
1345 | last_new_seg->next = new_seg; | |
1346 | ||
1347 | last_new_seg = new_seg; | |
1348 | seg = seg->next; | |
1349 | } | |
1350 | ||
68e1a55b | 1351 | aspath_str_update(new, false); |
d62a17ae | 1352 | return new; |
1353 | } | |
1354 | ||
1355 | /* AS path confed check. If aspath contains confed set or sequence then return | |
1356 | * 1. */ | |
3967f0a8 | 1357 | bool aspath_confed_check(struct aspath *aspath) |
d62a17ae | 1358 | { |
1359 | struct assegment *seg; | |
1360 | ||
1361 | if (!(aspath && aspath->segments)) | |
3967f0a8 | 1362 | return false; |
d62a17ae | 1363 | |
1364 | seg = aspath->segments; | |
1365 | ||
1366 | while (seg) { | |
1367 | if (seg->type == AS_CONFED_SET | |
1368 | || seg->type == AS_CONFED_SEQUENCE) | |
3967f0a8 | 1369 | return true; |
d62a17ae | 1370 | seg = seg->next; |
1371 | } | |
3967f0a8 | 1372 | return false; |
ca87e1d3 VT |
1373 | } |
1374 | ||
1375 | /* Leftmost AS path segment confed check. If leftmost AS segment is of type | |
1376 | AS_CONFED_SEQUENCE or AS_CONFED_SET then return 1. */ | |
3967f0a8 | 1377 | bool aspath_left_confed_check(struct aspath *aspath) |
ca87e1d3 VT |
1378 | { |
1379 | ||
d62a17ae | 1380 | if (!(aspath && aspath->segments)) |
3967f0a8 | 1381 | return false; |
ca87e1d3 | 1382 | |
d62a17ae | 1383 | if ((aspath->segments->type == AS_CONFED_SEQUENCE) |
1384 | || (aspath->segments->type == AS_CONFED_SET)) | |
3967f0a8 | 1385 | return true; |
ca87e1d3 | 1386 | |
3967f0a8 | 1387 | return false; |
ca87e1d3 VT |
1388 | } |
1389 | ||
718e3744 | 1390 | /* Merge as1 to as2. as2 should be uninterned aspath. */ |
d62a17ae | 1391 | static struct aspath *aspath_merge(struct aspath *as1, struct aspath *as2) |
718e3744 | 1392 | { |
d62a17ae | 1393 | struct assegment *last, *new; |
718e3744 | 1394 | |
d62a17ae | 1395 | if (!as1 || !as2) |
1396 | return NULL; | |
718e3744 | 1397 | |
d62a17ae | 1398 | last = new = assegment_dup_all(as1->segments); |
1399 | ||
1400 | /* find the last valid segment */ | |
1401 | while (last && last->next) | |
1402 | last = last->next; | |
1403 | ||
e00d8008 NT |
1404 | if (last) |
1405 | last->next = as2->segments; | |
d62a17ae | 1406 | as2->segments = new; |
68e1a55b | 1407 | aspath_str_update(as2, false); |
d62a17ae | 1408 | return as2; |
718e3744 | 1409 | } |
1410 | ||
1411 | /* Prepend as1 to as2. as2 should be uninterned aspath. */ | |
d62a17ae | 1412 | struct aspath *aspath_prepend(struct aspath *as1, struct aspath *as2) |
1413 | { | |
3c510881 QY |
1414 | struct assegment *as1segtail; |
1415 | struct assegment *as2segtail; | |
1416 | struct assegment *as2seghead; | |
d62a17ae | 1417 | |
1418 | if (!as1 || !as2) | |
1419 | return NULL; | |
1420 | ||
d62a17ae | 1421 | /* If as2 is empty, only need to dupe as1's chain onto as2 */ |
3c510881 | 1422 | if (as2->segments == NULL) { |
d62a17ae | 1423 | as2->segments = assegment_dup_all(as1->segments); |
68e1a55b | 1424 | aspath_str_update(as2, false); |
d62a17ae | 1425 | return as2; |
1426 | } | |
1427 | ||
1428 | /* If as1 is empty AS, no prepending to do. */ | |
3c510881 | 1429 | if (as1->segments == NULL) |
d62a17ae | 1430 | return as2; |
1431 | ||
1432 | /* find the tail as1's segment chain. */ | |
3c510881 QY |
1433 | as1segtail = as1->segments; |
1434 | while (as1segtail && as1segtail->next) | |
1435 | as1segtail = as1segtail->next; | |
d62a17ae | 1436 | |
1437 | /* Delete any AS_CONFED_SEQUENCE segment from as2. */ | |
3c510881 QY |
1438 | if (as1segtail->type == AS_SEQUENCE |
1439 | && as2->segments->type == AS_CONFED_SEQUENCE) | |
d62a17ae | 1440 | as2 = aspath_delete_confed_seq(as2); |
1441 | ||
3c510881 QY |
1442 | if (!as2->segments) { |
1443 | as2->segments = assegment_dup_all(as1->segments); | |
1444 | aspath_str_update(as2, false); | |
1445 | return as2; | |
1446 | } | |
1447 | ||
d62a17ae | 1448 | /* Compare last segment type of as1 and first segment type of as2. */ |
3c510881 | 1449 | if (as1segtail->type != as2->segments->type) |
d62a17ae | 1450 | return aspath_merge(as1, as2); |
1451 | ||
3c510881 | 1452 | if (as1segtail->type == AS_SEQUENCE) { |
d62a17ae | 1453 | /* We have two chains of segments, as1->segments and seg2, |
1454 | * and we have to attach them together, merging the attaching | |
1455 | * segments together into one. | |
1456 | * | |
1457 | * 1. dupe as1->segments onto head of as2 | |
1458 | * 2. merge seg2's asns onto last segment of this new chain | |
1459 | * 3. attach chain after seg2 | |
1460 | */ | |
1461 | ||
3c510881 QY |
1462 | /* save as2 head */ |
1463 | as2seghead = as2->segments; | |
1464 | ||
d62a17ae | 1465 | /* dupe as1 onto as2's head */ |
3c510881 | 1466 | as2segtail = as2->segments = assegment_dup_all(as1->segments); |
d62a17ae | 1467 | |
3c510881 QY |
1468 | /* refind the tail of as2 */ |
1469 | while (as2segtail && as2segtail->next) | |
1470 | as2segtail = as2segtail->next; | |
d62a17ae | 1471 | |
1472 | /* merge the old head, seg2, into tail, seg1 */ | |
3c510881 QY |
1473 | assegment_append_asns(as2segtail, as2seghead->as, |
1474 | as2seghead->length); | |
d62a17ae | 1475 | |
3c510881 QY |
1476 | /* |
1477 | * bypass the merged seg2, and attach any chain after it | |
1478 | * to chain descending from as2's head | |
d62a17ae | 1479 | */ |
e00d8008 NT |
1480 | if (as2segtail) |
1481 | as2segtail->next = as2seghead->next; | |
d62a17ae | 1482 | |
3c510881 QY |
1483 | /* as2->segments is now referenceless and useless */ |
1484 | assegment_free(as2seghead); | |
d62a17ae | 1485 | |
1486 | /* we've now prepended as1's segment chain to as2, merging | |
1487 | * the inbetween AS_SEQUENCE of seg2 in the process | |
1488 | */ | |
68e1a55b | 1489 | aspath_str_update(as2, false); |
d62a17ae | 1490 | return as2; |
1491 | } else { | |
1492 | /* AS_SET merge code is needed at here. */ | |
1493 | return aspath_merge(as1, as2); | |
1494 | } | |
1495 | /* XXX: Ermmm, what if as1 has multiple segments?? */ | |
1496 | ||
1497 | /* Not reached */ | |
718e3744 | 1498 | } |
1499 | ||
f79f7a7b | 1500 | /* Iterate over AS_PATH segments and wipe all occurrences of the |
841f7a57 DO |
1501 | * listed AS numbers. Hence some segments may lose some or even |
1502 | * all data on the way, the operation is implemented as a smarter | |
1503 | * version of aspath_dup(), which allocates memory to hold the new | |
1504 | * data, not the original. The new AS path is returned. | |
1505 | */ | |
d62a17ae | 1506 | struct aspath *aspath_filter_exclude(struct aspath *source, |
1507 | struct aspath *exclude_list) | |
1508 | { | |
1509 | struct assegment *srcseg, *exclseg, *lastseg; | |
1510 | struct aspath *newpath; | |
1511 | ||
1512 | newpath = aspath_new(); | |
1513 | lastseg = NULL; | |
1514 | ||
1515 | for (srcseg = source->segments; srcseg; srcseg = srcseg->next) { | |
1516 | unsigned i, y, newlen = 0, done = 0, skip_as; | |
1517 | struct assegment *newseg; | |
1518 | ||
1519 | /* Find out, how much ASns are we going to pick from this | |
1520 | * segment. | |
1521 | * We can't perform filtering right inline, because the size of | |
1522 | * the new segment isn't known at the moment yet. | |
1523 | */ | |
1524 | for (i = 0; i < srcseg->length; i++) { | |
1525 | skip_as = 0; | |
1526 | for (exclseg = exclude_list->segments; | |
1527 | exclseg && !skip_as; exclseg = exclseg->next) | |
1528 | for (y = 0; y < exclseg->length; y++) | |
1529 | if (srcseg->as[i] == exclseg->as[y]) { | |
1530 | skip_as = 1; | |
1531 | // There's no sense in testing | |
1532 | // the rest of exclusion list, | |
1533 | // bail out. | |
1534 | break; | |
1535 | } | |
1536 | if (!skip_as) | |
1537 | newlen++; | |
1538 | } | |
1539 | /* newlen is now the number of ASns to copy */ | |
1540 | if (!newlen) | |
1541 | continue; | |
1542 | ||
1543 | /* Actual copying. Allocate memory and iterate once more, | |
1544 | * performing filtering. */ | |
1545 | newseg = assegment_new(srcseg->type, newlen); | |
1546 | for (i = 0; i < srcseg->length; i++) { | |
1547 | skip_as = 0; | |
1548 | for (exclseg = exclude_list->segments; | |
1549 | exclseg && !skip_as; exclseg = exclseg->next) | |
1550 | for (y = 0; y < exclseg->length; y++) | |
1551 | if (srcseg->as[i] == exclseg->as[y]) { | |
1552 | skip_as = 1; | |
1553 | break; | |
1554 | } | |
1555 | if (skip_as) | |
1556 | continue; | |
1557 | newseg->as[done++] = srcseg->as[i]; | |
1558 | } | |
1559 | /* At his point newlen must be equal to done, and both must be | |
1560 | * positive. Append | |
1561 | * the filtered segment to the gross result. */ | |
1562 | if (!lastseg) | |
1563 | newpath->segments = newseg; | |
1564 | else | |
1565 | lastseg->next = newseg; | |
1566 | lastseg = newseg; | |
1567 | } | |
68e1a55b | 1568 | aspath_str_update(newpath, false); |
d62a17ae | 1569 | /* We are happy returning even an empty AS_PATH, because the |
1570 | * administrator | |
1571 | * might expect this very behaviour. There's a mean to avoid this, if | |
1572 | * necessary, | |
1573 | * by having a match rule against certain AS_PATH regexps in the | |
1574 | * route-map index. | |
1575 | */ | |
1576 | aspath_free(source); | |
1577 | return newpath; | |
841f7a57 DO |
1578 | } |
1579 | ||
718e3744 | 1580 | /* Add specified AS to the leftmost of aspath. */ |
d62a17ae | 1581 | static struct aspath *aspath_add_asns(struct aspath *aspath, as_t asno, |
d7c0a89a | 1582 | uint8_t type, unsigned num) |
d62a17ae | 1583 | { |
1584 | struct assegment *assegment = aspath->segments; | |
1585 | unsigned i; | |
1586 | ||
1587 | if (assegment && assegment->type == type) { | |
1588 | /* extend existing segment */ | |
1589 | aspath->segments = | |
1590 | assegment_prepend_asns(aspath->segments, asno, num); | |
1591 | } else { | |
1592 | /* prepend with new segment */ | |
1593 | struct assegment *newsegment = assegment_new(type, num); | |
1594 | for (i = 0; i < num; i++) | |
1595 | newsegment->as[i] = asno; | |
1596 | ||
1597 | /* insert potentially replacing empty segment */ | |
1598 | if (assegment && assegment->length == 0) { | |
1599 | newsegment->next = assegment->next; | |
1600 | assegment_free(assegment); | |
1601 | } else | |
1602 | newsegment->next = assegment; | |
1603 | aspath->segments = newsegment; | |
bc3dd427 | 1604 | } |
718e3744 | 1605 | |
68e1a55b | 1606 | aspath_str_update(aspath, false); |
d62a17ae | 1607 | return aspath; |
718e3744 | 1608 | } |
1609 | ||
bc3dd427 | 1610 | /* Add specified AS to the leftmost of aspath num times. */ |
d62a17ae | 1611 | struct aspath *aspath_add_seq_n(struct aspath *aspath, as_t asno, unsigned num) |
bc3dd427 | 1612 | { |
d62a17ae | 1613 | return aspath_add_asns(aspath, asno, AS_SEQUENCE, num); |
bc3dd427 DW |
1614 | } |
1615 | ||
718e3744 | 1616 | /* Add specified AS to the leftmost of aspath. */ |
d62a17ae | 1617 | struct aspath *aspath_add_seq(struct aspath *aspath, as_t asno) |
718e3744 | 1618 | { |
d62a17ae | 1619 | return aspath_add_asns(aspath, asno, AS_SEQUENCE, 1); |
718e3744 | 1620 | } |
1621 | ||
1622 | /* Compare leftmost AS value for MED check. If as1's leftmost AS and | |
1623 | as2's leftmost AS is same return 1. */ | |
3967f0a8 | 1624 | bool aspath_cmp_left(const struct aspath *aspath1, const struct aspath *aspath2) |
718e3744 | 1625 | { |
d62a17ae | 1626 | const struct assegment *seg1; |
1627 | const struct assegment *seg2; | |
1628 | ||
1629 | if (!(aspath1 && aspath2)) | |
3967f0a8 | 1630 | return false; |
718e3744 | 1631 | |
d62a17ae | 1632 | seg1 = aspath1->segments; |
1633 | seg2 = aspath2->segments; | |
718e3744 | 1634 | |
d62a17ae | 1635 | /* If both paths are originated in this AS then we do want to compare |
1636 | * MED */ | |
1637 | if (!seg1 && !seg2) | |
3967f0a8 | 1638 | return true; |
718e3744 | 1639 | |
d62a17ae | 1640 | /* find first non-confed segments for each */ |
9d303b37 DL |
1641 | while (seg1 && ((seg1->type == AS_CONFED_SEQUENCE) |
1642 | || (seg1->type == AS_CONFED_SET))) | |
d62a17ae | 1643 | seg1 = seg1->next; |
2a3fa5d7 | 1644 | |
9d303b37 DL |
1645 | while (seg2 && ((seg2->type == AS_CONFED_SEQUENCE) |
1646 | || (seg2->type == AS_CONFED_SET))) | |
d62a17ae | 1647 | seg2 = seg2->next; |
718e3744 | 1648 | |
d62a17ae | 1649 | /* Check as1's */ |
1650 | if (!(seg1 && seg2 && (seg1->type == AS_SEQUENCE) | |
1651 | && (seg2->type == AS_SEQUENCE))) | |
3967f0a8 | 1652 | return false; |
718e3744 | 1653 | |
d62a17ae | 1654 | if (seg1->as[0] == seg2->as[0]) |
3967f0a8 | 1655 | return true; |
718e3744 | 1656 | |
3967f0a8 | 1657 | return false; |
718e3744 | 1658 | } |
1659 | ||
0b2aa3a0 PJ |
1660 | /* Truncate an aspath after a number of hops, and put the hops remaining |
1661 | * at the front of another aspath. Needed for AS4 compat. | |
1662 | * | |
1663 | * Returned aspath is a /new/ aspath, which should either by free'd or | |
1664 | * interned by the caller, as desired. | |
1665 | */ | |
d62a17ae | 1666 | struct aspath *aspath_reconcile_as4(struct aspath *aspath, |
1667 | struct aspath *as4path) | |
1668 | { | |
1669 | struct assegment *seg, *newseg, *prevseg = NULL; | |
1670 | struct aspath *newpath = NULL, *mergedpath; | |
1671 | int hops, cpasns = 0; | |
1672 | ||
e8a3a0a0 | 1673 | if (!aspath || !as4path) |
d62a17ae | 1674 | return NULL; |
1675 | ||
1676 | seg = aspath->segments; | |
1677 | ||
1678 | /* CONFEDs should get reconciled too.. */ | |
1679 | hops = (aspath_count_hops(aspath) + aspath_count_confeds(aspath)) | |
1680 | - aspath_count_hops(as4path); | |
1681 | ||
1682 | if (hops < 0) { | |
1683 | if (BGP_DEBUG(as4, AS4)) | |
ade6974d | 1684 | flog_warn( |
e50f7cfd | 1685 | EC_BGP_ASPATH_FEWER_HOPS, |
ade6974d | 1686 | "[AS4] Fewer hops in AS_PATH than NEW_AS_PATH"); |
d62a17ae | 1687 | /* Something's gone wrong. The RFC says we should now ignore |
1688 | * AS4_PATH, | |
1689 | * which is daft behaviour - it contains vital loop-detection | |
1690 | * information which must have been removed from AS_PATH. | |
1691 | */ | |
1692 | hops = aspath_count_hops(aspath); | |
1693 | } | |
1694 | ||
1695 | if (!hops) { | |
1696 | newpath = aspath_dup(as4path); | |
68e1a55b | 1697 | aspath_str_update(newpath, false); |
d62a17ae | 1698 | return newpath; |
0b2aa3a0 | 1699 | } |
d62a17ae | 1700 | |
1701 | if (BGP_DEBUG(as4, AS4)) | |
1702 | zlog_debug( | |
1703 | "[AS4] got AS_PATH %s and AS4_PATH %s synthesizing now", | |
1704 | aspath->str, as4path->str); | |
1705 | ||
1706 | while (seg && hops > 0) { | |
1707 | switch (seg->type) { | |
1708 | case AS_SET: | |
1709 | case AS_CONFED_SET: | |
1710 | hops--; | |
1711 | cpasns = seg->length; | |
1712 | break; | |
1713 | case AS_CONFED_SEQUENCE: | |
1714 | /* Should never split a confed-sequence, if hop-count | |
1715 | * suggests we must then something's gone wrong | |
1716 | * somewhere. | |
1717 | * | |
1718 | * Most important goal is to preserve AS_PATHs prime | |
1719 | * function | |
1720 | * as loop-detector, so we fudge the numbers so that the | |
1721 | * entire | |
1722 | * confed-sequence is merged in. | |
1723 | */ | |
1724 | if (hops < seg->length) { | |
1725 | if (BGP_DEBUG(as4, AS4)) | |
1726 | zlog_debug( | |
3efd0893 | 1727 | "[AS4] AS4PATHmangle: AS_CONFED_SEQUENCE falls across 2/4 ASN boundary somewhere, broken.."); |
d62a17ae | 1728 | hops = seg->length; |
1729 | } | |
1730 | /* fallthru */ | |
1731 | case AS_SEQUENCE: | |
1732 | cpasns = MIN(seg->length, hops); | |
1733 | hops -= seg->length; | |
1734 | } | |
1735 | ||
1736 | assert(cpasns <= seg->length); | |
1737 | ||
1738 | newseg = assegment_new(seg->type, 0); | |
1739 | newseg = assegment_append_asns(newseg, seg->as, cpasns); | |
1740 | ||
1741 | if (!newpath) { | |
1742 | newpath = aspath_new(); | |
1743 | newpath->segments = newseg; | |
1744 | } else | |
1745 | prevseg->next = newseg; | |
1746 | ||
1747 | prevseg = newseg; | |
1748 | seg = seg->next; | |
1749 | } | |
1750 | ||
1751 | /* We may be able to join some segments here, and we must | |
1752 | * do this because... we want normalised aspaths in out hash | |
1753 | * and we do not want to stumble in aspath_put. | |
1754 | */ | |
1755 | mergedpath = aspath_merge(newpath, aspath_dup(as4path)); | |
1756 | aspath_free(newpath); | |
1757 | mergedpath->segments = assegment_normalise(mergedpath->segments); | |
68e1a55b | 1758 | aspath_str_update(mergedpath, false); |
d62a17ae | 1759 | |
1760 | if (BGP_DEBUG(as4, AS4)) | |
1761 | zlog_debug("[AS4] result of synthesizing is %s", | |
1762 | mergedpath->str); | |
1763 | ||
1764 | return mergedpath; | |
0b2aa3a0 PJ |
1765 | } |
1766 | ||
718e3744 | 1767 | /* Compare leftmost AS value for MED check. If as1's leftmost AS and |
1768 | as2's leftmost AS is same return 1. (confederation as-path | |
1769 | only). */ | |
74df8d6d DS |
1770 | bool aspath_cmp_left_confed(const struct aspath *aspath1, |
1771 | const struct aspath *aspath2) | |
718e3744 | 1772 | { |
d62a17ae | 1773 | if (!(aspath1 && aspath2)) |
74df8d6d | 1774 | return false; |
718e3744 | 1775 | |
d62a17ae | 1776 | if (!(aspath1->segments && aspath2->segments)) |
74df8d6d | 1777 | return false; |
d62a17ae | 1778 | |
1779 | if ((aspath1->segments->type != AS_CONFED_SEQUENCE) | |
1780 | || (aspath2->segments->type != AS_CONFED_SEQUENCE)) | |
74df8d6d | 1781 | return false; |
d62a17ae | 1782 | |
1783 | if (aspath1->segments->as[0] == aspath2->segments->as[0]) | |
74df8d6d | 1784 | return true; |
d62a17ae | 1785 | |
74df8d6d | 1786 | return false; |
718e3744 | 1787 | } |
1788 | ||
66b199b2 DS |
1789 | /* Delete all AS_CONFED_SEQUENCE/SET segments from aspath. |
1790 | * RFC 5065 section 4.1.c.1 | |
1791 | * | |
1792 | * 1) if any path segments of the AS_PATH are of the type | |
1793 | * AS_CONFED_SEQUENCE or AS_CONFED_SET, those segments MUST be | |
1794 | * removed from the AS_PATH attribute, leaving the sanitized | |
1795 | * AS_PATH attribute to be operated on by steps 2, 3 or 4. | |
1796 | */ | |
d62a17ae | 1797 | struct aspath *aspath_delete_confed_seq(struct aspath *aspath) |
718e3744 | 1798 | { |
d62a17ae | 1799 | struct assegment *seg, *prev, *next; |
1800 | char removed_confed_segment; | |
1801 | ||
1802 | if (!(aspath && aspath->segments)) | |
1803 | return aspath; | |
718e3744 | 1804 | |
d62a17ae | 1805 | seg = aspath->segments; |
1806 | removed_confed_segment = 0; | |
1807 | next = NULL; | |
1808 | prev = NULL; | |
718e3744 | 1809 | |
d62a17ae | 1810 | while (seg) { |
1811 | next = seg->next; | |
66b199b2 | 1812 | |
d62a17ae | 1813 | if (seg->type == AS_CONFED_SEQUENCE |
1814 | || seg->type == AS_CONFED_SET) { | |
1815 | /* This is the first segment in the aspath */ | |
1816 | if (aspath->segments == seg) | |
1817 | aspath->segments = seg->next; | |
1818 | else | |
1819 | prev->next = seg->next; | |
66b199b2 | 1820 | |
d62a17ae | 1821 | assegment_free(seg); |
1822 | removed_confed_segment = 1; | |
1823 | } else | |
1824 | prev = seg; | |
66b199b2 | 1825 | |
d62a17ae | 1826 | seg = next; |
1827 | } | |
66b199b2 | 1828 | |
d62a17ae | 1829 | if (removed_confed_segment) |
68e1a55b | 1830 | aspath_str_update(aspath, false); |
66b199b2 | 1831 | |
d62a17ae | 1832 | return aspath; |
718e3744 | 1833 | } |
1834 | ||
1835 | /* Add new AS number to the leftmost part of the aspath as | |
1836 | AS_CONFED_SEQUENCE. */ | |
d62a17ae | 1837 | struct aspath *aspath_add_confed_seq(struct aspath *aspath, as_t asno) |
718e3744 | 1838 | { |
d62a17ae | 1839 | return aspath_add_asns(aspath, asno, AS_CONFED_SEQUENCE, 1); |
718e3744 | 1840 | } |
1841 | ||
1842 | /* Add new as value to as path structure. */ | |
d62a17ae | 1843 | static void aspath_as_add(struct aspath *as, as_t asno) |
718e3744 | 1844 | { |
d62a17ae | 1845 | struct assegment *seg = as->segments; |
1846 | ||
1847 | if (!seg) | |
1848 | return; | |
718e3744 | 1849 | |
d62a17ae | 1850 | /* Last segment search procedure. */ |
1851 | while (seg->next) | |
1852 | seg = seg->next; | |
93c1749c | 1853 | |
d62a17ae | 1854 | assegment_append_asns(seg, &asno, 1); |
718e3744 | 1855 | } |
1856 | ||
1857 | /* Add new as segment to the as path. */ | |
d62a17ae | 1858 | static void aspath_segment_add(struct aspath *as, int type) |
718e3744 | 1859 | { |
d62a17ae | 1860 | struct assegment *seg = as->segments; |
1861 | struct assegment *new = assegment_new(type, 0); | |
718e3744 | 1862 | |
d62a17ae | 1863 | if (seg) { |
1864 | while (seg->next) | |
1865 | seg = seg->next; | |
1866 | seg->next = new; | |
1867 | } else | |
1868 | as->segments = new; | |
718e3744 | 1869 | } |
1870 | ||
d62a17ae | 1871 | struct aspath *aspath_empty(void) |
718e3744 | 1872 | { |
d62a17ae | 1873 | return aspath_parse(NULL, 0, 1); /* 32Bit ;-) */ |
718e3744 | 1874 | } |
1875 | ||
d62a17ae | 1876 | struct aspath *aspath_empty_get(void) |
718e3744 | 1877 | { |
d62a17ae | 1878 | struct aspath *aspath; |
718e3744 | 1879 | |
d62a17ae | 1880 | aspath = aspath_new(); |
68e1a55b | 1881 | aspath_make_str_count(aspath, false); |
d62a17ae | 1882 | return aspath; |
718e3744 | 1883 | } |
1884 | ||
d62a17ae | 1885 | unsigned long aspath_count(void) |
718e3744 | 1886 | { |
d62a17ae | 1887 | return ashash->count; |
1888 | } | |
6b0655a2 | 1889 | |
d62a17ae | 1890 | /* |
718e3744 | 1891 | Theoretically, one as path can have: |
1892 | ||
1893 | One BGP packet size should be less than 4096. | |
1894 | One BGP attribute size should be less than 4096 - BGP header size. | |
1895 | One BGP aspath size should be less than 4096 - BGP header size - | |
1896 | BGP mandantry attribute size. | |
1897 | */ | |
1898 | ||
1899 | /* AS path string lexical token enum. */ | |
d62a17ae | 1900 | enum as_token { |
1901 | as_token_asval, | |
1902 | as_token_set_start, | |
1903 | as_token_set_end, | |
1904 | as_token_confed_seq_start, | |
1905 | as_token_confed_seq_end, | |
1906 | as_token_confed_set_start, | |
1907 | as_token_confed_set_end, | |
1908 | as_token_unknown | |
718e3744 | 1909 | }; |
1910 | ||
1911 | /* Return next token and point for string parse. */ | |
d62a17ae | 1912 | static const char *aspath_gettoken(const char *buf, enum as_token *token, |
d7c0a89a | 1913 | unsigned long *asno) |
d62a17ae | 1914 | { |
1915 | const char *p = buf; | |
1916 | ||
8afb9d8a | 1917 | /* Skip separators (space for sequences, ',' for sets). */ |
fefa5e0f | 1918 | while (isspace((unsigned char)*p) || *p == ',') |
d62a17ae | 1919 | p++; |
1920 | ||
1921 | /* Check the end of the string and type specify characters | |
1922 | (e.g. {}()). */ | |
1923 | switch (*p) { | |
1924 | case '\0': | |
1925 | return NULL; | |
1926 | case '{': | |
1927 | *token = as_token_set_start; | |
1928 | p++; | |
1929 | return p; | |
1930 | case '}': | |
1931 | *token = as_token_set_end; | |
1932 | p++; | |
1933 | return p; | |
1934 | case '(': | |
1935 | *token = as_token_confed_seq_start; | |
1936 | p++; | |
1937 | return p; | |
1938 | case ')': | |
1939 | *token = as_token_confed_seq_end; | |
1940 | p++; | |
1941 | return p; | |
1942 | case '[': | |
1943 | *token = as_token_confed_set_start; | |
1944 | p++; | |
1945 | return p; | |
1946 | case ']': | |
1947 | *token = as_token_confed_set_end; | |
1948 | p++; | |
1949 | return p; | |
1950 | } | |
1951 | ||
1952 | /* Check actual AS value. */ | |
fefa5e0f | 1953 | if (isdigit((unsigned char)*p)) { |
d62a17ae | 1954 | as_t asval; |
1955 | ||
1956 | *token = as_token_asval; | |
1957 | asval = (*p - '0'); | |
1958 | p++; | |
1959 | ||
fefa5e0f | 1960 | while (isdigit((unsigned char)*p)) { |
d62a17ae | 1961 | asval *= 10; |
1962 | asval += (*p - '0'); | |
1963 | p++; | |
1964 | } | |
1965 | *asno = asval; | |
1966 | return p; | |
718e3744 | 1967 | } |
718e3744 | 1968 | |
d62a17ae | 1969 | /* There is no match then return unknown token. */ |
1970 | *token = as_token_unknown; | |
b42d80dd VJ |
1971 | p++; |
1972 | return p; | |
d62a17ae | 1973 | } |
1974 | ||
1975 | struct aspath *aspath_str2aspath(const char *str) | |
1976 | { | |
1977 | enum as_token token = as_token_unknown; | |
d7c0a89a QY |
1978 | unsigned short as_type; |
1979 | unsigned long asno = 0; | |
d62a17ae | 1980 | struct aspath *aspath; |
1981 | int needtype; | |
1982 | ||
1983 | aspath = aspath_new(); | |
1984 | ||
1985 | /* We start default type as AS_SEQUENCE. */ | |
1986 | as_type = AS_SEQUENCE; | |
1987 | needtype = 1; | |
1988 | ||
1989 | while ((str = aspath_gettoken(str, &token, &asno)) != NULL) { | |
1990 | switch (token) { | |
1991 | case as_token_asval: | |
1992 | if (needtype) { | |
1993 | aspath_segment_add(aspath, as_type); | |
1994 | needtype = 0; | |
1995 | } | |
1996 | aspath_as_add(aspath, asno); | |
1997 | break; | |
1998 | case as_token_set_start: | |
1999 | as_type = AS_SET; | |
2000 | aspath_segment_add(aspath, as_type); | |
2001 | needtype = 0; | |
2002 | break; | |
2003 | case as_token_set_end: | |
2004 | as_type = AS_SEQUENCE; | |
2005 | needtype = 1; | |
2006 | break; | |
2007 | case as_token_confed_seq_start: | |
2008 | as_type = AS_CONFED_SEQUENCE; | |
2009 | aspath_segment_add(aspath, as_type); | |
2010 | needtype = 0; | |
2011 | break; | |
2012 | case as_token_confed_seq_end: | |
2013 | as_type = AS_SEQUENCE; | |
2014 | needtype = 1; | |
2015 | break; | |
2016 | case as_token_confed_set_start: | |
2017 | as_type = AS_CONFED_SET; | |
2018 | aspath_segment_add(aspath, as_type); | |
2019 | needtype = 0; | |
2020 | break; | |
2021 | case as_token_confed_set_end: | |
2022 | as_type = AS_SEQUENCE; | |
2023 | needtype = 1; | |
2024 | break; | |
2025 | case as_token_unknown: | |
2026 | default: | |
2027 | aspath_free(aspath); | |
2028 | return NULL; | |
2029 | } | |
2030 | } | |
2031 | ||
68e1a55b | 2032 | aspath_make_str_count(aspath, false); |
718e3744 | 2033 | |
d62a17ae | 2034 | return aspath; |
718e3744 | 2035 | } |
6b0655a2 | 2036 | |
718e3744 | 2037 | /* Make hash value by raw aspath data. */ |
d8b87afe | 2038 | unsigned int aspath_key_make(const void *p) |
718e3744 | 2039 | { |
d8b87afe | 2040 | const struct aspath *aspath = p; |
d62a17ae | 2041 | unsigned int key = 0; |
718e3744 | 2042 | |
d62a17ae | 2043 | if (!aspath->str) |
d8b87afe | 2044 | aspath_str_update((struct aspath *)aspath, false); |
f669f7d2 | 2045 | |
d62a17ae | 2046 | key = jhash(aspath->str, aspath->str_len, 2334325); |
718e3744 | 2047 | |
d62a17ae | 2048 | return key; |
718e3744 | 2049 | } |
2050 | ||
2051 | /* If two aspath have same value then return 1 else return 0 */ | |
74df8d6d | 2052 | bool aspath_cmp(const void *arg1, const void *arg2) |
d62a17ae | 2053 | { |
2054 | const struct assegment *seg1 = ((const struct aspath *)arg1)->segments; | |
2055 | const struct assegment *seg2 = ((const struct aspath *)arg2)->segments; | |
2056 | ||
2057 | while (seg1 || seg2) { | |
2058 | int i; | |
2059 | if ((!seg1 && seg2) || (seg1 && !seg2)) | |
74df8d6d | 2060 | return false; |
d62a17ae | 2061 | if (seg1->type != seg2->type) |
74df8d6d | 2062 | return false; |
d62a17ae | 2063 | if (seg1->length != seg2->length) |
74df8d6d | 2064 | return false; |
d62a17ae | 2065 | for (i = 0; i < seg1->length; i++) |
2066 | if (seg1->as[i] != seg2->as[i]) | |
74df8d6d | 2067 | return false; |
d62a17ae | 2068 | seg1 = seg1->next; |
2069 | seg2 = seg2->next; | |
2070 | } | |
74df8d6d | 2071 | return true; |
718e3744 | 2072 | } |
2073 | ||
2074 | /* AS path hash initialize. */ | |
d62a17ae | 2075 | void aspath_init(void) |
718e3744 | 2076 | { |
996c9314 | 2077 | ashash = hash_create_size(32768, aspath_key_make, aspath_cmp, |
3f65c5b1 | 2078 | "BGP AS Path"); |
718e3744 | 2079 | } |
8fdc32ab | 2080 | |
d62a17ae | 2081 | void aspath_finish(void) |
8fdc32ab | 2082 | { |
d62a17ae | 2083 | hash_clean(ashash, (void (*)(void *))aspath_free); |
2084 | hash_free(ashash); | |
2085 | ashash = NULL; | |
2086 | ||
2087 | if (snmp_stream) | |
2088 | stream_free(snmp_stream); | |
8fdc32ab | 2089 | } |
6b0655a2 | 2090 | |
718e3744 | 2091 | /* return and as path value */ |
d62a17ae | 2092 | const char *aspath_print(struct aspath *as) |
718e3744 | 2093 | { |
d62a17ae | 2094 | return (as ? as->str : NULL); |
718e3744 | 2095 | } |
2096 | ||
2097 | /* Printing functions */ | |
841f7a57 DO |
2098 | /* Feed the AS_PATH to the vty; the suffix string follows it only in case |
2099 | * AS_PATH wasn't empty. | |
2100 | */ | |
d62a17ae | 2101 | void aspath_print_vty(struct vty *vty, const char *format, struct aspath *as, |
2102 | const char *suffix) | |
718e3744 | 2103 | { |
d62a17ae | 2104 | assert(format); |
2105 | vty_out(vty, format, as->str); | |
2106 | if (as->str_len && strlen(suffix)) | |
2107 | vty_out(vty, "%s", suffix); | |
718e3744 | 2108 | } |
2109 | ||
e3b78da8 | 2110 | static void aspath_show_all_iterator(struct hash_bucket *bucket, |
d62a17ae | 2111 | struct vty *vty) |
718e3744 | 2112 | { |
d62a17ae | 2113 | struct aspath *as; |
718e3744 | 2114 | |
e3b78da8 | 2115 | as = (struct aspath *)bucket->data; |
718e3744 | 2116 | |
e3b78da8 | 2117 | vty_out(vty, "[%p:%u] (%ld) ", (void *)bucket, bucket->key, as->refcnt); |
d62a17ae | 2118 | vty_out(vty, "%s\n", as->str); |
718e3744 | 2119 | } |
2120 | ||
2121 | /* Print all aspath and hash information. This function is used from | |
716b2d8a | 2122 | `show [ip] bgp paths' command. */ |
d62a17ae | 2123 | void aspath_print_all_vty(struct vty *vty) |
718e3744 | 2124 | { |
e3b78da8 | 2125 | hash_iterate(ashash, (void (*)(struct hash_bucket *, |
9d303b37 | 2126 | void *))aspath_show_all_iterator, |
d62a17ae | 2127 | vty); |
718e3744 | 2128 | } |
e00d8008 NT |
2129 | |
2130 | static struct aspath *bgp_aggr_aspath_lookup(struct bgp_aggregate *aggregate, | |
2131 | struct aspath *aspath) | |
2132 | { | |
2133 | return hash_lookup(aggregate->aspath_hash, aspath); | |
2134 | } | |
2135 | ||
2136 | static void *bgp_aggr_aspath_hash_alloc(void *p) | |
2137 | { | |
2138 | struct aspath *ref = (struct aspath *)p; | |
2139 | struct aspath *aspath = NULL; | |
2140 | ||
2141 | aspath = aspath_dup(ref); | |
2142 | return aspath; | |
2143 | } | |
2144 | ||
7f5818fb | 2145 | static void bgp_aggr_aspath_prepare(struct hash_bucket *hb, void *arg) |
e00d8008 | 2146 | { |
e00d8008 NT |
2147 | struct aspath *hb_aspath = hb->data; |
2148 | struct aspath **aggr_aspath = arg; | |
2149 | ||
ef51a7d8 | 2150 | if (*aggr_aspath) |
2151 | *aggr_aspath = aspath_aggregate(*aggr_aspath, hb_aspath); | |
2152 | else | |
e00d8008 NT |
2153 | *aggr_aspath = aspath_dup(hb_aspath); |
2154 | } | |
2155 | ||
2156 | void bgp_aggr_aspath_remove(void *arg) | |
2157 | { | |
2158 | struct aspath *aspath = arg; | |
2159 | ||
2160 | aspath_free(aspath); | |
2161 | } | |
2162 | ||
2163 | void bgp_compute_aggregate_aspath(struct bgp_aggregate *aggregate, | |
2164 | struct aspath *aspath) | |
ef51a7d8 | 2165 | { |
2166 | bgp_compute_aggregate_aspath_hash(aggregate, aspath); | |
2167 | ||
2168 | bgp_compute_aggregate_aspath_val(aggregate); | |
2169 | ||
2170 | } | |
2171 | ||
2172 | void bgp_compute_aggregate_aspath_hash(struct bgp_aggregate *aggregate, | |
2173 | struct aspath *aspath) | |
e00d8008 NT |
2174 | { |
2175 | struct aspath *aggr_aspath = NULL; | |
2176 | ||
2177 | if ((aggregate == NULL) || (aspath == NULL)) | |
2178 | return; | |
2179 | ||
2180 | /* Create hash if not already created. | |
2181 | */ | |
2182 | if (aggregate->aspath_hash == NULL) | |
2183 | aggregate->aspath_hash = hash_create( | |
2184 | aspath_key_make, aspath_cmp, | |
2185 | "BGP Aggregator as-path hash"); | |
2186 | ||
2187 | aggr_aspath = bgp_aggr_aspath_lookup(aggregate, aspath); | |
2188 | if (aggr_aspath == NULL) { | |
2189 | /* Insert as-path into hash. | |
2190 | */ | |
2191 | aggr_aspath = hash_get(aggregate->aspath_hash, aspath, | |
2192 | bgp_aggr_aspath_hash_alloc); | |
ef51a7d8 | 2193 | } |
e00d8008 | 2194 | |
ef51a7d8 | 2195 | /* Increment reference counter. |
2196 | */ | |
2197 | aggr_aspath->refcnt++; | |
2198 | } | |
2199 | ||
2200 | void bgp_compute_aggregate_aspath_val(struct bgp_aggregate *aggregate) | |
2201 | { | |
2202 | if (aggregate == NULL) | |
2203 | return; | |
2204 | /* Re-compute aggregate's as-path. | |
2205 | */ | |
2206 | if (aggregate->aspath) { | |
2207 | aspath_free(aggregate->aspath); | |
2208 | aggregate->aspath = NULL; | |
2209 | } | |
2210 | if (aggregate->aspath_hash | |
2211 | && aggregate->aspath_hash->count) { | |
e00d8008 NT |
2212 | hash_iterate(aggregate->aspath_hash, |
2213 | bgp_aggr_aspath_prepare, | |
2214 | &aggregate->aspath); | |
2215 | } | |
e00d8008 NT |
2216 | } |
2217 | ||
2218 | void bgp_remove_aspath_from_aggregate(struct bgp_aggregate *aggregate, | |
2219 | struct aspath *aspath) | |
2220 | { | |
2221 | struct aspath *aggr_aspath = NULL; | |
2222 | struct aspath *ret_aspath = NULL; | |
2223 | ||
ef51a7d8 | 2224 | if ((!aggregate) |
2225 | || (!aggregate->aspath_hash) | |
2226 | || (!aspath)) | |
e00d8008 NT |
2227 | return; |
2228 | ||
2229 | /* Look-up the aspath in the hash. | |
2230 | */ | |
2231 | aggr_aspath = bgp_aggr_aspath_lookup(aggregate, aspath); | |
2232 | if (aggr_aspath) { | |
2233 | aggr_aspath->refcnt--; | |
2234 | ||
2235 | if (aggr_aspath->refcnt == 0) { | |
2236 | ret_aspath = hash_release(aggregate->aspath_hash, | |
2237 | aggr_aspath); | |
2238 | aspath_free(ret_aspath); | |
ef51a7d8 | 2239 | ret_aspath = NULL; |
e00d8008 NT |
2240 | |
2241 | /* Remove aggregate's old as-path. | |
2242 | */ | |
2243 | aspath_free(aggregate->aspath); | |
2244 | aggregate->aspath = NULL; | |
2245 | ||
ef51a7d8 | 2246 | bgp_compute_aggregate_aspath_val(aggregate); |
e00d8008 NT |
2247 | } |
2248 | } | |
2249 | } | |
ef51a7d8 | 2250 | |
2251 | void bgp_remove_aspath_from_aggregate_hash(struct bgp_aggregate *aggregate, | |
2252 | struct aspath *aspath) | |
2253 | { | |
2254 | struct aspath *aggr_aspath = NULL; | |
2255 | struct aspath *ret_aspath = NULL; | |
2256 | ||
2257 | if ((!aggregate) | |
2258 | || (!aggregate->aspath_hash) | |
2259 | || (!aspath)) | |
2260 | return; | |
2261 | ||
2262 | /* Look-up the aspath in the hash. | |
2263 | */ | |
2264 | aggr_aspath = bgp_aggr_aspath_lookup(aggregate, aspath); | |
2265 | if (aggr_aspath) { | |
2266 | aggr_aspath->refcnt--; | |
2267 | ||
2268 | if (aggr_aspath->refcnt == 0) { | |
2269 | ret_aspath = hash_release(aggregate->aspath_hash, | |
2270 | aggr_aspath); | |
2271 | aspath_free(ret_aspath); | |
2272 | ret_aspath = NULL; | |
2273 | } | |
2274 | } | |
2275 | } | |
2276 |