2 * IS-IS Rout(e)ing protocol - isis_lsp.c
5 * Copyright (C) 2001,2002 Sampo Saaristo
6 * Tampere University of Technology
7 * Institute of Communications Engineering
8 * Copyright (C) 2013-2015 Christian Franke <chris@opensourcerouting.org>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option)
15 * This program is distributed in the hope that it will be useful,but WITHOUT
16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
20 * You should have received a copy of the GNU General Public License along
21 * with this program; see the file COPYING; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
40 #include "srcdest_table.h"
41 #include "lib_errors.h"
43 #include "isisd/isis_constants.h"
44 #include "isisd/isis_common.h"
45 #include "isisd/isis_flags.h"
46 #include "isisd/isis_circuit.h"
47 #include "isisd/isisd.h"
48 #include "isisd/isis_lsp.h"
49 #include "isisd/isis_pdu.h"
50 #include "isisd/isis_dynhn.h"
51 #include "isisd/isis_misc.h"
52 #include "isisd/isis_csm.h"
53 #include "isisd/isis_adjacency.h"
54 #include "isisd/isis_spf.h"
55 #include "isisd/isis_mt.h"
56 #include "isisd/isis_tlvs.h"
57 #include "isisd/isis_te.h"
58 #include "isisd/isis_sr.h"
59 #include "isisd/fabricd.h"
60 #include "isisd/isis_tx_queue.h"
61 #include "isisd/isis_nb.h"
63 DEFINE_MTYPE_STATIC(ISISD
, ISIS_LSP
, "ISIS LSP");
65 static int lsp_refresh(struct thread
*thread
);
66 static int lsp_l1_refresh_pseudo(struct thread
*thread
);
67 static int lsp_l2_refresh_pseudo(struct thread
*thread
);
69 static void lsp_destroy(struct isis_lsp
*lsp
);
71 int lsp_id_cmp(uint8_t *id1
, uint8_t *id2
)
73 return memcmp(id1
, id2
, ISIS_SYS_ID_LEN
+ 2);
76 int lspdb_compare(const struct isis_lsp
*a
, const struct isis_lsp
*b
)
78 return memcmp(a
->hdr
.lsp_id
, b
->hdr
.lsp_id
, sizeof(a
->hdr
.lsp_id
));
81 void lsp_db_init(struct lspdb_head
*head
)
86 void lsp_db_fini(struct lspdb_head
*head
)
90 while ((lsp
= lspdb_pop(head
)))
95 struct isis_lsp
*lsp_search(struct lspdb_head
*head
, const uint8_t *id
)
97 struct isis_lsp searchfor
;
98 memcpy(searchfor
.hdr
.lsp_id
, id
, sizeof(searchfor
.hdr
.lsp_id
));
100 return lspdb_find(head
, &searchfor
);
103 static void lsp_clear_data(struct isis_lsp
*lsp
)
108 isis_free_tlvs(lsp
->tlvs
);
112 static void lsp_remove_frags(struct lspdb_head
*head
, struct list
*frags
);
114 static void lsp_destroy(struct isis_lsp
*lsp
)
116 struct listnode
*cnode
;
117 struct isis_circuit
*circuit
;
122 for (ALL_LIST_ELEMENTS_RO(lsp
->area
->circuit_list
, cnode
, circuit
))
123 isis_tx_queue_del(circuit
->tx_queue
, lsp
);
125 ISIS_FLAGS_CLEAR_ALL(lsp
->SSNflags
);
127 isis_te_lsp_event(lsp
, LSP_DEL
);
131 if (!LSP_FRAGMENT(lsp
->hdr
.lsp_id
)) {
132 if (lsp
->lspu
.frags
) {
133 lsp_remove_frags(&lsp
->area
->lspdb
[lsp
->level
- 1],
135 list_delete(&lsp
->lspu
.frags
);
138 if (lsp
->lspu
.zero_lsp
139 && lsp
->lspu
.zero_lsp
->lspu
.frags
) {
140 listnode_delete(lsp
->lspu
.zero_lsp
->lspu
.frags
, lsp
);
144 isis_spf_schedule(lsp
->area
, lsp
->level
);
147 stream_free(lsp
->pdu
);
149 fabricd_lsp_free(lsp
);
150 XFREE(MTYPE_ISIS_LSP
, lsp
);
154 * Remove all the frags belonging to the given lsp
156 static void lsp_remove_frags(struct lspdb_head
*head
, struct list
*frags
)
158 struct listnode
*lnode
, *lnnode
;
159 struct isis_lsp
*lsp
;
161 for (ALL_LIST_ELEMENTS(frags
, lnode
, lnnode
, lsp
)) {
162 lsp
= lsp_search(head
, lsp
->hdr
.lsp_id
);
163 lspdb_del(head
, lsp
);
168 void lsp_search_and_destroy(struct lspdb_head
*head
, const uint8_t *id
)
170 struct isis_lsp
*lsp
;
172 lsp
= lsp_search(head
, id
);
174 lspdb_del(head
, lsp
);
176 * If this is a zero lsp, remove all the frags now
178 if (LSP_FRAGMENT(lsp
->hdr
.lsp_id
) == 0) {
180 lsp_remove_frags(head
, lsp
->lspu
.frags
);
183 * else just remove this frag, from the zero lsps' frag
186 if (lsp
->lspu
.zero_lsp
187 && lsp
->lspu
.zero_lsp
->lspu
.frags
)
188 listnode_delete(lsp
->lspu
.zero_lsp
->lspu
.frags
,
196 * Compares a LSP to given values
197 * Params are given in net order
199 int lsp_compare(char *areatag
, struct isis_lsp
*lsp
, uint32_t seqno
,
200 uint16_t checksum
, uint16_t rem_lifetime
)
202 if (lsp
->hdr
.seqno
== seqno
&& lsp
->hdr
.checksum
== checksum
203 && ((lsp
->hdr
.rem_lifetime
== 0 && rem_lifetime
== 0)
204 || (lsp
->hdr
.rem_lifetime
!= 0 && rem_lifetime
!= 0))) {
205 if (IS_DEBUG_SNP_PACKETS
) {
207 "ISIS-Snp (%s): Compare LSP %s seq 0x%08x, cksum 0x%04hx, lifetime %hus",
208 areatag
, rawlspid_print(lsp
->hdr
.lsp_id
),
209 lsp
->hdr
.seqno
, lsp
->hdr
.checksum
,
210 lsp
->hdr
.rem_lifetime
);
212 "ISIS-Snp (%s): is equal to ours seq 0x%08x, cksum 0x%04hx, lifetime %hus",
213 areatag
, seqno
, checksum
, rem_lifetime
);
219 * LSPs with identical checksums should only be treated as newer if:
220 * a) The current LSP has a remaining lifetime != 0 and the other LSP
222 * remaining lifetime == 0. In this case, we should participate in
224 * and should not treat the current LSP with remaining lifetime == 0
226 * b) The LSP has an incorrect checksum. In this case, we need to react
230 if (seqno
> lsp
->hdr
.seqno
231 || (seqno
== lsp
->hdr
.seqno
232 && ((lsp
->hdr
.rem_lifetime
!= 0 && rem_lifetime
== 0)
233 || (lsp
->hdr
.checksum
!= checksum
234 && lsp
->hdr
.rem_lifetime
)))) {
235 if (IS_DEBUG_SNP_PACKETS
) {
237 "ISIS-Snp (%s): Compare LSP %s seq 0x%08x, cksum 0x%04hx, lifetime %hus",
238 areatag
, rawlspid_print(lsp
->hdr
.lsp_id
), seqno
,
239 checksum
, rem_lifetime
);
241 "ISIS-Snp (%s): is newer than ours seq 0x%08x, cksum 0x%04hx, lifetime %hus",
242 areatag
, lsp
->hdr
.seqno
, lsp
->hdr
.checksum
,
243 lsp
->hdr
.rem_lifetime
);
247 if (IS_DEBUG_SNP_PACKETS
) {
248 zlog_debug("ISIS-Snp (%s): Compare LSP %s seq 0x%08x, cksum 0x%04hx, lifetime %hus",
249 areatag
, rawlspid_print(lsp
->hdr
.lsp_id
), seqno
,
250 checksum
, rem_lifetime
);
252 "ISIS-Snp (%s): is older than ours seq 0x%08x, cksum 0x%04hx, lifetime %hus",
253 areatag
, lsp
->hdr
.seqno
, lsp
->hdr
.checksum
,
254 lsp
->hdr
.rem_lifetime
);
260 static void put_lsp_hdr(struct isis_lsp
*lsp
, size_t *len_pointer
, bool keep
)
263 (lsp
->level
== IS_LEVEL_1
) ? L1_LINK_STATE
: L2_LINK_STATE
;
264 struct isis_lsp_hdr
*hdr
= &lsp
->hdr
;
265 struct stream
*stream
= lsp
->pdu
;
266 size_t orig_getp
= 0, orig_endp
= 0;
269 orig_getp
= stream_get_getp(lsp
->pdu
);
270 orig_endp
= stream_get_endp(lsp
->pdu
);
273 stream_set_getp(lsp
->pdu
, 0);
274 stream_set_endp(lsp
->pdu
, 0);
276 fill_fixed_hdr(pdu_type
, stream
);
279 *len_pointer
= stream_get_endp(stream
);
280 stream_putw(stream
, hdr
->pdu_len
);
281 stream_putw(stream
, hdr
->rem_lifetime
);
282 stream_put(stream
, hdr
->lsp_id
, sizeof(hdr
->lsp_id
));
283 stream_putl(stream
, hdr
->seqno
);
284 stream_putw(stream
, hdr
->checksum
);
285 stream_putc(stream
, hdr
->lsp_bits
);
288 stream_set_endp(lsp
->pdu
, orig_endp
);
289 stream_set_getp(lsp
->pdu
, orig_getp
);
293 static void lsp_add_auth(struct isis_lsp
*lsp
)
295 struct isis_passwd
*passwd
;
296 passwd
= (lsp
->level
== IS_LEVEL_1
) ? &lsp
->area
->area_passwd
297 : &lsp
->area
->domain_passwd
;
298 isis_tlvs_add_auth(lsp
->tlvs
, passwd
);
301 static void lsp_pack_pdu(struct isis_lsp
*lsp
)
304 lsp
->tlvs
= isis_alloc_tlvs();
309 put_lsp_hdr(lsp
, &len_pointer
, false);
310 isis_pack_tlvs(lsp
->tlvs
, lsp
->pdu
, len_pointer
, false, true);
312 lsp
->hdr
.pdu_len
= stream_get_endp(lsp
->pdu
);
314 ntohs(fletcher_checksum(STREAM_DATA(lsp
->pdu
) + 12,
315 stream_get_endp(lsp
->pdu
) - 12, 12));
318 void lsp_inc_seqno(struct isis_lsp
*lsp
, uint32_t seqno
)
322 if (seqno
== 0 || lsp
->hdr
.seqno
> seqno
)
323 newseq
= lsp
->hdr
.seqno
+ 1;
328 /* check for overflow */
329 if (newseq
< lsp
->hdr
.seqno
) {
330 /* send northbound notification */
331 lsp
->area
->lsp_exceeded_max_counter
++;
332 isis_notif_lsp_exceed_max(lsp
->area
, lsp
->hdr
.lsp_id
);
334 #endif /* ifndef FABRICD */
336 lsp
->hdr
.seqno
= newseq
;
339 isis_spf_schedule(lsp
->area
, lsp
->level
);
340 isis_te_lsp_event(lsp
, LSP_INC
);
343 static void lsp_purge_add_poi(struct isis_lsp
*lsp
,
344 const uint8_t *sender
)
346 if (lsp
->area
== NULL
)
349 if (!lsp
->area
->purge_originator
)
352 /* add purge originator identification */
354 lsp
->tlvs
= isis_alloc_tlvs();
355 isis_tlvs_set_purge_originator(lsp
->tlvs
, lsp
->area
->isis
->sysid
,
357 isis_tlvs_set_dynamic_hostname(lsp
->tlvs
, cmd_hostname_get());
360 static void lsp_purge(struct isis_lsp
*lsp
, int level
,
361 const uint8_t *sender
)
365 stream_reset(lsp
->pdu
);
368 lsp
->hdr
.checksum
= 0;
369 lsp
->hdr
.rem_lifetime
= 0;
371 lsp
->age_out
= lsp
->area
->max_lsp_lifetime
[level
- 1];
372 lsp
->area
->lsp_purge_count
[level
- 1]++;
374 lsp_purge_add_poi(lsp
, sender
);
377 lsp_flood(lsp
, NULL
);
381 * Generates checksum for LSP and its frags
383 static void lsp_seqno_update(struct isis_lsp
*lsp0
)
385 struct isis_lsp
*lsp
;
386 struct listnode
*node
;
388 lsp_inc_seqno(lsp0
, 0);
390 if (!lsp0
->lspu
.frags
)
393 for (ALL_LIST_ELEMENTS_RO(lsp0
->lspu
.frags
, node
, lsp
)) {
395 lsp_inc_seqno(lsp
, 0);
396 else if (lsp
->hdr
.rem_lifetime
) {
397 /* Purge should only be applied when the fragment has
398 * non-zero remaining lifetime.
400 lsp_purge(lsp
, lsp0
->level
, NULL
);
407 bool isis_level2_adj_up(struct isis_area
*area
)
409 struct listnode
*node
, *cnode
;
410 struct isis_circuit
*circuit
;
412 struct isis_adjacency
*adj
;
414 if (area
->is_type
== IS_LEVEL_1
)
417 for (ALL_LIST_ELEMENTS_RO(area
->circuit_list
, cnode
, circuit
)) {
418 if (circuit
->circ_type
== CIRCUIT_T_BROADCAST
) {
419 adjdb
= circuit
->u
.bc
.adjdb
[1];
420 if (!adjdb
|| !adjdb
->count
)
423 for (ALL_LIST_ELEMENTS_RO(adjdb
, node
, adj
)) {
424 if (adj
->level
!= ISIS_ADJ_LEVEL1
425 && adj
->adj_state
== ISIS_ADJ_UP
)
428 } else if (circuit
->circ_type
== CIRCUIT_T_P2P
429 && circuit
->u
.p2p
.neighbor
) {
430 adj
= circuit
->u
.p2p
.neighbor
;
431 if (adj
->level
!= ISIS_ADJ_LEVEL1
432 && adj
->adj_state
== ISIS_ADJ_UP
)
440 static void isis_reset_attach_bit(struct isis_adjacency
*adj
)
442 struct isis_area
*area
= adj
->circuit
->area
;
443 struct lspdb_head
*head
;
444 struct isis_lsp
*lsp
;
445 uint8_t lspid
[ISIS_SYS_ID_LEN
+ 2];
448 * If an L2 adjacency changed its state in L-1-2 area, we have to:
449 * - set the attached bit in L1 LSPs if it's the first L2 adjacency
450 * - remove the attached bit in L1 LSPs if it's the last L2 adjacency
453 if (area
->is_type
!= IS_LEVEL_1_AND_2
|| adj
->level
== ISIS_ADJ_LEVEL1
)
456 if (!area
->attached_bit_send
)
459 head
= &area
->lspdb
[IS_LEVEL_1
- 1];
460 memset(lspid
, 0, ISIS_SYS_ID_LEN
+ 2);
461 memcpy(lspid
, area
->isis
->sysid
, ISIS_SYS_ID_LEN
);
463 lsp
= lsp_search(head
, lspid
);
467 if (adj
->adj_state
== ISIS_ADJ_UP
468 && !(lsp
->hdr
.lsp_bits
& LSPBIT_ATT
)) {
469 sched_debug("ISIS (%s): adj going up regenerate lsp-bits",
471 lsp_regenerate_schedule(area
, IS_LEVEL_1
, 0);
472 } else if (adj
->adj_state
== ISIS_ADJ_DOWN
473 && (lsp
->hdr
.lsp_bits
& LSPBIT_ATT
)
474 && !isis_level2_adj_up(area
)) {
475 sched_debug("ISIS (%s): adj going down regenerate lsp-bits",
477 lsp_regenerate_schedule(area
, IS_LEVEL_1
, 0);
481 static uint8_t lsp_bits_generate(int level
, int overload_bit
, int attached_bit
,
482 struct isis_area
*area
)
484 uint8_t lsp_bits
= 0;
485 if (area
->is_type
== IS_LEVEL_1
)
486 lsp_bits
= IS_LEVEL_1
;
488 lsp_bits
= IS_LEVEL_1_AND_2
;
490 lsp_bits
|= overload_bit
;
492 /* only set the attach bit if we are a level-1-2 router and this is
493 * a level-1 LSP and we have a level-2 adjacency up from another area
495 if (area
->is_type
== IS_LEVEL_1_AND_2
&& level
== IS_LEVEL_1
496 && attached_bit
&& isis_level2_adj_up(area
))
497 lsp_bits
|= LSPBIT_ATT
;
501 static void lsp_update_data(struct isis_lsp
*lsp
, struct isis_lsp_hdr
*hdr
,
502 struct isis_tlvs
*tlvs
, struct stream
*stream
,
503 struct isis_area
*area
, int level
)
505 /* free the old lsp data */
508 /* copying only the relevant part of our stream */
509 if (lsp
->pdu
!= NULL
)
510 stream_free(lsp
->pdu
);
511 lsp
->pdu
= stream_dup(stream
);
513 memcpy(&lsp
->hdr
, hdr
, sizeof(lsp
->hdr
));
516 lsp
->age_out
= ZERO_AGE_LIFETIME
;
517 lsp
->installed
= time(NULL
);
521 if (area
->dynhostname
&& lsp
->tlvs
->hostname
522 && lsp
->hdr
.rem_lifetime
) {
524 area
->isis
, lsp
->hdr
.lsp_id
, lsp
->tlvs
->hostname
,
525 (lsp
->hdr
.lsp_bits
& LSPBIT_IST
) == IS_LEVEL_1_AND_2
533 static void lsp_link_fragment(struct isis_lsp
*lsp
, struct isis_lsp
*lsp0
)
535 if (!LSP_FRAGMENT(lsp
->hdr
.lsp_id
)) {
536 /* zero lsp -> create list to store fragments */
537 lsp
->lspu
.frags
= list_new();
539 /* fragment -> set backpointer and add to zero lsps list */
541 lsp
->lspu
.zero_lsp
= lsp0
;
542 listnode_add(lsp0
->lspu
.frags
, lsp
);
546 void lsp_update(struct isis_lsp
*lsp
, struct isis_lsp_hdr
*hdr
,
547 struct isis_tlvs
*tlvs
, struct stream
*stream
,
548 struct isis_area
*area
, int level
, bool confusion
)
553 "ISIS-Upd (%s): BUG updating LSP %s still marked as own LSP",
554 area
->area_tag
, rawlspid_print(lsp
->hdr
.lsp_id
));
560 lsp_purge(lsp
, level
, NULL
);
562 lsp_update_data(lsp
, hdr
, tlvs
, stream
, area
, level
);
565 if (LSP_FRAGMENT(lsp
->hdr
.lsp_id
) && !lsp
->lspu
.zero_lsp
) {
566 uint8_t lspid
[ISIS_SYS_ID_LEN
+ 2];
567 struct isis_lsp
*lsp0
;
569 memcpy(lspid
, lsp
->hdr
.lsp_id
, ISIS_SYS_ID_LEN
+ 1);
570 LSP_FRAGMENT(lspid
) = 0;
571 lsp0
= lsp_search(&area
->lspdb
[level
- 1], lspid
);
573 lsp_link_fragment(lsp
, lsp0
);
576 if (lsp
->hdr
.seqno
) {
577 isis_spf_schedule(lsp
->area
, lsp
->level
);
578 isis_te_lsp_event(lsp
, LSP_UPD
);
582 /* creation of LSP directly from what we received */
583 struct isis_lsp
*lsp_new_from_recv(struct isis_lsp_hdr
*hdr
,
584 struct isis_tlvs
*tlvs
,
585 struct stream
*stream
, struct isis_lsp
*lsp0
,
586 struct isis_area
*area
, int level
)
588 struct isis_lsp
*lsp
;
590 lsp
= XCALLOC(MTYPE_ISIS_LSP
, sizeof(struct isis_lsp
));
591 lsp_update_data(lsp
, hdr
, tlvs
, stream
, area
, level
);
592 lsp_link_fragment(lsp
, lsp0
);
597 static void lsp_adjust_stream(struct isis_lsp
*lsp
)
600 if (STREAM_SIZE(lsp
->pdu
) == LLC_LEN
+ lsp
->area
->lsp_mtu
)
602 stream_free(lsp
->pdu
);
605 lsp
->pdu
= stream_new(LLC_LEN
+ lsp
->area
->lsp_mtu
);
608 struct isis_lsp
*lsp_new(struct isis_area
*area
, uint8_t *lsp_id
,
609 uint16_t rem_lifetime
, uint32_t seqno
,
610 uint8_t lsp_bits
, uint16_t checksum
,
611 struct isis_lsp
*lsp0
, int level
)
613 struct isis_lsp
*lsp
;
615 lsp
= XCALLOC(MTYPE_ISIS_LSP
, sizeof(struct isis_lsp
));
618 lsp_adjust_stream(lsp
);
620 /* Minimal LSP PDU size */
621 lsp
->hdr
.pdu_len
= ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
;
622 memcpy(lsp
->hdr
.lsp_id
, lsp_id
, sizeof(lsp
->hdr
.lsp_id
));
623 lsp
->hdr
.checksum
= checksum
;
624 lsp
->hdr
.seqno
= seqno
;
625 lsp
->hdr
.rem_lifetime
= rem_lifetime
;
626 lsp
->hdr
.lsp_bits
= lsp_bits
;
628 lsp
->age_out
= ZERO_AGE_LIFETIME
;
629 lsp_link_fragment(lsp
, lsp0
);
630 put_lsp_hdr(lsp
, NULL
, false);
633 zlog_debug("New LSP with ID %s-%02x-%02x len %d seqnum %08x",
634 sysid_print(lsp_id
), LSP_PSEUDO_ID(lsp
->hdr
.lsp_id
),
635 LSP_FRAGMENT(lsp
->hdr
.lsp_id
), lsp
->hdr
.pdu_len
,
641 void lsp_insert(struct lspdb_head
*head
, struct isis_lsp
*lsp
)
643 lspdb_add(head
, lsp
);
644 if (lsp
->hdr
.seqno
) {
645 isis_spf_schedule(lsp
->area
, lsp
->level
);
646 isis_te_lsp_event(lsp
, LSP_ADD
);
651 * Build a list of LSPs with non-zero ht and seqno bounded by start and stop ids
653 void lsp_build_list_nonzero_ht(struct lspdb_head
*head
, const uint8_t *start_id
,
654 const uint8_t *stop_id
, struct list
*list
)
656 struct isis_lsp searchfor
;
657 struct isis_lsp
*lsp
, *start
;
659 memcpy(&searchfor
.hdr
.lsp_id
, start_id
, sizeof(searchfor
.hdr
.lsp_id
));
661 start
= lspdb_find_gteq(head
, &searchfor
);
662 frr_each_from (lspdb
, head
, lsp
, start
) {
663 if (memcmp(lsp
->hdr
.lsp_id
, stop_id
,
664 ISIS_SYS_ID_LEN
+ 2) > 0)
667 if (lsp
->hdr
.rem_lifetime
&& lsp
->hdr
.seqno
)
668 listnode_add(list
, lsp
);
672 static void lsp_set_time(struct isis_lsp
*lsp
)
676 if (lsp
->hdr
.rem_lifetime
== 0) {
677 if (lsp
->age_out
> 0)
682 lsp
->hdr
.rem_lifetime
--;
683 if (lsp
->pdu
&& stream_get_endp(lsp
->pdu
) >= 12)
684 stream_putw_at(lsp
->pdu
, 10, lsp
->hdr
.rem_lifetime
);
687 void lspid_print(uint8_t *lsp_id
, char *dest
, size_t dest_len
, char dynhost
,
688 char frag
, struct isis
*isis
)
690 struct isis_dynhn
*dyn
= NULL
;
691 char id
[SYSID_STRLEN
];
694 dyn
= dynhn_find_by_id(isis
, lsp_id
);
699 snprintf(id
, sizeof(id
), "%.14s", dyn
->hostname
);
700 else if (!memcmp(isis
->sysid
, lsp_id
, ISIS_SYS_ID_LEN
) && dynhost
)
701 snprintf(id
, sizeof(id
), "%.14s", cmd_hostname_get());
703 memcpy(id
, sysid_print(lsp_id
), 15);
706 snprintf(dest
, dest_len
, "%s.%02x-%02x", id
,
707 LSP_PSEUDO_ID(lsp_id
), LSP_FRAGMENT(lsp_id
));
709 snprintf(dest
, dest_len
, "%s.%02x", id
, LSP_PSEUDO_ID(lsp_id
));
712 /* Convert the lsp attribute bits to attribute string */
713 static const char *lsp_bits2string(uint8_t lsp_bits
, char *buf
, size_t buf_size
)
720 if (buf_size
< 2 * 3)
723 /* we only focus on the default metric */
724 pos
+= snprintf(pos
, buf_size
, "%d/",
725 ISIS_MASK_LSP_ATT_BITS(lsp_bits
) ? 1 : 0);
727 pos
+= snprintf(pos
, buf_size
, "%d/",
728 ISIS_MASK_LSP_PARTITION_BIT(lsp_bits
) ? 1 : 0);
730 snprintf(pos
, buf_size
, "%d", ISIS_MASK_LSP_OL_BIT(lsp_bits
) ? 1 : 0);
735 /* this function prints the lsp on show isis database */
736 void lsp_print(struct isis_lsp
*lsp
, struct vty
*vty
, char dynhost
,
743 lspid_print(lsp
->hdr
.lsp_id
, LSPid
, sizeof(LSPid
), dynhost
, 1, isis
);
744 vty_out(vty
, "%-21s%c ", LSPid
, lsp
->own_lsp
? '*' : ' ');
745 vty_out(vty
, "%5hu ", lsp
->hdr
.pdu_len
);
746 vty_out(vty
, "0x%08x ", lsp
->hdr
.seqno
);
747 vty_out(vty
, "0x%04hx ", lsp
->hdr
.checksum
);
748 if (lsp
->hdr
.rem_lifetime
== 0) {
749 snprintf(age_out
, sizeof(age_out
), "(%d)", lsp
->age_out
);
751 vty_out(vty
, "%7s ", age_out
);
753 vty_out(vty
, " %5hu ", lsp
->hdr
.rem_lifetime
);
754 vty_out(vty
, "%s\n", lsp_bits2string(lsp
->hdr
.lsp_bits
, b
, sizeof(b
)));
757 void lsp_print_detail(struct isis_lsp
*lsp
, struct vty
*vty
, char dynhost
,
760 lsp_print(lsp
, vty
, dynhost
, isis
);
762 vty_multiline(vty
, " ", "%s", isis_format_tlvs(lsp
->tlvs
));
766 /* print all the lsps info in the local lspdb */
767 int lsp_print_all(struct vty
*vty
, struct lspdb_head
*head
, char detail
,
768 char dynhost
, struct isis
*isis
)
770 struct isis_lsp
*lsp
;
773 if (detail
== ISIS_UI_LEVEL_BRIEF
) {
774 frr_each (lspdb
, head
, lsp
) {
775 lsp_print(lsp
, vty
, dynhost
, isis
);
778 } else if (detail
== ISIS_UI_LEVEL_DETAIL
) {
779 frr_each (lspdb
, head
, lsp
) {
780 lsp_print_detail(lsp
, vty
, dynhost
, isis
);
788 static uint16_t lsp_rem_lifetime(struct isis_area
*area
, int level
)
790 uint16_t rem_lifetime
;
792 /* Add jitter to configured LSP lifetime */
794 isis_jitter(area
->max_lsp_lifetime
[level
- 1], MAX_AGE_JITTER
);
796 /* No jitter if the max refresh will be less than configure gen interval
798 /* N.B. this calucation is acceptable since rem_lifetime is in
801 if (area
->lsp_gen_interval
[level
- 1] > (rem_lifetime
- 300))
802 rem_lifetime
= area
->max_lsp_lifetime
[level
- 1];
807 static uint16_t lsp_refresh_time(struct isis_lsp
*lsp
, uint16_t rem_lifetime
)
809 struct isis_area
*area
= lsp
->area
;
810 int level
= lsp
->level
;
811 uint16_t refresh_time
;
813 /* Add jitter to LSP refresh time */
815 isis_jitter(area
->lsp_refresh
[level
- 1], MAX_LSP_GEN_JITTER
);
817 /* RFC 4444 : make sure the refresh time is at least less than 300
818 * of the remaining lifetime and more than gen interval */
819 if (refresh_time
<= area
->lsp_gen_interval
[level
- 1]
820 || refresh_time
> (rem_lifetime
- 300))
821 refresh_time
= rem_lifetime
- 300;
823 /* In cornercases, refresh_time might be <= lsp_gen_interval, however
824 * we accept this violation to satisfy refresh_time <= rem_lifetime -
830 static void lsp_build_ext_reach_ipv4(struct isis_lsp
*lsp
,
831 struct isis_area
*area
)
833 struct route_table
*er_table
= get_ext_reach(area
, AF_INET
, lsp
->level
);
837 for (struct route_node
*rn
= route_top(er_table
); rn
;
838 rn
= route_next(rn
)) {
842 struct prefix_ipv4
*ipv4
= (struct prefix_ipv4
*)&rn
->p
;
843 struct isis_ext_info
*info
= rn
->info
;
845 uint32_t metric
= info
->metric
;
846 if (metric
> MAX_WIDE_PATH_METRIC
)
847 metric
= MAX_WIDE_PATH_METRIC
;
848 if (area
->oldmetric
&& metric
> 0x3f)
852 isis_tlvs_add_oldstyle_ip_reach(lsp
->tlvs
, ipv4
,
854 if (area
->newmetric
) {
855 struct sr_prefix_cfg
*pcfg
= NULL
;
857 if (area
->srdb
.enabled
)
858 pcfg
= isis_sr_cfg_prefix_find(area
, ipv4
);
860 isis_tlvs_add_extended_ip_reach(lsp
->tlvs
, ipv4
, metric
,
866 static void lsp_build_ext_reach_ipv6(struct isis_lsp
*lsp
,
867 struct isis_area
*area
)
869 struct route_table
*er_table
=
870 get_ext_reach(area
, AF_INET6
, lsp
->level
);
874 for (struct route_node
*rn
= route_top(er_table
); rn
;
875 rn
= srcdest_route_next(rn
)) {
878 struct isis_ext_info
*info
= rn
->info
;
879 struct prefix_ipv6
*p
, *src_p
;
881 srcdest_rnode_prefixes(rn
, (const struct prefix
**)&p
,
882 (const struct prefix
**)&src_p
);
884 uint32_t metric
= info
->metric
;
885 if (info
->metric
> MAX_WIDE_PATH_METRIC
)
886 metric
= MAX_WIDE_PATH_METRIC
;
888 if (!src_p
|| !src_p
->prefixlen
) {
889 struct sr_prefix_cfg
*pcfg
= NULL
;
891 if (area
->srdb
.enabled
)
892 pcfg
= isis_sr_cfg_prefix_find(area
, p
);
894 isis_tlvs_add_ipv6_reach(lsp
->tlvs
,
895 isis_area_ipv6_topology(area
),
896 p
, metric
, true, pcfg
);
897 } else if (isis_area_ipv6_dstsrc_enabled(area
)) {
898 isis_tlvs_add_ipv6_dstsrc_reach(lsp
->tlvs
,
905 static void lsp_build_ext_reach(struct isis_lsp
*lsp
, struct isis_area
*area
)
907 lsp_build_ext_reach_ipv4(lsp
, area
);
908 lsp_build_ext_reach_ipv6(lsp
, area
);
911 static struct isis_lsp
*lsp_next_frag(uint8_t frag_num
, struct isis_lsp
*lsp0
,
912 struct isis_area
*area
, int level
)
914 struct isis_lsp
*lsp
;
915 uint8_t frag_id
[ISIS_SYS_ID_LEN
+ 2];
917 memcpy(frag_id
, lsp0
->hdr
.lsp_id
, ISIS_SYS_ID_LEN
+ 1);
918 LSP_FRAGMENT(frag_id
) = frag_num
;
920 lsp
= lsp_search(&area
->lspdb
[level
- 1], frag_id
);
923 if (!lsp
->lspu
.zero_lsp
)
924 lsp_link_fragment(lsp
, lsp0
);
928 lsp
= lsp_new(area
, frag_id
, lsp0
->hdr
.rem_lifetime
, 0,
929 lsp_bits_generate(level
, area
->overload_bit
,
930 area
->attached_bit_send
, area
),
933 lsp_insert(&area
->lspdb
[level
- 1], lsp
);
938 * Builds the LSP data part. This func creates a new frag whenever
939 * area->lsp_frag_threshold is exceeded.
941 static void lsp_build(struct isis_lsp
*lsp
, struct isis_area
*area
)
943 int level
= lsp
->level
;
944 struct listnode
*node
;
945 struct isis_lsp
*frag
;
948 for (ALL_LIST_ELEMENTS_RO(lsp
->lspu
.frags
, node
, frag
))
949 lsp_clear_data(frag
);
951 lsp
->tlvs
= isis_alloc_tlvs();
952 lsp_debug("ISIS (%s): Constructing local system LSP for level %d",
953 area
->area_tag
, level
);
955 lsp
->hdr
.lsp_bits
= lsp_bits_generate(level
, area
->overload_bit
,
956 area
->attached_bit_send
, area
);
960 isis_tlvs_add_area_addresses(lsp
->tlvs
, area
->area_addrs
);
962 /* Protocols Supported */
963 if (area
->ip_circuits
> 0 || area
->ipv6_circuits
> 0) {
964 struct nlpids nlpids
= {.count
= 0};
966 if (area
->ip_circuits
> 0) {
968 "ISIS (%s): Found IPv4 circuit, adding IPv4 to NLPIDs",
970 nlpids
.nlpids
[nlpids
.count
] = NLPID_IP
;
973 if (area
->ipv6_circuits
> 0) {
975 "ISIS (%s): Found IPv6 circuit, adding IPv6 to NLPIDs",
977 nlpids
.nlpids
[nlpids
.count
] = NLPID_IPV6
;
980 isis_tlvs_set_protocols_supported(lsp
->tlvs
, &nlpids
);
983 if (area_is_mt(area
)) {
984 lsp_debug("ISIS (%s): Adding MT router tlv...", area
->area_tag
);
986 struct isis_area_mt_setting
**mt_settings
;
987 unsigned int mt_count
;
989 mt_settings
= area_mt_settings(area
, &mt_count
);
990 for (unsigned int i
= 0; i
< mt_count
; i
++) {
991 isis_tlvs_add_mt_router_info(
992 lsp
->tlvs
, mt_settings
[i
]->mtid
,
993 mt_settings
[i
]->overload
, false);
994 lsp_debug("ISIS (%s): MT %s", area
->area_tag
,
995 isis_mtid2str(mt_settings
[i
]->mtid
));
998 lsp_debug("ISIS (%s): Not adding MT router tlv (disabled)",
1001 /* Dynamic Hostname */
1002 if (area
->dynhostname
) {
1003 isis_tlvs_set_dynamic_hostname(lsp
->tlvs
, cmd_hostname_get());
1004 lsp_debug("ISIS (%s): Adding dynamic hostname '%s'",
1005 area
->area_tag
, cmd_hostname_get());
1007 lsp_debug("ISIS (%s): Not adding dynamic hostname (disabled)",
1011 /* Add Router Capability TLV. */
1012 if (area
->isis
->router_id
!= 0) {
1013 struct isis_router_cap cap
= {};
1015 cap
.router_id
.s_addr
= area
->isis
->router_id
;
1017 /* Add SR Sub-TLVs if SR is enabled. */
1018 if (area
->srdb
.enabled
) {
1019 struct isis_sr_db
*srdb
= &area
->srdb
;
1020 uint32_t range_size
;
1023 range_size
= srdb
->config
.srgb_upper_bound
1024 - srdb
->config
.srgb_lower_bound
+ 1;
1025 cap
.srgb
.flags
= ISIS_SUBTLV_SRGB_FLAG_I
1026 | ISIS_SUBTLV_SRGB_FLAG_V
;
1027 cap
.srgb
.range_size
= range_size
;
1028 cap
.srgb
.lower_bound
= srdb
->config
.srgb_lower_bound
;
1029 /* Then Algorithm */
1030 cap
.algo
[0] = SR_ALGORITHM_SPF
;
1031 cap
.algo
[1] = SR_ALGORITHM_UNSET
;
1034 range_size
= srdb
->config
.srlb_upper_bound
1035 - srdb
->config
.srlb_lower_bound
+ 1;
1036 cap
.srlb
.range_size
= range_size
;
1037 cap
.srlb
.lower_bound
= srdb
->config
.srlb_lower_bound
;
1038 /* And finally MSD */
1039 cap
.msd
= srdb
->config
.msd
;
1041 /* Disable SR Algorithm */
1042 cap
.algo
[0] = SR_ALGORITHM_UNSET
;
1043 cap
.algo
[1] = SR_ALGORITHM_UNSET
;
1046 isis_tlvs_set_router_capability(lsp
->tlvs
, &cap
);
1047 lsp_debug("ISIS (%s): Adding Router Capabilities information",
1051 /* IPv4 address and TE router ID TLVs.
1052 * In case of the first one we don't follow "C" vendor,
1053 * but "J" vendor behavior - one IPv4 address is put
1054 * into LSP. TE router ID will be the same if MPLS-TE
1055 * is not activate or MPLS-TE router-id not specified
1057 if (area
->isis
->router_id
!= 0) {
1058 struct in_addr id
= {.s_addr
= area
->isis
->router_id
};
1059 lsp_debug("ISIS (%s): Adding router ID %pI4 as IPv4 tlv.",
1060 area
->area_tag
, &id
);
1061 isis_tlvs_add_ipv4_address(lsp
->tlvs
, &id
);
1063 /* If new style TLV's are in use, add TE router ID TLV
1064 * Check if MPLS-TE is activate and mpls-te router-id set
1065 * otherwise add exactly same data as for IPv4 address
1067 if (area
->newmetric
) {
1068 if (IS_MPLS_TE(area
->mta
)
1069 && area
->mta
->router_id
.s_addr
!= INADDR_ANY
)
1070 id
.s_addr
= area
->mta
->router_id
.s_addr
;
1072 "ISIS (%s): Adding router ID also as TE router ID tlv.",
1074 isis_tlvs_set_te_router_id(lsp
->tlvs
, &id
);
1077 lsp_debug("ISIS (%s): Router ID is unset. Not adding tlv.",
1081 if (IS_MPLS_TE(area
->mta
)
1082 && !IN6_IS_ADDR_UNSPECIFIED(&area
->mta
->router_id_ipv6
)) {
1083 lsp_debug("ISIS (%s): Adding IPv6 TE Router ID tlv.",
1085 isis_tlvs_set_te_router_id_ipv6(lsp
->tlvs
,
1086 &area
->mta
->router_id_ipv6
);
1089 lsp_debug("ISIS (%s): Adding circuit specific information.",
1094 "ISIS (%s): Adding tier %hhu spine-leaf-extension tlv.",
1095 area
->area_tag
, fabricd_tier(area
));
1096 isis_tlvs_add_spine_leaf(lsp
->tlvs
, fabricd_tier(area
), true,
1097 false, false, false);
1100 struct isis_circuit
*circuit
;
1101 for (ALL_LIST_ELEMENTS_RO(area
->circuit_list
, node
, circuit
)) {
1102 if (!circuit
->interface
)
1104 "ISIS (%s): Processing %s circuit %p with unknown interface",
1106 circuit_type2string(circuit
->circ_type
),
1109 lsp_debug("ISIS (%s): Processing %s circuit %s",
1111 circuit_type2string(circuit
->circ_type
),
1112 circuit
->interface
->name
);
1114 if (circuit
->state
!= C_STATE_UP
) {
1115 lsp_debug("ISIS (%s): Circuit is not up, ignoring.",
1120 uint32_t metric
= area
->oldmetric
1121 ? circuit
->metric
[level
- 1]
1122 : circuit
->te_metric
[level
- 1];
1124 if (circuit
->ip_router
&& circuit
->ip_addrs
1125 && circuit
->ip_addrs
->count
> 0) {
1127 "ISIS (%s): Circuit has IPv4 active, adding respective TLVs.",
1129 struct listnode
*ipnode
;
1130 struct prefix_ipv4
*ipv4
;
1131 for (ALL_LIST_ELEMENTS_RO(circuit
->ip_addrs
, ipnode
,
1133 if (area
->oldmetric
) {
1135 "ISIS (%s): Adding old-style IP reachability for %pFX",
1136 area
->area_tag
, ipv4
);
1137 isis_tlvs_add_oldstyle_ip_reach(
1138 lsp
->tlvs
, ipv4
, metric
);
1141 if (area
->newmetric
) {
1142 struct sr_prefix_cfg
*pcfg
= NULL
;
1145 "ISIS (%s): Adding te-style IP reachability for %pFX",
1146 area
->area_tag
, ipv4
);
1148 if (area
->srdb
.enabled
)
1149 pcfg
= isis_sr_cfg_prefix_find(
1152 isis_tlvs_add_extended_ip_reach(
1153 lsp
->tlvs
, ipv4
, metric
, false,
1159 if (circuit
->ipv6_router
&& circuit
->ipv6_non_link
1160 && circuit
->ipv6_non_link
->count
> 0) {
1161 struct listnode
*ipnode
;
1162 struct prefix_ipv6
*ipv6
;
1164 for (ALL_LIST_ELEMENTS_RO(circuit
->ipv6_non_link
,
1166 struct sr_prefix_cfg
*pcfg
= NULL
;
1169 "ISIS (%s): Adding IPv6 reachability for %pFX",
1170 area
->area_tag
, ipv6
);
1172 if (area
->srdb
.enabled
)
1173 pcfg
= isis_sr_cfg_prefix_find(area
,
1176 isis_tlvs_add_ipv6_reach(
1178 isis_area_ipv6_topology(area
), ipv6
,
1179 metric
, false, pcfg
);
1183 switch (circuit
->circ_type
) {
1184 case CIRCUIT_T_BROADCAST
:
1185 if (level
& circuit
->is_type
) {
1187 (level
== IS_LEVEL_1
)
1188 ? circuit
->u
.bc
.l1_desig_is
1189 : circuit
->u
.bc
.l2_desig_is
;
1191 if (LSP_PSEUDO_ID(ne_id
)) {
1192 if (area
->oldmetric
) {
1194 "ISIS (%s): Adding DIS %s.%02x as old-style neighbor",
1197 LSP_PSEUDO_ID(ne_id
));
1198 isis_tlvs_add_oldstyle_reach(
1202 if (area
->newmetric
)
1205 level
, ne_id
, metric
);
1209 "ISIS (%s): Circuit is not active for current level. Not adding IS neighbors",
1213 case CIRCUIT_T_P2P
: {
1214 struct isis_adjacency
*nei
= circuit
->u
.p2p
.neighbor
;
1215 if (nei
&& nei
->adj_state
== ISIS_ADJ_UP
1216 && (level
& nei
->circuit_t
)) {
1218 memcpy(ne_id
, nei
->sysid
, ISIS_SYS_ID_LEN
);
1219 LSP_PSEUDO_ID(ne_id
) = 0;
1221 if (area
->oldmetric
) {
1223 "ISIS (%s): Adding old-style is reach for %s",
1225 sysid_print(ne_id
));
1226 isis_tlvs_add_oldstyle_reach(
1227 lsp
->tlvs
, ne_id
, metric
);
1229 if (area
->newmetric
) {
1230 uint32_t neighbor_metric
;
1231 if (fabricd_tier(area
) == 0) {
1232 neighbor_metric
= 0xffe;
1234 neighbor_metric
= metric
;
1237 tlvs_add_mt_p2p(lsp
->tlvs
, circuit
,
1238 ne_id
, neighbor_metric
);
1242 "ISIS (%s): No adjacency for given level on this circuit. Not adding IS neighbors",
1246 case CIRCUIT_T_LOOPBACK
:
1249 zlog_warn("lsp_area_create: unknown circuit type");
1253 lsp_build_ext_reach(lsp
, area
);
1255 struct isis_tlvs
*tlvs
= lsp
->tlvs
;
1258 lsp_adjust_stream(lsp
);
1260 size_t tlv_space
= STREAM_WRITEABLE(lsp
->pdu
) - LLC_LEN
;
1261 lsp_clear_data(lsp
);
1263 struct list
*fragments
= isis_fragment_tlvs(tlvs
, tlv_space
);
1265 zlog_warn("BUG: could not fragment own LSP:");
1266 log_multiline(LOG_WARNING
, " ", "%s",
1267 isis_format_tlvs(tlvs
));
1268 isis_free_tlvs(tlvs
);
1271 isis_free_tlvs(tlvs
);
1273 bool fragment_overflow
= false;
1275 for (ALL_LIST_ELEMENTS_RO(fragments
, node
, tlvs
)) {
1276 if (node
!= listhead(fragments
)) {
1277 if (LSP_FRAGMENT(frag
->hdr
.lsp_id
) == 255) {
1278 if (!fragment_overflow
) {
1279 fragment_overflow
= true;
1281 "ISIS (%s): Too much information for 256 fragments",
1284 isis_free_tlvs(tlvs
);
1288 frag
= lsp_next_frag(LSP_FRAGMENT(frag
->hdr
.lsp_id
) + 1,
1290 lsp_adjust_stream(frag
);
1295 list_delete(&fragments
);
1296 lsp_debug("ISIS (%s): LSP construction is complete. Serializing...",
1302 * 7.3.7 and 7.3.9 Generation on non-pseudonode LSPs
1304 int lsp_generate(struct isis_area
*area
, int level
)
1306 struct isis_lsp
*oldlsp
, *newlsp
;
1307 uint32_t seq_num
= 0;
1308 uint8_t lspid
[ISIS_SYS_ID_LEN
+ 2];
1309 uint16_t rem_lifetime
, refresh_time
;
1311 if ((area
== NULL
) || (area
->is_type
& level
) != level
)
1314 memset(&lspid
, 0, ISIS_SYS_ID_LEN
+ 2);
1316 memcpy(&lspid
, area
->isis
->sysid
, ISIS_SYS_ID_LEN
);
1318 /* only builds the lsp if the area shares the level */
1319 oldlsp
= lsp_search(&area
->lspdb
[level
- 1], lspid
);
1321 /* FIXME: we should actually initiate a purge */
1322 seq_num
= oldlsp
->hdr
.seqno
;
1323 lsp_search_and_destroy(&area
->lspdb
[level
- 1],
1324 oldlsp
->hdr
.lsp_id
);
1326 rem_lifetime
= lsp_rem_lifetime(area
, level
);
1327 newlsp
= lsp_new(area
, lspid
, rem_lifetime
, seq_num
,
1328 lsp_bits_generate(area
->is_type
, area
->overload_bit
,
1329 area
->attached_bit_send
, area
),
1331 newlsp
->area
= area
;
1332 newlsp
->own_lsp
= 1;
1334 lsp_insert(&area
->lspdb
[level
- 1], newlsp
);
1335 /* build_lsp_data (newlsp, area); */
1336 lsp_build(newlsp
, area
);
1337 /* time to calculate our checksum */
1338 lsp_seqno_update(newlsp
);
1339 newlsp
->last_generated
= time(NULL
);
1340 lsp_flood(newlsp
, NULL
);
1341 area
->lsp_gen_count
[level
- 1]++;
1343 refresh_time
= lsp_refresh_time(newlsp
, rem_lifetime
);
1345 thread_cancel(&area
->t_lsp_refresh
[level
- 1]);
1346 area
->lsp_regenerate_pending
[level
- 1] = 0;
1347 thread_add_timer(master
, lsp_refresh
,
1348 &area
->lsp_refresh_arg
[level
- 1], refresh_time
,
1349 &area
->t_lsp_refresh
[level
- 1]);
1351 if (IS_DEBUG_UPDATE_PACKETS
) {
1352 zlog_debug("ISIS-Upd (%s): Building L%d LSP %s, len %hu, seq 0x%08x, cksum 0x%04hx, lifetime %hus refresh %hus",
1353 area
->area_tag
, level
,
1354 rawlspid_print(newlsp
->hdr
.lsp_id
),
1355 newlsp
->hdr
.pdu_len
, newlsp
->hdr
.seqno
,
1356 newlsp
->hdr
.checksum
, newlsp
->hdr
.rem_lifetime
,
1360 "ISIS (%s): Built L%d LSP. Set triggered regenerate to non-pending.",
1361 area
->area_tag
, level
);
1364 /* send northbound notification */
1365 isis_notif_lsp_gen(area
, newlsp
->hdr
.lsp_id
, newlsp
->hdr
.seqno
,
1366 newlsp
->last_generated
);
1367 #endif /* ifndef FABRICD */
1373 * Search own LSPs, update holding time and flood
1375 static int lsp_regenerate(struct isis_area
*area
, int level
)
1377 struct lspdb_head
*head
;
1378 struct isis_lsp
*lsp
, *frag
;
1379 struct listnode
*node
;
1380 uint8_t lspid
[ISIS_SYS_ID_LEN
+ 2];
1381 uint16_t rem_lifetime
, refresh_time
;
1383 if ((area
== NULL
) || (area
->is_type
& level
) != level
)
1386 head
= &area
->lspdb
[level
- 1];
1387 memset(lspid
, 0, ISIS_SYS_ID_LEN
+ 2);
1388 memcpy(lspid
, area
->isis
->sysid
, ISIS_SYS_ID_LEN
);
1390 lsp
= lsp_search(head
, lspid
);
1393 flog_err(EC_LIB_DEVELOPMENT
,
1394 "ISIS-Upd (%s): lsp_regenerate: no L%d LSP found!",
1395 area
->area_tag
, level
);
1399 lsp_clear_data(lsp
);
1400 lsp_build(lsp
, area
);
1401 rem_lifetime
= lsp_rem_lifetime(area
, level
);
1402 lsp
->hdr
.rem_lifetime
= rem_lifetime
;
1403 lsp
->last_generated
= time(NULL
);
1404 lsp_flood(lsp
, NULL
);
1405 area
->lsp_gen_count
[level
- 1]++;
1406 for (ALL_LIST_ELEMENTS_RO(lsp
->lspu
.frags
, node
, frag
)) {
1408 /* Updating and flooding should only affect fragments
1414 frag
->hdr
.lsp_bits
=
1415 lsp_bits_generate(level
, area
->overload_bit
,
1416 area
->attached_bit_send
, area
);
1417 /* Set the lifetime values of all the fragments to the same
1419 * so that no fragment expires before the lsp is refreshed.
1421 frag
->hdr
.rem_lifetime
= rem_lifetime
;
1422 frag
->age_out
= ZERO_AGE_LIFETIME
;
1423 lsp_flood(frag
, NULL
);
1425 lsp_seqno_update(lsp
);
1427 refresh_time
= lsp_refresh_time(lsp
, rem_lifetime
);
1428 thread_add_timer(master
, lsp_refresh
,
1429 &area
->lsp_refresh_arg
[level
- 1], refresh_time
,
1430 &area
->t_lsp_refresh
[level
- 1]);
1431 area
->lsp_regenerate_pending
[level
- 1] = 0;
1433 if (IS_DEBUG_UPDATE_PACKETS
) {
1435 "ISIS-Upd (%s): Refreshed our L%d LSP %s, len %hu, seq 0x%08x, cksum 0x%04hx, lifetime %hus refresh %hus",
1436 area
->area_tag
, level
, rawlspid_print(lsp
->hdr
.lsp_id
),
1437 lsp
->hdr
.pdu_len
, lsp
->hdr
.seqno
, lsp
->hdr
.checksum
,
1438 lsp
->hdr
.rem_lifetime
, refresh_time
);
1441 "ISIS (%s): Rebuilt L%d LSP. Set triggered regenerate to non-pending.",
1442 area
->area_tag
, level
);
1448 * Something has changed or periodic refresh -> regenerate LSP
1450 static int lsp_refresh(struct thread
*thread
)
1452 struct lsp_refresh_arg
*arg
= THREAD_ARG(thread
);
1456 struct isis_area
*area
= arg
->area
;
1460 int level
= arg
->level
;
1462 area
->t_lsp_refresh
[level
- 1] = NULL
;
1463 area
->lsp_regenerate_pending
[level
- 1] = 0;
1465 if ((area
->is_type
& level
) == 0)
1469 * Throttle regeneration of LSPs (but not when BFD signalled a 'down'
1472 if (monotime_since(&area
->last_lsp_refresh_event
[level
- 1], NULL
)
1474 && !(area
->bfd_force_spf_refresh
)) {
1475 sched_debug("ISIS (%s): Still unstable, postpone LSP L%d refresh",
1476 area
->area_tag
, level
);
1477 _lsp_regenerate_schedule(area
, level
, 0, false,
1478 __func__
, __FILE__
, __LINE__
);
1483 "ISIS (%s): LSP L%d refresh timer expired. Refreshing LSP...",
1484 area
->area_tag
, level
);
1485 return lsp_regenerate(area
, level
);
1488 int _lsp_regenerate_schedule(struct isis_area
*area
, int level
,
1489 int all_pseudo
, bool postpone
,
1490 const char *func
, const char *file
,
1493 struct isis_lsp
*lsp
;
1494 uint8_t id
[ISIS_SYS_ID_LEN
+ 2];
1497 struct listnode
*cnode
;
1498 struct isis_circuit
*circuit
;
1505 "ISIS (%s): Scheduling regeneration of %s LSPs, %sincluding PSNs Caller: %s %s:%d",
1506 area
->area_tag
, circuit_t2string(level
),
1507 all_pseudo
? "" : "not ",
1510 memcpy(id
, area
->isis
->sysid
, ISIS_SYS_ID_LEN
);
1511 LSP_PSEUDO_ID(id
) = LSP_FRAGMENT(id
) = 0;
1514 for (lvl
= IS_LEVEL_1
; lvl
<= IS_LEVEL_2
; lvl
++) {
1515 if (!((level
& lvl
) && (area
->is_type
& lvl
)))
1519 monotime(&area
->last_lsp_refresh_event
[lvl
- 1]);
1523 "ISIS (%s): Checking whether L%d needs to be scheduled",
1524 area
->area_tag
, lvl
);
1526 if (area
->lsp_regenerate_pending
[lvl
- 1]
1527 && !(area
->bfd_signalled_down
)) {
1529 * Note: in case of a BFD 'down' message the refresh is
1530 * scheduled once again just to be sure
1532 struct timeval remain
= thread_timer_remain(
1533 area
->t_lsp_refresh
[lvl
- 1]);
1535 "ISIS (%s): Regeneration is already pending, nothing todo. (Due in %lld.%03lld seconds)",
1536 area
->area_tag
, (long long)remain
.tv_sec
,
1537 (long long)remain
.tv_usec
/ 1000);
1541 lsp
= lsp_search(&area
->lspdb
[lvl
- 1], id
);
1544 "ISIS (%s): We do not have any LSPs to regenerate, nothing todo.",
1550 * Throttle avoidance
1553 "ISIS (%s): Will schedule regen timer. Last run was: %lld, Now is: %lld",
1554 area
->area_tag
, (long long)lsp
->last_generated
,
1556 thread_cancel(&area
->t_lsp_refresh
[lvl
- 1]);
1557 diff
= now
- lsp
->last_generated
;
1558 if (diff
< area
->lsp_gen_interval
[lvl
- 1]
1559 && !(area
->bfd_signalled_down
)) {
1561 1000 * (area
->lsp_gen_interval
[lvl
- 1] - diff
);
1563 "ISIS (%s): Scheduling in %ld ms to match configured lsp_gen_interval",
1564 area
->area_tag
, timeout
);
1567 * Schedule LSP refresh ASAP
1569 if (area
->bfd_signalled_down
) {
1571 "ISIS (%s): Scheduling immediately due to BFD 'down' message.",
1573 area
->bfd_signalled_down
= false;
1574 area
->bfd_force_spf_refresh
= true;
1577 int64_t time_since_last
= monotime_since(
1578 &area
->last_lsp_refresh_event
[lvl
- 1],
1580 timeout
= time_since_last
< 100000L
1581 ? (100000L - time_since_last
)/1000
1585 "ISIS (%s): Last generation was more than lsp_gen_interval ago. Scheduling for execution in %ld ms due to the instability timer.",
1586 area
->area_tag
, timeout
);
1589 "ISIS (%s): Last generation was more than lsp_gen_interval ago. Scheduling for execution now.",
1594 area
->lsp_regenerate_pending
[lvl
- 1] = 1;
1595 thread_add_timer_msec(master
, lsp_refresh
,
1596 &area
->lsp_refresh_arg
[lvl
- 1],
1598 &area
->t_lsp_refresh
[lvl
- 1]);
1602 for (ALL_LIST_ELEMENTS_RO(area
->circuit_list
, cnode
, circuit
))
1603 lsp_regenerate_schedule_pseudo(circuit
, level
);
1610 * Funcs for pseudonode LSPs
1614 * 7.3.8 and 7.3.10 Generation of level 1 and 2 pseudonode LSPs
1616 static void lsp_build_pseudo(struct isis_lsp
*lsp
, struct isis_circuit
*circuit
,
1619 struct isis_adjacency
*adj
;
1620 struct list
*adj_list
;
1621 struct listnode
*node
;
1622 struct isis_area
*area
= circuit
->area
;
1625 lsp_clear_data(lsp
);
1626 lsp
->tlvs
= isis_alloc_tlvs();
1628 "ISIS (%s): Constructing pseudo LSP %s for interface %s level %d",
1629 area
->area_tag
, rawlspid_print(lsp
->hdr
.lsp_id
),
1630 circuit
->interface
->name
, level
);
1633 /* RFC3787 section 4 SHOULD not set overload bit in pseudo LSPs */
1634 lsp
->hdr
.lsp_bits
= lsp_bits_generate(
1635 level
, 0, circuit
->area
->attached_bit_send
, area
);
1638 * add self to IS neighbours
1640 uint8_t ne_id
[ISIS_SYS_ID_LEN
+ 1];
1642 memcpy(ne_id
, area
->isis
->sysid
, ISIS_SYS_ID_LEN
);
1643 LSP_PSEUDO_ID(ne_id
) = 0;
1645 if (circuit
->area
->oldmetric
) {
1646 isis_tlvs_add_oldstyle_reach(lsp
->tlvs
, ne_id
, 0);
1648 "ISIS (%s): Adding %s.%02x as old-style neighbor (self)",
1649 area
->area_tag
, sysid_print(ne_id
),
1650 LSP_PSEUDO_ID(ne_id
));
1652 if (circuit
->area
->newmetric
) {
1653 if (area_is_mt(circuit
->area
))
1654 mtid
= ISIS_MT_IPV4_UNICAST
;
1656 mtid
= ISIS_MT_DISABLE
;
1657 isis_tlvs_add_extended_reach(lsp
->tlvs
, mtid
, ne_id
, 0, NULL
);
1659 "ISIS (%s): Adding %s.%02x as te-style neighbor (self)",
1660 area
->area_tag
, sysid_print(ne_id
),
1661 LSP_PSEUDO_ID(ne_id
));
1664 adj_list
= list_new();
1665 isis_adj_build_up_list(circuit
->u
.bc
.adjdb
[level
- 1], adj_list
);
1667 for (ALL_LIST_ELEMENTS_RO(adj_list
, node
, adj
)) {
1668 if (!(adj
->level
& level
)) {
1670 "ISIS (%s): Ignoring neighbor %s, level does not intersect",
1671 area
->area_tag
, sysid_print(adj
->sysid
));
1675 if (!(level
== IS_LEVEL_1
1676 && adj
->sys_type
== ISIS_SYSTYPE_L1_IS
)
1677 && !(level
== IS_LEVEL_1
1678 && adj
->sys_type
== ISIS_SYSTYPE_L2_IS
1679 && adj
->adj_usage
== ISIS_ADJ_LEVEL1AND2
)
1680 && !(level
== IS_LEVEL_2
1681 && adj
->sys_type
== ISIS_SYSTYPE_L2_IS
)) {
1683 "ISIS (%s): Ignoring neighbor %s, level does not match",
1684 area
->area_tag
, sysid_print(adj
->sysid
));
1688 memcpy(ne_id
, adj
->sysid
, ISIS_SYS_ID_LEN
);
1689 if (circuit
->area
->oldmetric
) {
1690 isis_tlvs_add_oldstyle_reach(lsp
->tlvs
, ne_id
, 0);
1692 "ISIS (%s): Adding %s.%02x as old-style neighbor (peer)",
1693 area
->area_tag
, sysid_print(ne_id
),
1694 LSP_PSEUDO_ID(ne_id
));
1696 if (circuit
->area
->newmetric
) {
1697 isis_tlvs_add_extended_reach(lsp
->tlvs
,
1698 ISIS_MT_IPV4_UNICAST
,
1701 "ISIS (%s): Adding %s.%02x as te-style neighbor (peer)",
1702 area
->area_tag
, sysid_print(ne_id
),
1703 LSP_PSEUDO_ID(ne_id
));
1706 list_delete(&adj_list
);
1710 int lsp_generate_pseudo(struct isis_circuit
*circuit
, int level
)
1712 struct lspdb_head
*head
= &circuit
->area
->lspdb
[level
- 1];
1713 struct isis_lsp
*lsp
;
1714 uint8_t lsp_id
[ISIS_SYS_ID_LEN
+ 2];
1715 uint16_t rem_lifetime
, refresh_time
;
1717 if ((circuit
->is_type
& level
) != level
1718 || (circuit
->state
!= C_STATE_UP
)
1719 || (circuit
->circ_type
!= CIRCUIT_T_BROADCAST
)
1720 || (circuit
->u
.bc
.is_dr
[level
- 1] == 0))
1723 memcpy(lsp_id
, circuit
->isis
->sysid
, ISIS_SYS_ID_LEN
);
1724 LSP_FRAGMENT(lsp_id
) = 0;
1725 LSP_PSEUDO_ID(lsp_id
) = circuit
->circuit_id
;
1728 * If for some reason have a pseudo LSP in the db already -> regenerate
1730 if (lsp_search(head
, lsp_id
))
1731 return lsp_regenerate_schedule_pseudo(circuit
, level
);
1733 rem_lifetime
= lsp_rem_lifetime(circuit
->area
, level
);
1734 /* RFC3787 section 4 SHOULD not set overload bit in pseudo LSPs */
1735 lsp
= lsp_new(circuit
->area
, lsp_id
, rem_lifetime
, 1,
1736 lsp_bits_generate(circuit
->area
->is_type
, 0,
1737 circuit
->area
->attached_bit_send
,
1740 lsp
->area
= circuit
->area
;
1742 lsp_build_pseudo(lsp
, circuit
, level
);
1745 lsp_insert(head
, lsp
);
1746 lsp_flood(lsp
, NULL
);
1748 refresh_time
= lsp_refresh_time(lsp
, rem_lifetime
);
1749 thread_cancel(&circuit
->u
.bc
.t_refresh_pseudo_lsp
[level
- 1]);
1750 circuit
->lsp_regenerate_pending
[level
- 1] = 0;
1751 if (level
== IS_LEVEL_1
)
1753 master
, lsp_l1_refresh_pseudo
, circuit
, refresh_time
,
1754 &circuit
->u
.bc
.t_refresh_pseudo_lsp
[level
- 1]);
1755 else if (level
== IS_LEVEL_2
)
1757 master
, lsp_l2_refresh_pseudo
, circuit
, refresh_time
,
1758 &circuit
->u
.bc
.t_refresh_pseudo_lsp
[level
- 1]);
1760 if (IS_DEBUG_UPDATE_PACKETS
) {
1762 "ISIS-Upd (%s): Built L%d Pseudo LSP %s, len %hu, seq 0x%08x, cksum 0x%04hx, lifetime %hus, refresh %hus",
1763 circuit
->area
->area_tag
, level
,
1764 rawlspid_print(lsp
->hdr
.lsp_id
), lsp
->hdr
.pdu_len
,
1765 lsp
->hdr
.seqno
, lsp
->hdr
.checksum
,
1766 lsp
->hdr
.rem_lifetime
, refresh_time
);
1772 static int lsp_regenerate_pseudo(struct isis_circuit
*circuit
, int level
)
1774 struct lspdb_head
*head
= &circuit
->area
->lspdb
[level
- 1];
1775 struct isis_lsp
*lsp
;
1776 uint8_t lsp_id
[ISIS_SYS_ID_LEN
+ 2];
1777 uint16_t rem_lifetime
, refresh_time
;
1779 if ((circuit
->is_type
& level
) != level
1780 || (circuit
->state
!= C_STATE_UP
)
1781 || (circuit
->circ_type
!= CIRCUIT_T_BROADCAST
)
1782 || (circuit
->u
.bc
.is_dr
[level
- 1] == 0))
1785 memcpy(lsp_id
, circuit
->isis
->sysid
, ISIS_SYS_ID_LEN
);
1786 LSP_PSEUDO_ID(lsp_id
) = circuit
->circuit_id
;
1787 LSP_FRAGMENT(lsp_id
) = 0;
1789 lsp
= lsp_search(head
, lsp_id
);
1792 flog_err(EC_LIB_DEVELOPMENT
,
1793 "lsp_regenerate_pseudo: no l%d LSP %s found!", level
,
1794 rawlspid_print(lsp_id
));
1798 rem_lifetime
= lsp_rem_lifetime(circuit
->area
, level
);
1799 lsp
->hdr
.rem_lifetime
= rem_lifetime
;
1800 lsp_build_pseudo(lsp
, circuit
, level
);
1801 lsp_inc_seqno(lsp
, 0);
1802 lsp
->last_generated
= time(NULL
);
1803 lsp_flood(lsp
, NULL
);
1805 refresh_time
= lsp_refresh_time(lsp
, rem_lifetime
);
1806 if (level
== IS_LEVEL_1
)
1808 master
, lsp_l1_refresh_pseudo
, circuit
, refresh_time
,
1809 &circuit
->u
.bc
.t_refresh_pseudo_lsp
[level
- 1]);
1810 else if (level
== IS_LEVEL_2
)
1812 master
, lsp_l2_refresh_pseudo
, circuit
, refresh_time
,
1813 &circuit
->u
.bc
.t_refresh_pseudo_lsp
[level
- 1]);
1815 if (IS_DEBUG_UPDATE_PACKETS
) {
1817 "ISIS-Upd (%s): Refreshed L%d Pseudo LSP %s, len %hu, seq 0x%08x, cksum 0x%04hx, lifetime %hus, refresh %hus",
1818 circuit
->area
->area_tag
, level
,
1819 rawlspid_print(lsp
->hdr
.lsp_id
), lsp
->hdr
.pdu_len
,
1820 lsp
->hdr
.seqno
, lsp
->hdr
.checksum
,
1821 lsp
->hdr
.rem_lifetime
, refresh_time
);
1828 * Something has changed or periodic refresh -> regenerate pseudo LSP
1830 static int lsp_l1_refresh_pseudo(struct thread
*thread
)
1832 struct isis_circuit
*circuit
;
1833 uint8_t id
[ISIS_SYS_ID_LEN
+ 2];
1835 circuit
= THREAD_ARG(thread
);
1837 circuit
->u
.bc
.t_refresh_pseudo_lsp
[0] = NULL
;
1838 circuit
->lsp_regenerate_pending
[0] = 0;
1840 if ((circuit
->u
.bc
.is_dr
[0] == 0)
1841 || (circuit
->is_type
& IS_LEVEL_1
) == 0) {
1842 memcpy(id
, circuit
->isis
->sysid
, ISIS_SYS_ID_LEN
);
1843 LSP_PSEUDO_ID(id
) = circuit
->circuit_id
;
1844 LSP_FRAGMENT(id
) = 0;
1845 lsp_purge_pseudo(id
, circuit
, IS_LEVEL_1
);
1849 return lsp_regenerate_pseudo(circuit
, IS_LEVEL_1
);
1852 static int lsp_l2_refresh_pseudo(struct thread
*thread
)
1854 struct isis_circuit
*circuit
;
1855 uint8_t id
[ISIS_SYS_ID_LEN
+ 2];
1857 circuit
= THREAD_ARG(thread
);
1859 circuit
->u
.bc
.t_refresh_pseudo_lsp
[1] = NULL
;
1860 circuit
->lsp_regenerate_pending
[1] = 0;
1862 if ((circuit
->u
.bc
.is_dr
[1] == 0)
1863 || (circuit
->is_type
& IS_LEVEL_2
) == 0) {
1864 memcpy(id
, circuit
->isis
->sysid
, ISIS_SYS_ID_LEN
);
1865 LSP_PSEUDO_ID(id
) = circuit
->circuit_id
;
1866 LSP_FRAGMENT(id
) = 0;
1867 lsp_purge_pseudo(id
, circuit
, IS_LEVEL_2
);
1871 return lsp_regenerate_pseudo(circuit
, IS_LEVEL_2
);
1874 int lsp_regenerate_schedule_pseudo(struct isis_circuit
*circuit
, int level
)
1876 struct isis_lsp
*lsp
;
1877 uint8_t lsp_id
[ISIS_SYS_ID_LEN
+ 2];
1881 struct isis_area
*area
= circuit
->area
;
1883 if (circuit
->circ_type
!= CIRCUIT_T_BROADCAST
1884 || circuit
->state
!= C_STATE_UP
)
1888 "ISIS (%s): Scheduling regeneration of %s pseudo LSP for interface %s",
1889 area
->area_tag
, circuit_t2string(level
),
1890 circuit
->interface
->name
);
1892 memcpy(lsp_id
, area
->isis
->sysid
, ISIS_SYS_ID_LEN
);
1893 LSP_PSEUDO_ID(lsp_id
) = circuit
->circuit_id
;
1894 LSP_FRAGMENT(lsp_id
) = 0;
1897 for (lvl
= IS_LEVEL_1
; lvl
<= IS_LEVEL_2
; lvl
++) {
1899 "ISIS (%s): Checking whether L%d pseudo LSP needs to be scheduled",
1900 area
->area_tag
, lvl
);
1902 if (!((level
& lvl
) && (circuit
->is_type
& lvl
))) {
1903 sched_debug("ISIS (%s): Level is not active on circuit",
1908 if (circuit
->u
.bc
.is_dr
[lvl
- 1] == 0) {
1910 "ISIS (%s): This IS is not DR, nothing to do.",
1915 if (circuit
->lsp_regenerate_pending
[lvl
- 1]) {
1916 struct timeval remain
= thread_timer_remain(
1917 circuit
->u
.bc
.t_refresh_pseudo_lsp
[lvl
- 1]);
1919 "ISIS (%s): Regenerate is already pending, nothing todo. (Due in %lld.%03lld seconds)",
1920 area
->area_tag
, (long long)remain
.tv_sec
,
1921 (long long)remain
.tv_usec
/ 1000);
1925 lsp
= lsp_search(&circuit
->area
->lspdb
[lvl
- 1], lsp_id
);
1928 "ISIS (%s): Pseudonode LSP does not exist yet, nothing to regenerate.",
1934 * Throttle avoidance
1937 "ISIS (%s): Will schedule PSN regen timer. Last run was: %lld, Now is: %lld",
1938 area
->area_tag
, (long long)lsp
->last_generated
,
1940 thread_cancel(&circuit
->u
.bc
.t_refresh_pseudo_lsp
[lvl
- 1]);
1941 diff
= now
- lsp
->last_generated
;
1942 if (diff
< circuit
->area
->lsp_gen_interval
[lvl
- 1]) {
1944 1000 * (circuit
->area
->lsp_gen_interval
[lvl
- 1]
1947 "ISIS (%s): Sechduling in %ld ms to match configured lsp_gen_interval",
1948 area
->area_tag
, timeout
);
1952 "ISIS (%s): Last generation was more than lsp_gen_interval ago. Scheduling for execution in %ld ms.",
1953 area
->area_tag
, timeout
);
1956 circuit
->lsp_regenerate_pending
[lvl
- 1] = 1;
1958 if (lvl
== IS_LEVEL_1
) {
1959 thread_add_timer_msec(
1960 master
, lsp_l1_refresh_pseudo
, circuit
, timeout
,
1961 &circuit
->u
.bc
.t_refresh_pseudo_lsp
[lvl
- 1]);
1962 } else if (lvl
== IS_LEVEL_2
) {
1963 thread_add_timer_msec(
1964 master
, lsp_l2_refresh_pseudo
, circuit
, timeout
,
1965 &circuit
->u
.bc
.t_refresh_pseudo_lsp
[lvl
- 1]);
1973 * Walk through LSPs for an area
1974 * - set remaining lifetime
1976 int lsp_tick(struct thread
*thread
)
1978 struct isis_area
*area
;
1979 struct isis_lsp
*lsp
;
1981 uint16_t rem_lifetime
;
1982 bool fabricd_sync_incomplete
= false;
1984 area
= THREAD_ARG(thread
);
1986 area
->t_tick
= NULL
;
1987 thread_add_timer(master
, lsp_tick
, area
, 1, &area
->t_tick
);
1989 struct isis_circuit
*fabricd_init_c
= fabricd_initial_sync_circuit(area
);
1992 * Remove LSPs which have aged out
1994 for (level
= 0; level
< ISIS_LEVELS
; level
++) {
1995 struct isis_lsp
*next
= lspdb_first(&area
->lspdb
[level
]);
1996 frr_each_from (lspdb
, &area
->lspdb
[level
], lsp
, next
) {
1998 * The lsp rem_lifetime is kept at 0 for MaxAge
2000 * ZeroAgeLifetime depending on explicit purge
2002 * natural age out. So schedule spf only once
2004 * the first time rem_lifetime becomes 0.
2006 rem_lifetime
= lsp
->hdr
.rem_lifetime
;
2010 * Schedule may run spf which should be done
2012 * the lsp rem_lifetime becomes 0 for the first
2014 * ISO 10589 - 7.3.16.4 first paragraph.
2016 if (rem_lifetime
== 1 && lsp
->hdr
.seqno
!= 0) {
2017 /* 7.3.16.4 a) set SRM flags on all */
2018 /* 7.3.16.4 b) retain only the header */
2019 if (lsp
->area
->purge_originator
)
2020 lsp_purge(lsp
, lsp
->level
, NULL
);
2022 lsp_flood(lsp
, NULL
);
2023 /* 7.3.16.4 c) record the time to purge
2025 isis_spf_schedule(lsp
->area
, lsp
->level
);
2026 isis_te_lsp_event(lsp
, LSP_TICK
);
2029 if (lsp
->age_out
== 0) {
2031 "ISIS-Upd (%s): L%u LSP %s seq 0x%08x aged out",
2032 area
->area_tag
, lsp
->level
,
2033 rawlspid_print(lsp
->hdr
.lsp_id
),
2036 /* if we're aging out fragment 0, lsp_destroy()
2037 * below will delete all other fragments too,
2038 * so we need to skip over those
2040 if (!LSP_FRAGMENT(lsp
->hdr
.lsp_id
))
2042 !memcmp(next
->hdr
.lsp_id
,
2044 ISIS_SYS_ID_LEN
+ 1))
2046 &area
->lspdb
[level
],
2049 lspdb_del(&area
->lspdb
[level
], lsp
);
2054 if (fabricd_init_c
&& lsp
) {
2055 fabricd_sync_incomplete
|=
2056 ISIS_CHECK_FLAG(lsp
->SSNflags
,
2063 && !fabricd_sync_incomplete
2064 && !isis_tx_queue_len(fabricd_init_c
->tx_queue
)) {
2065 fabricd_initial_sync_finish(area
);
2071 void lsp_purge_pseudo(uint8_t *id
, struct isis_circuit
*circuit
, int level
)
2073 struct isis_lsp
*lsp
;
2075 lsp
= lsp_search(&circuit
->area
->lspdb
[level
- 1], id
);
2079 lsp_purge(lsp
, level
, NULL
);
2083 * Purge own LSP that is received and we don't have.
2084 * -> Do as in 7.3.16.4
2086 void lsp_purge_non_exist(int level
, struct isis_lsp_hdr
*hdr
,
2087 struct isis_area
*area
)
2089 struct isis_lsp
*lsp
;
2092 * We need to create the LSP to be purged
2094 lsp
= XCALLOC(MTYPE_ISIS_LSP
, sizeof(struct isis_lsp
));
2097 lsp_adjust_stream(lsp
);
2098 lsp
->age_out
= ZERO_AGE_LIFETIME
;
2099 lsp
->area
->lsp_purge_count
[level
- 1]++;
2101 memcpy(&lsp
->hdr
, hdr
, sizeof(lsp
->hdr
));
2102 lsp
->hdr
.rem_lifetime
= 0;
2104 lsp_purge_add_poi(lsp
, NULL
);
2108 lsp_insert(&area
->lspdb
[lsp
->level
- 1], lsp
);
2109 lsp_flood(lsp
, NULL
);
2114 void lsp_set_all_srmflags(struct isis_lsp
*lsp
, bool set
)
2116 struct listnode
*node
;
2117 struct isis_circuit
*circuit
;
2124 struct list
*circuit_list
= lsp
->area
->circuit_list
;
2125 for (ALL_LIST_ELEMENTS_RO(circuit_list
, node
, circuit
)) {
2127 isis_tx_queue_add(circuit
->tx_queue
, lsp
,
2130 isis_tx_queue_del(circuit
->tx_queue
, lsp
);
2135 void _lsp_flood(struct isis_lsp
*lsp
, struct isis_circuit
*circuit
,
2136 const char *func
, const char *file
, int line
)
2138 if (IS_DEBUG_FLOODING
) {
2139 zlog_debug("Flooding LSP %s%s%s (From %s %s:%d)",
2140 rawlspid_print(lsp
->hdr
.lsp_id
),
2141 circuit
? " except on " : "",
2142 circuit
? circuit
->interface
->name
: "",
2147 lsp_set_all_srmflags(lsp
, true);
2149 fabricd_lsp_flood(lsp
, circuit
);
2152 isis_tx_queue_del(circuit
->tx_queue
, lsp
);
2155 static int lsp_handle_adj_state_change(struct isis_adjacency
*adj
)
2157 lsp_regenerate_schedule(adj
->circuit
->area
, IS_LEVEL_1
| IS_LEVEL_2
, 0);
2159 /* when an adjacency state changes determine if we need to
2160 * change attach_bits in other area's LSPs
2162 isis_reset_attach_bit(adj
);
2168 * Iterate over all IP reachability TLVs in a LSP (all fragments) of the given
2169 * address-family and MT-ID.
2171 int isis_lsp_iterate_ip_reach(struct isis_lsp
*lsp
, int family
, uint16_t mtid
,
2172 lsp_ip_reach_iter_cb cb
, void *arg
)
2174 bool pseudo_lsp
= LSP_PSEUDO_ID(lsp
->hdr
.lsp_id
);
2175 struct isis_lsp
*frag
;
2176 struct listnode
*node
;
2178 if (lsp
->hdr
.seqno
== 0 || lsp
->hdr
.rem_lifetime
== 0)
2179 return LSP_ITER_CONTINUE
;
2183 if (!fabricd
&& !pseudo_lsp
&& family
== AF_INET
2184 && mtid
== ISIS_MT_IPV4_UNICAST
) {
2185 struct isis_item_list
*reachs
[] = {
2186 &lsp
->tlvs
->oldstyle_ip_reach
,
2187 &lsp
->tlvs
->oldstyle_ip_reach_ext
};
2189 for (unsigned int i
= 0; i
< array_size(reachs
); i
++) {
2190 struct isis_oldstyle_ip_reach
*r
;
2192 for (r
= (struct isis_oldstyle_ip_reach
*)
2196 bool external
= i
? true : false;
2198 if ((*cb
)((struct prefix
*)&r
->prefix
,
2199 r
->metric
, external
, NULL
,
2202 return LSP_ITER_STOP
;
2207 if (!pseudo_lsp
&& family
== AF_INET
) {
2208 struct isis_item_list
*ipv4_reachs
;
2210 if (mtid
== ISIS_MT_IPV4_UNICAST
)
2211 ipv4_reachs
= &lsp
->tlvs
->extended_ip_reach
;
2213 ipv4_reachs
= isis_lookup_mt_items(
2214 &lsp
->tlvs
->mt_ip_reach
, mtid
);
2216 struct isis_extended_ip_reach
*r
;
2217 for (r
= ipv4_reachs
? (struct isis_extended_ip_reach
*)
2221 if ((*cb
)((struct prefix
*)&r
->prefix
,
2222 r
->metric
, false, r
->subtlvs
, arg
)
2224 return LSP_ITER_STOP
;
2228 if (!pseudo_lsp
&& family
== AF_INET6
) {
2229 struct isis_item_list
*ipv6_reachs
;
2230 struct isis_ipv6_reach
*r
;
2232 if (mtid
== ISIS_MT_IPV4_UNICAST
)
2233 ipv6_reachs
= &lsp
->tlvs
->ipv6_reach
;
2235 ipv6_reachs
= isis_lookup_mt_items(
2236 &lsp
->tlvs
->mt_ipv6_reach
, mtid
);
2238 for (r
= ipv6_reachs
? (struct isis_ipv6_reach
*)
2242 if ((*cb
)((struct prefix
*)&r
->prefix
,
2243 r
->metric
, r
->external
, r
->subtlvs
,
2246 return LSP_ITER_STOP
;
2251 /* Parse LSP fragments if it is not a fragment itself */
2252 if (!LSP_FRAGMENT(lsp
->hdr
.lsp_id
))
2253 for (ALL_LIST_ELEMENTS_RO(lsp
->lspu
.frags
, node
, frag
)) {
2257 if (isis_lsp_iterate_ip_reach(frag
, family
, mtid
, cb
,
2260 return LSP_ITER_STOP
;
2263 return LSP_ITER_CONTINUE
;
2267 * Iterate over all IS reachability TLVs in a LSP (all fragments) of the given
2270 int isis_lsp_iterate_is_reach(struct isis_lsp
*lsp
, uint16_t mtid
,
2271 lsp_is_reach_iter_cb cb
, void *arg
)
2273 bool pseudo_lsp
= LSP_PSEUDO_ID(lsp
->hdr
.lsp_id
);
2274 struct isis_lsp
*frag
;
2275 struct listnode
*node
;
2276 struct isis_item
*head
;
2277 struct isis_item_list
*te_neighs
;
2279 if (lsp
->hdr
.seqno
== 0 || lsp
->hdr
.rem_lifetime
== 0)
2280 return LSP_ITER_CONTINUE
;
2284 if (pseudo_lsp
|| mtid
== ISIS_MT_IPV4_UNICAST
) {
2285 head
= lsp
->tlvs
->oldstyle_reach
.head
;
2286 for (struct isis_oldstyle_reach
*reach
=
2287 (struct isis_oldstyle_reach
*)head
;
2288 reach
; reach
= reach
->next
) {
2289 if ((*cb
)(reach
->id
, reach
->metric
, true, NULL
,
2292 return LSP_ITER_STOP
;
2296 if (pseudo_lsp
|| mtid
== ISIS_MT_IPV4_UNICAST
)
2297 te_neighs
= &lsp
->tlvs
->extended_reach
;
2300 isis_get_mt_items(&lsp
->tlvs
->mt_reach
, mtid
);
2302 head
= te_neighs
->head
;
2303 for (struct isis_extended_reach
*reach
=
2304 (struct isis_extended_reach
*)head
;
2305 reach
; reach
= reach
->next
) {
2306 if ((*cb
)(reach
->id
, reach
->metric
, false,
2307 reach
->subtlvs
, arg
)
2309 return LSP_ITER_STOP
;
2314 /* Parse LSP fragments if it not a fragment itself. */
2315 if (!LSP_FRAGMENT(lsp
->hdr
.lsp_id
))
2316 for (ALL_LIST_ELEMENTS_RO(lsp
->lspu
.frags
, node
, frag
)) {
2320 if (isis_lsp_iterate_is_reach(frag
, mtid
, cb
, arg
)
2322 return LSP_ITER_STOP
;
2325 return LSP_ITER_CONTINUE
;
2330 hook_register(isis_adj_state_change_hook
,
2331 lsp_handle_adj_state_change
);