1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * OSPF Link State Advertisement
4 * Copyright (C) 1999, 2000 Toshiaki Takada
19 #include "sockunion.h" /* for inet_aton() */
23 #include "ospfd/ospfd.h"
24 #include "ospfd/ospf_interface.h"
25 #include "ospfd/ospf_ism.h"
26 #include "ospfd/ospf_asbr.h"
27 #include "ospfd/ospf_lsa.h"
28 #include "ospfd/ospf_lsdb.h"
29 #include "ospfd/ospf_neighbor.h"
30 #include "ospfd/ospf_nsm.h"
31 #include "ospfd/ospf_flood.h"
32 #include "ospfd/ospf_packet.h"
33 #include "ospfd/ospf_spf.h"
34 #include "ospfd/ospf_dump.h"
35 #include "ospfd/ospf_route.h"
36 #include "ospfd/ospf_ase.h"
37 #include "ospfd/ospf_zebra.h"
38 #include "ospfd/ospf_abr.h"
39 #include "ospfd/ospf_errors.h"
41 static struct ospf_lsa
*ospf_handle_summarylsa_lsId_chg(struct ospf
*ospf
,
42 struct prefix_ipv4
*p
,
45 struct in_addr old_id
);
46 static struct ospf_lsa
*
47 ospf_summary_lsa_prepare_and_flood(struct prefix_ipv4
*p
, uint32_t metric
,
48 struct ospf_area
*area
, struct in_addr id
);
49 static struct ospf_lsa
*ospf_summary_lsa_refresh(struct ospf
*ospf
,
50 struct ospf_lsa
*lsa
);
51 static struct ospf_lsa
*
52 ospf_asbr_summary_lsa_prepare_and_flood(struct prefix_ipv4
*p
, uint32_t metric
,
53 struct ospf_area
*area
,
55 static struct ospf_lsa
*ospf_summary_asbr_lsa_refresh(struct ospf
*ospf
,
56 struct ospf_lsa
*lsa
);
57 static struct ospf_lsa
*ospf_handle_exnl_lsa_lsId_chg(struct ospf
*ospf
,
58 struct external_info
*ei
,
60 static struct ospf_lsa
*
61 ospf_exnl_lsa_prepare_and_flood(struct ospf
*ospf
, struct external_info
*ei
,
64 uint32_t get_metric(uint8_t *metric
)
68 m
= (m
<< 8) + metric
[1];
69 m
= (m
<< 8) + metric
[2];
73 /** @brief The Function checks self generated DoNotAge.
75 * @return true or false.
77 bool ospf_check_dna_lsa(const struct ospf_lsa
*lsa
)
79 return ((IS_LSA_SELF(lsa
) && CHECK_FLAG(lsa
->data
->ls_age
, DO_NOT_AGE
))
84 struct timeval
int2tv(int a
)
94 struct timeval
msec2tv(int a
)
98 ret
.tv_sec
= a
/ 1000;
99 ret
.tv_usec
= (a
% 1000) * 1000;
104 int ospf_lsa_refresh_delay(struct ospf_lsa
*lsa
)
106 struct timeval delta
;
109 if (monotime_since(&lsa
->tv_orig
, &delta
)
110 < OSPF_MIN_LS_INTERVAL
* 1000LL) {
111 struct timeval minv
= msec2tv(OSPF_MIN_LS_INTERVAL
);
112 timersub(&minv
, &delta
, &minv
);
114 /* TBD: remove padding to full sec, return timeval instead */
115 delay
= minv
.tv_sec
+ !!minv
.tv_usec
;
117 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
119 "LSA[Type%d:%pI4]: Refresh timer delay %d seconds",
120 lsa
->data
->type
, &lsa
->data
->id
,
130 int get_age(struct ospf_lsa
*lsa
)
134 /* As per rfc4136, the self-originated LSAs in their
135 * own database keep aging, however rfc doesn't tell
136 * till how long the LSA should be aged, as of now
137 * we are capping it for OSPF_LSA_MAXAGE.
140 /* If LSA is marked as donotage */
141 if (CHECK_FLAG(lsa
->data
->ls_age
, DO_NOT_AGE
) && !IS_LSA_SELF(lsa
))
142 return ntohs(lsa
->data
->ls_age
);
144 monotime_since(&lsa
->tv_recv
, &rel
);
145 return ntohs(lsa
->data
->ls_age
) + rel
.tv_sec
;
149 /* Fletcher Checksum -- Refer to RFC1008. */
151 /* All the offsets are zero-based. The offsets in the RFC1008 are
153 uint16_t ospf_lsa_checksum(struct lsa_header
*lsa
)
155 uint8_t *buffer
= &lsa
->options
;
156 int options_offset
= buffer
- (uint8_t *)&lsa
->ls_age
; /* should be 2 */
158 /* Skip the AGE field */
159 uint16_t len
= ntohs(lsa
->length
) - options_offset
;
161 /* Checksum offset starts from "options" field, not the beginning of the
162 lsa_header struct. The offset is 14, rather than 16. */
163 int checksum_offset
= (uint8_t *)&lsa
->checksum
- buffer
;
165 return fletcher_checksum(buffer
, len
, checksum_offset
);
168 int ospf_lsa_checksum_valid(struct lsa_header
*lsa
)
170 uint8_t *buffer
= &lsa
->options
;
171 int options_offset
= buffer
- (uint8_t *)&lsa
->ls_age
; /* should be 2 */
173 /* Skip the AGE field */
174 uint16_t len
= ntohs(lsa
->length
) - options_offset
;
176 return (fletcher_checksum(buffer
, len
, FLETCHER_CHECKSUM_VALIDATE
)
181 /* Create OSPF LSA. */
182 struct ospf_lsa
*ospf_lsa_new(void)
184 struct ospf_lsa
*new;
186 new = XCALLOC(MTYPE_OSPF_LSA
, sizeof(struct ospf_lsa
));
190 new->retransmit_counter
= 0;
191 monotime(&new->tv_recv
);
192 new->tv_orig
= new->tv_recv
;
193 new->refresh_list
= -1;
194 new->vrf_id
= VRF_DEFAULT
;
195 new->to_be_acknowledged
= 0;
196 new->opaque_zero_len_delete
= 0;
201 struct ospf_lsa
*ospf_lsa_new_and_data(size_t size
)
203 struct ospf_lsa
*new;
205 new = ospf_lsa_new();
206 new->data
= ospf_lsa_data_new(size
);
212 /* Duplicate OSPF LSA. */
213 struct ospf_lsa
*ospf_lsa_dup(struct ospf_lsa
*lsa
)
215 struct ospf_lsa
*new;
220 new = XCALLOC(MTYPE_OSPF_LSA
, sizeof(struct ospf_lsa
));
222 memcpy(new, lsa
, sizeof(struct ospf_lsa
));
223 UNSET_FLAG(new->flags
, OSPF_LSA_DISCARD
);
225 new->retransmit_counter
= 0;
226 new->data
= ospf_lsa_data_dup(lsa
->data
);
228 /* kevinm: Clear the refresh_list, otherwise there are going
229 to be problems when we try to remove the LSA from the
230 queue (which it's not a member of.)
231 XXX: Should we add the LSA to the refresh_list queue? */
232 new->refresh_list
= -1;
234 if (IS_DEBUG_OSPF(lsa
, LSA
))
235 zlog_debug("LSA: duplicated %p (new: %p)", (void *)lsa
,
242 void ospf_lsa_free(struct ospf_lsa
*lsa
)
244 assert(lsa
->lock
== 0);
246 if (IS_DEBUG_OSPF(lsa
, LSA
))
247 zlog_debug("LSA: freed %p", (void *)lsa
);
249 /* Delete LSA data. */
250 if (lsa
->data
!= NULL
)
251 ospf_lsa_data_free(lsa
->data
);
253 assert(lsa
->refresh_list
< 0);
255 memset(lsa
, 0, sizeof(struct ospf_lsa
));
256 XFREE(MTYPE_OSPF_LSA
, lsa
);
260 struct ospf_lsa
*ospf_lsa_lock(struct ospf_lsa
*lsa
)
267 void ospf_lsa_unlock(struct ospf_lsa
**lsa
)
269 /* This is sanity check. */
275 assert((*lsa
)->lock
>= 0);
277 if ((*lsa
)->lock
== 0) {
278 assert(CHECK_FLAG((*lsa
)->flags
, OSPF_LSA_DISCARD
));
284 /* Check discard flag. */
285 void ospf_lsa_discard(struct ospf_lsa
*lsa
)
287 if (!CHECK_FLAG(lsa
->flags
, OSPF_LSA_DISCARD
)) {
288 SET_FLAG(lsa
->flags
, OSPF_LSA_DISCARD
);
289 ospf_lsa_unlock(&lsa
);
293 /* Create LSA data. */
294 struct lsa_header
*ospf_lsa_data_new(size_t size
)
296 return XCALLOC(MTYPE_OSPF_LSA_DATA
, size
);
299 /* Duplicate LSA data. */
300 struct lsa_header
*ospf_lsa_data_dup(struct lsa_header
*lsah
)
302 struct lsa_header
*new;
304 new = ospf_lsa_data_new(ntohs(lsah
->length
));
305 memcpy(new, lsah
, ntohs(lsah
->length
));
311 void ospf_lsa_data_free(struct lsa_header
*lsah
)
313 if (IS_DEBUG_OSPF(lsa
, LSA
))
314 zlog_debug("LSA[Type%d:%pI4]: data freed %p", lsah
->type
,
315 &lsah
->id
, (void *)lsah
);
317 XFREE(MTYPE_OSPF_LSA_DATA
, lsah
);
321 /* LSA general functions. */
323 const char *dump_lsa_key(struct ospf_lsa
*lsa
)
325 static char buf
[sizeof("Type255,id(255.255.255.255),ar(255.255.255.255)")+1];
326 struct lsa_header
*lsah
;
328 if (lsa
!= NULL
&& (lsah
= lsa
->data
) != NULL
) {
329 char id
[INET_ADDRSTRLEN
], ar
[INET_ADDRSTRLEN
];
330 inet_ntop(AF_INET
, &lsah
->id
, id
, sizeof(id
));
331 inet_ntop(AF_INET
, &lsah
->adv_router
, ar
, sizeof(ar
));
333 snprintf(buf
, sizeof(buf
), "Type%d,id(%s),ar(%s)", lsah
->type
,
336 strlcpy(buf
, "NULL", sizeof(buf
));
341 uint32_t lsa_seqnum_increment(struct ospf_lsa
*lsa
)
345 seqnum
= ntohl(lsa
->data
->ls_seqnum
) + 1;
347 return htonl(seqnum
);
350 void lsa_header_set(struct stream
*s
, uint8_t options
, uint8_t type
,
351 struct in_addr id
, struct in_addr router_id
)
353 struct lsa_header
*lsah
;
355 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
357 lsah
->ls_age
= htons(OSPF_LSA_INITIAL_AGE
);
358 lsah
->options
= options
;
361 lsah
->adv_router
= router_id
;
362 lsah
->ls_seqnum
= htonl(OSPF_INITIAL_SEQUENCE_NUMBER
);
364 stream_forward_endp(s
, OSPF_LSA_HEADER_SIZE
);
368 /* router-LSA related functions. */
369 /* Get router-LSA flags. */
370 uint8_t router_lsa_flags(struct ospf_area
*area
)
374 flags
= area
->ospf
->flags
;
376 /* Set virtual link flag. */
377 if (ospf_full_virtual_nbrs(area
))
378 SET_FLAG(flags
, ROUTER_LSA_VIRTUAL
);
380 /* Just sanity check */
381 UNSET_FLAG(flags
, ROUTER_LSA_VIRTUAL
);
383 /* Set Shortcut ABR behabiour flag. */
384 UNSET_FLAG(flags
, ROUTER_LSA_SHORTCUT
);
385 if (area
->ospf
->abr_type
== OSPF_ABR_SHORTCUT
)
386 if (!OSPF_IS_AREA_BACKBONE(area
))
387 if ((area
->shortcut_configured
== OSPF_SHORTCUT_DEFAULT
388 && area
->ospf
->backbone
== NULL
)
389 || area
->shortcut_configured
390 == OSPF_SHORTCUT_ENABLE
)
391 SET_FLAG(flags
, ROUTER_LSA_SHORTCUT
);
393 /* ASBR can't exit in stub area. */
394 if (area
->external_routing
== OSPF_AREA_STUB
)
395 UNSET_FLAG(flags
, ROUTER_LSA_EXTERNAL
);
396 /* If ASBR set External flag */
397 else if (IS_OSPF_ASBR(area
->ospf
))
398 SET_FLAG(flags
, ROUTER_LSA_EXTERNAL
);
400 /* Set ABR dependent flags */
401 if (IS_OSPF_ABR(area
->ospf
)) {
402 SET_FLAG(flags
, ROUTER_LSA_BORDER
);
403 /* If Area is NSSA and we are both ABR and unconditional
405 * set Nt bit to inform other routers.
407 if ((area
->external_routing
== OSPF_AREA_NSSA
)
408 && (area
->NSSATranslatorRole
== OSPF_NSSA_ROLE_ALWAYS
))
409 SET_FLAG(flags
, ROUTER_LSA_NT
);
414 /* Lookup neighbor other than myself.
415 And check neighbor count,
416 Point-to-Point link must have only 1 neighbor. */
417 struct ospf_neighbor
*ospf_nbr_lookup_ptop(struct ospf_interface
*oi
)
419 struct ospf_neighbor
*nbr
= NULL
;
420 struct route_node
*rn
;
422 /* Search neighbor, there must be one of two nbrs. */
423 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
424 if ((nbr
= rn
->info
))
425 if (!IPV4_ADDR_SAME(&nbr
->router_id
,
426 &oi
->ospf
->router_id
))
427 if (nbr
->state
== NSM_Full
) {
428 route_unlock_node(rn
);
432 /* PtoP link must have only 1 neighbor. */
433 if (ospf_nbr_count(oi
, 0) > 1)
435 EC_OSPF_PTP_NEIGHBOR
,
436 "Point-to-Point link on interface %s has more than 1 neighbor.",
442 /* Determine cost of link, taking RFC3137 stub-router support into
445 static uint16_t ospf_link_cost(struct ospf_interface
*oi
)
447 /* RFC3137 stub router support */
448 if (!CHECK_FLAG(oi
->area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
))
449 return oi
->output_cost
;
451 return OSPF_OUTPUT_COST_INFINITE
;
454 /* Set a link information. */
455 char link_info_set(struct stream
**s
, struct in_addr id
, struct in_addr data
,
456 uint8_t type
, uint8_t tos
, uint16_t cost
)
458 /* LSA stream is initially allocated to OSPF_MAX_LSA_SIZE, suits
459 * vast majority of cases. Some rare routers with lots of links need
461 * we try accommodate those here.
463 if (STREAM_WRITEABLE(*s
) < OSPF_ROUTER_LSA_LINK_SIZE
) {
464 size_t ret
= OSPF_MAX_LSA_SIZE
;
466 /* Can we enlarge the stream still? */
467 if (STREAM_SIZE(*s
) == OSPF_MAX_LSA_SIZE
) {
468 /* we futz the size here for simplicity, really we need
471 * IP Header - (sizeof(struct ip))
472 * OSPF Header - OSPF_HEADER_SIZE
473 * LSA Header - OSPF_LSA_HEADER_SIZE
474 * MD5 auth data, if MD5 is configured -
475 * OSPF_AUTH_MD5_SIZE.
477 * Simpler just to subtract OSPF_MAX_LSA_SIZE though.
479 ret
= stream_resize_inplace(
480 s
, OSPF_MAX_PACKET_SIZE
- OSPF_MAX_LSA_SIZE
);
483 if (ret
== OSPF_MAX_LSA_SIZE
) {
486 "%s: Out of space in LSA stream, left %zd, size %zd",
487 __func__
, STREAM_WRITEABLE(*s
),
493 /* TOS based routing is not supported. */
494 stream_put_ipv4(*s
, id
.s_addr
); /* Link ID. */
495 stream_put_ipv4(*s
, data
.s_addr
); /* Link Data. */
496 stream_putc(*s
, type
); /* Link Type. */
497 stream_putc(*s
, tos
); /* TOS = 0. */
498 stream_putw(*s
, cost
); /* Link Cost. */
503 /* Describe Point-to-Point link (Section 12.4.1.1). */
505 /* Note: If the interface is configured as point-to-point dmvpn then the other
506 * end of link is dmvpn hub with point-to-multipoint ospf network type. The
507 * hub then expects this router to populate the stub network and also Link Data
508 * Field set to IP Address and not MIB-II ifIndex
510 static int lsa_link_ptop_set(struct stream
**s
, struct ospf_interface
*oi
)
513 struct ospf_neighbor
*nbr
;
514 struct in_addr id
, mask
, data
;
515 uint16_t cost
= ospf_link_cost(oi
);
517 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
518 zlog_debug("LSA[Type1]: Set link Point-to-Point");
520 if ((nbr
= ospf_nbr_lookup_ptop(oi
)))
521 if (nbr
->state
== NSM_Full
) {
522 if (CHECK_FLAG(oi
->connected
->flags
,
523 ZEBRA_IFA_UNNUMBERED
)
525 /* For unnumbered point-to-point networks, the
527 should specify the interface's MIB-II ifIndex
529 data
.s_addr
= htonl(oi
->ifp
->ifindex
);
530 links
+= link_info_set(
531 s
, nbr
->router_id
, data
,
532 LSA_LINK_TYPE_POINTOPOINT
, 0, cost
);
534 links
+= link_info_set(
536 oi
->address
->u
.prefix4
,
537 LSA_LINK_TYPE_POINTOPOINT
, 0, cost
);
541 /* no need for a stub link for unnumbered interfaces */
543 || !CHECK_FLAG(oi
->connected
->flags
, ZEBRA_IFA_UNNUMBERED
)) {
544 /* Regardless of the state of the neighboring router, we must
545 add a Type 3 link (stub network).
546 N.B. Options 1 & 2 share basically the same logic. */
547 masklen2ip(oi
->address
->prefixlen
, &mask
);
548 id
.s_addr
= CONNECTED_PREFIX(oi
->connected
)->u
.prefix4
.s_addr
550 links
+= link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0,
557 /* Describe Broadcast Link. */
558 static int lsa_link_broadcast_set(struct stream
**s
, struct ospf_interface
*oi
)
560 struct ospf_neighbor
*dr
;
561 struct in_addr id
, mask
;
562 uint16_t cost
= ospf_link_cost(oi
);
564 /* Describe Type 3 Link. */
565 if (oi
->state
== ISM_Waiting
) {
566 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
568 "LSA[Type1]: Interface %s is in state Waiting. Adding stub interface",
570 masklen2ip(oi
->address
->prefixlen
, &mask
);
571 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
& mask
.s_addr
;
572 return link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0,
576 dr
= ospf_nbr_lookup_by_addr(oi
->nbrs
, &DR(oi
));
577 /* Describe Type 2 link. */
578 if (dr
&& (dr
->state
== NSM_Full
579 || IPV4_ADDR_SAME(&oi
->address
->u
.prefix4
, &DR(oi
)))
580 && ospf_nbr_count(oi
, NSM_Full
) > 0) {
581 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
583 "LSA[Type1]: Interface %s has a DR. Adding transit interface",
585 return link_info_set(s
, DR(oi
), oi
->address
->u
.prefix4
,
586 LSA_LINK_TYPE_TRANSIT
, 0, cost
);
588 /* Describe type 3 link. */
590 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
592 "LSA[Type1]: Interface %s has no DR. Adding stub interface",
594 masklen2ip(oi
->address
->prefixlen
, &mask
);
595 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
& mask
.s_addr
;
596 return link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0,
601 static int lsa_link_loopback_set(struct stream
**s
, struct ospf_interface
*oi
)
603 struct in_addr id
, mask
;
605 /* Describe Type 3 Link. */
606 if (oi
->state
!= ISM_Loopback
)
609 mask
.s_addr
= 0xffffffff;
610 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
;
611 return link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0, 0);
614 /* Describe Virtual Link. */
615 static int lsa_link_virtuallink_set(struct stream
**s
,
616 struct ospf_interface
*oi
)
618 struct ospf_neighbor
*nbr
;
619 uint16_t cost
= ospf_link_cost(oi
);
621 if (oi
->state
== ISM_PointToPoint
)
622 if ((nbr
= ospf_nbr_lookup_ptop(oi
)))
623 if (nbr
->state
== NSM_Full
) {
624 return link_info_set(s
, nbr
->router_id
,
625 oi
->address
->u
.prefix4
,
626 LSA_LINK_TYPE_VIRTUALLINK
,
633 #define lsa_link_nbma_set(S,O) lsa_link_broadcast_set (S, O)
635 /* this function add for support point-to-multipoint ,see rfc2328
637 /* from "edward rrr" <edward_rrr@hotmail.com>
638 http://marc.theaimsgroup.com/?l=zebra&m=100739222210507&w=2 */
639 static int lsa_link_ptomp_set(struct stream
**s
, struct ospf_interface
*oi
)
642 struct route_node
*rn
;
643 struct ospf_neighbor
*nbr
= NULL
;
644 struct in_addr id
, mask
;
645 uint16_t cost
= ospf_link_cost(oi
);
647 mask
.s_addr
= 0xffffffff;
648 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
;
649 links
+= link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0, 0);
651 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
652 zlog_debug("PointToMultipoint: running ptomultip_set");
654 /* Search neighbor, */
655 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
656 if ((nbr
= rn
->info
) != NULL
)
658 if (!IPV4_ADDR_SAME(&nbr
->router_id
,
659 &oi
->ospf
->router_id
))
660 if (nbr
->state
== NSM_Full
)
663 links
+= link_info_set(
665 oi
->address
->u
.prefix4
,
666 LSA_LINK_TYPE_POINTOPOINT
, 0,
668 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
670 "PointToMultipoint: set link to %pI4",
671 &oi
->address
->u
.prefix4
);
677 /* Set router-LSA link information. */
678 static int router_lsa_link_set(struct stream
**s
, struct ospf_area
*area
)
680 struct listnode
*node
;
681 struct ospf_interface
*oi
;
684 for (ALL_LIST_ELEMENTS_RO(area
->oiflist
, node
, oi
)) {
685 struct interface
*ifp
= oi
->ifp
;
687 /* Check interface is up, OSPF is enable. */
688 if (if_is_operative(ifp
)) {
689 if (oi
->state
!= ISM_Down
) {
690 oi
->lsa_pos_beg
= links
;
691 /* Describe each link. */
693 case OSPF_IFTYPE_POINTOPOINT
:
694 links
+= lsa_link_ptop_set(s
, oi
);
696 case OSPF_IFTYPE_BROADCAST
:
697 links
+= lsa_link_broadcast_set(s
, oi
);
699 case OSPF_IFTYPE_NBMA
:
700 links
+= lsa_link_nbma_set(s
, oi
);
702 case OSPF_IFTYPE_POINTOMULTIPOINT
:
703 links
+= lsa_link_ptomp_set(s
, oi
);
705 case OSPF_IFTYPE_VIRTUALLINK
:
707 lsa_link_virtuallink_set(s
, oi
);
709 case OSPF_IFTYPE_LOOPBACK
:
710 links
+= lsa_link_loopback_set(s
, oi
);
712 oi
->lsa_pos_end
= links
;
720 /* Set router-LSA body. */
721 void ospf_router_lsa_body_set(struct stream
**s
, struct ospf_area
*area
)
727 stream_putc(*s
, router_lsa_flags(area
));
729 /* Set Zero fields. */
732 /* Keep pointer to # links. */
733 putp
= stream_get_endp(*s
);
738 /* Set all link information. */
739 cnt
= router_lsa_link_set(s
, area
);
741 /* Set # of links here. */
742 stream_putw_at(*s
, putp
, cnt
);
745 static void ospf_stub_router_timer(struct thread
*t
)
747 struct ospf_area
*area
= THREAD_ARG(t
);
749 area
->t_stub_router
= NULL
;
751 SET_FLAG(area
->stub_router_state
, OSPF_AREA_WAS_START_STUB_ROUTED
);
753 /* clear stub route state and generate router-lsa refresh, don't
754 * clobber an administratively set stub-router state though.
756 if (CHECK_FLAG(area
->stub_router_state
, OSPF_AREA_ADMIN_STUB_ROUTED
))
759 UNSET_FLAG(area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
);
761 ospf_router_lsa_update_area(area
);
764 static void ospf_stub_router_check(struct ospf_area
*area
)
766 /* area must either be administratively configured to be stub
767 * or startup-time stub-router must be configured and we must in a
771 if (CHECK_FLAG(area
->stub_router_state
, OSPF_AREA_ADMIN_STUB_ROUTED
)) {
772 SET_FLAG(area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
);
776 /* not admin-stubbed, check whether startup stubbing is configured and
777 * whether it's not been done yet
779 if (CHECK_FLAG(area
->stub_router_state
,
780 OSPF_AREA_WAS_START_STUB_ROUTED
))
783 if (area
->ospf
->stub_router_startup_time
784 == OSPF_STUB_ROUTER_UNCONFIGURED
) {
785 /* stub-router is hence done forever for this area, even if
787 * tries configure it (take effect next restart).
789 SET_FLAG(area
->stub_router_state
,
790 OSPF_AREA_WAS_START_STUB_ROUTED
);
794 /* startup stub-router configured and not yet done */
795 SET_FLAG(area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
);
797 OSPF_AREA_TIMER_ON(area
->t_stub_router
, ospf_stub_router_timer
,
798 area
->ospf
->stub_router_startup_time
);
801 /* Create new router-LSA. */
802 static struct ospf_lsa
*ospf_router_lsa_new(struct ospf_area
*area
)
804 struct ospf
*ospf
= area
->ospf
;
806 struct lsa_header
*lsah
;
807 struct ospf_lsa
*new;
810 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
811 zlog_debug("LSA[Type1]: Create router-LSA instance");
813 /* check whether stub-router is desired, and if this is the first
816 ospf_stub_router_check(area
);
818 /* Create a stream for LSA. */
819 s
= stream_new(OSPF_MAX_LSA_SIZE
);
820 /* Set LSA common header fields. */
821 lsa_header_set(s
, LSA_OPTIONS_GET(area
) | LSA_OPTIONS_NSSA_GET(area
),
822 OSPF_ROUTER_LSA
, ospf
->router_id
, ospf
->router_id
);
824 /* Set router-LSA body fields. */
825 ospf_router_lsa_body_set(&s
, area
);
828 length
= stream_get_endp(s
);
829 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
830 lsah
->length
= htons(length
);
832 /* Now, create OSPF LSA instance. */
833 new = ospf_lsa_new_and_data(length
);
836 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
837 new->vrf_id
= area
->ospf
->vrf_id
;
839 /* Copy LSA data to store, discard stream. */
840 memcpy(new->data
, lsah
, length
);
846 /* Originate Router-LSA. */
847 static struct ospf_lsa
*ospf_router_lsa_originate(struct ospf_area
*area
)
849 struct ospf_lsa
*new;
851 if (area
->ospf
->gr_info
.restart_in_progress
) {
852 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
854 "LSA[Type%d]: Graceful Restart in progress, don't originate",
859 /* Create new router-LSA instance. */
860 if ((new = ospf_router_lsa_new(area
)) == NULL
) {
861 zlog_err("%s: ospf_router_lsa_new returned NULL", __func__
);
866 if (new->data
->adv_router
.s_addr
== INADDR_ANY
) {
867 if (IS_DEBUG_OSPF_EVENT
)
868 zlog_debug("LSA[Type1]: AdvRouter is 0, discard");
869 ospf_lsa_discard(new);
873 /* Install LSA to LSDB. */
874 new = ospf_lsa_install(area
->ospf
, NULL
, new);
876 /* Update LSA origination count. */
877 area
->ospf
->lsa_originate_count
++;
879 /* Flooding new LSA through area. */
880 ospf_flood_through_area(area
, NULL
, new);
882 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
883 zlog_debug("LSA[Type%d:%pI4]: Originate router-LSA %p",
884 new->data
->type
, &new->data
->id
,
886 ospf_lsa_header_dump(new->data
);
892 /* Refresh router-LSA. */
893 static struct ospf_lsa
*ospf_router_lsa_refresh(struct ospf_lsa
*lsa
)
895 struct ospf_area
*area
= lsa
->area
;
896 struct ospf_lsa
*new;
901 /* Delete LSA from neighbor retransmit-list. */
902 ospf_ls_retransmit_delete_nbr_area(area
, lsa
);
904 /* Unregister LSA from refresh-list */
905 ospf_refresher_unregister_lsa(area
->ospf
, lsa
);
907 /* Create new router-LSA instance. */
908 if ((new = ospf_router_lsa_new(area
)) == NULL
) {
909 zlog_err("%s: ospf_router_lsa_new returned NULL", __func__
);
913 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
915 ospf_lsa_install(area
->ospf
, NULL
, new);
917 /* Flood LSA through area. */
918 ospf_flood_through_area(area
, NULL
, new);
921 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
922 zlog_debug("LSA[Type%d:%pI4]: router-LSA refresh",
923 new->data
->type
, &new->data
->id
);
924 ospf_lsa_header_dump(new->data
);
930 int ospf_router_lsa_update_area(struct ospf_area
*area
)
932 if (IS_DEBUG_OSPF_EVENT
)
933 zlog_debug("[router-LSA]: (router-LSA area update)");
935 /* Now refresh router-LSA. */
936 if (area
->router_lsa_self
)
937 ospf_lsa_refresh(area
->ospf
, area
->router_lsa_self
);
938 /* Newly originate router-LSA. */
940 ospf_router_lsa_originate(area
);
945 int ospf_router_lsa_update(struct ospf
*ospf
)
947 struct listnode
*node
, *nnode
;
948 struct ospf_area
*area
;
950 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
951 zlog_debug("Timer[router-LSA Update]: (timer expire)");
953 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
954 struct ospf_lsa
*lsa
= area
->router_lsa_self
;
955 struct router_lsa
*rl
;
956 const char *area_str
;
958 /* Keep Area ID string. */
959 area_str
= AREA_NAME(area
);
961 /* If LSA not exist in this Area, originate new. */
963 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
965 "LSA[Type1]: Create router-LSA for Area %s",
968 ospf_router_lsa_originate(area
);
970 /* If router-ID is changed, Link ID must change.
971 First flush old LSA, then originate new. */
972 else if (!IPV4_ADDR_SAME(&lsa
->data
->id
, &ospf
->router_id
)) {
973 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
975 "LSA[Type%d:%pI4]: Refresh router-LSA for Area %s",
977 &lsa
->data
->id
, area_str
);
978 ospf_refresher_unregister_lsa(ospf
, lsa
);
979 ospf_lsa_flush_area(lsa
, area
);
980 ospf_lsa_unlock(&area
->router_lsa_self
);
981 area
->router_lsa_self
= NULL
;
983 /* Refresh router-LSA, (not install) and flood through
985 ospf_router_lsa_update_area(area
);
987 rl
= (struct router_lsa
*)lsa
->data
;
988 /* Refresh router-LSA, (not install) and flood through
990 if (rl
->flags
!= ospf
->flags
)
991 ospf_router_lsa_update_area(area
);
999 /* network-LSA related functions. */
1000 /* Originate Network-LSA. */
1001 static void ospf_network_lsa_body_set(struct stream
*s
,
1002 struct ospf_interface
*oi
)
1004 struct in_addr mask
;
1005 struct route_node
*rn
;
1006 struct ospf_neighbor
*nbr
;
1008 masklen2ip(oi
->address
->prefixlen
, &mask
);
1009 stream_put_ipv4(s
, mask
.s_addr
);
1011 /* The network-LSA lists those routers that are fully adjacent to
1012 the Designated Router; each fully adjacent router is identified by
1013 its OSPF Router ID. The Designated Router includes itself in this
1014 list. RFC2328, Section 12.4.2 */
1016 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
1017 if ((nbr
= rn
->info
) != NULL
)
1018 if (nbr
->state
== NSM_Full
|| nbr
== oi
->nbr_self
)
1019 stream_put_ipv4(s
, nbr
->router_id
.s_addr
);
1022 static struct ospf_lsa
*ospf_network_lsa_new(struct ospf_interface
*oi
)
1025 struct ospf_lsa
*new;
1026 struct lsa_header
*lsah
;
1027 struct ospf_if_params
*oip
;
1030 /* If there are no neighbours on this network (the net is stub),
1031 the router does not originate network-LSA (see RFC 12.4.2) */
1032 if (oi
->full_nbrs
== 0)
1035 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1036 zlog_debug("LSA[Type2]: Create network-LSA instance");
1038 /* Create new stream for LSA. */
1039 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1040 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1042 lsa_header_set(s
, (OPTIONS(oi
) | LSA_OPTIONS_GET(oi
->area
)),
1043 OSPF_NETWORK_LSA
, DR(oi
), oi
->ospf
->router_id
);
1045 /* Set network-LSA body fields. */
1046 ospf_network_lsa_body_set(s
, oi
);
1049 length
= stream_get_endp(s
);
1050 lsah
->length
= htons(length
);
1052 /* Create OSPF LSA instance. */
1053 new = ospf_lsa_new_and_data(length
);
1055 new->area
= oi
->area
;
1056 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
1057 new->vrf_id
= oi
->ospf
->vrf_id
;
1059 /* Copy LSA to store. */
1060 memcpy(new->data
, lsah
, length
);
1063 /* Remember prior network LSA sequence numbers, even if we stop
1064 * originating one for this oi, to try avoid re-originating LSAs with a
1065 * prior sequence number, and thus speed up adjency forming &
1068 if ((oip
= ospf_lookup_if_params(oi
->ifp
, oi
->address
->u
.prefix4
))) {
1069 new->data
->ls_seqnum
= oip
->network_lsa_seqnum
;
1070 new->data
->ls_seqnum
= lsa_seqnum_increment(new);
1072 oip
= ospf_get_if_params(oi
->ifp
, oi
->address
->u
.prefix4
);
1073 ospf_if_update_params(oi
->ifp
, oi
->address
->u
.prefix4
);
1075 oip
->network_lsa_seqnum
= new->data
->ls_seqnum
;
1080 /* Originate network-LSA. */
1081 void ospf_network_lsa_update(struct ospf_interface
*oi
)
1083 struct ospf_lsa
*new;
1085 if (oi
->area
->ospf
->gr_info
.restart_in_progress
) {
1086 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1088 "LSA[Type%d]: Graceful Restart in progress, don't originate",
1093 if (oi
->network_lsa_self
!= NULL
) {
1094 ospf_lsa_refresh(oi
->ospf
, oi
->network_lsa_self
);
1098 /* Create new network-LSA instance. */
1099 new = ospf_network_lsa_new(oi
);
1103 /* Install LSA to LSDB. */
1104 new = ospf_lsa_install(oi
->ospf
, oi
, new);
1106 /* Update LSA origination count. */
1107 oi
->ospf
->lsa_originate_count
++;
1109 /* Flooding new LSA through area. */
1110 ospf_flood_through_area(oi
->area
, NULL
, new);
1112 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1113 zlog_debug("LSA[Type%d:%pI4]: Originate network-LSA %p",
1114 new->data
->type
, &new->data
->id
,
1116 ospf_lsa_header_dump(new->data
);
1122 static struct ospf_lsa
*ospf_network_lsa_refresh(struct ospf_lsa
*lsa
)
1124 struct ospf_area
*area
= lsa
->area
;
1125 struct ospf_lsa
*new, *new2
;
1126 struct ospf_if_params
*oip
;
1127 struct ospf_interface
*oi
;
1131 /* Retrieve the oi for the network LSA */
1132 oi
= ospf_if_lookup_by_local_addr(area
->ospf
, NULL
, lsa
->data
->id
);
1134 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1136 "LSA[Type%d:%pI4]: network-LSA refresh: no oi found, ick, ignoring.",
1137 lsa
->data
->type
, &lsa
->data
->id
);
1138 ospf_lsa_header_dump(lsa
->data
);
1143 if (oi
->state
!= ISM_DR
)
1146 /* Delete LSA from neighbor retransmit-list. */
1147 ospf_ls_retransmit_delete_nbr_area(area
, lsa
);
1149 /* Unregister LSA from refresh-list */
1150 ospf_refresher_unregister_lsa(area
->ospf
, lsa
);
1152 /* Create new network-LSA instance. */
1153 new = ospf_network_lsa_new(oi
);
1157 oip
= ospf_lookup_if_params(oi
->ifp
, oi
->address
->u
.prefix4
);
1158 assert(oip
!= NULL
);
1159 oip
->network_lsa_seqnum
= new->data
->ls_seqnum
=
1160 lsa_seqnum_increment(lsa
);
1162 new2
= ospf_lsa_install(area
->ospf
, oi
, new);
1164 assert(new2
== new);
1166 /* Flood LSA through aera. */
1167 ospf_flood_through_area(area
, NULL
, new);
1169 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1170 zlog_debug("LSA[Type%d:%pI4]: network-LSA refresh",
1171 new->data
->type
, &new->data
->id
);
1172 ospf_lsa_header_dump(new->data
);
1178 static void stream_put_ospf_metric(struct stream
*s
, uint32_t metric_value
)
1183 /* Put 0 metric. TOS metric is not supported. */
1184 metric
= htonl(metric_value
);
1185 mp
= (char *)&metric
;
1187 stream_put(s
, mp
, 3);
1190 /* summary-LSA related functions. */
1191 static void ospf_summary_lsa_body_set(struct stream
*s
, struct prefix
*p
,
1194 struct in_addr mask
;
1196 masklen2ip(p
->prefixlen
, &mask
);
1198 /* Put Network Mask. */
1199 stream_put_ipv4(s
, mask
.s_addr
);
1202 stream_putc(s
, (uint8_t)0);
1205 stream_put_ospf_metric(s
, metric
);
1208 static struct ospf_lsa
*ospf_summary_lsa_new(struct ospf_area
*area
,
1209 struct prefix
*p
, uint32_t metric
,
1213 struct ospf_lsa
*new;
1214 struct lsa_header
*lsah
;
1217 if (id
.s_addr
== 0xffffffff) {
1218 /* Maybe Link State ID not available. */
1219 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1221 "LSA[Type%d]: Link ID not available, can't originate",
1226 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1227 zlog_debug("LSA[Type3]: Create summary-LSA instance");
1229 /* Create new stream for LSA. */
1230 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1231 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1233 lsa_header_set(s
, LSA_OPTIONS_GET(area
), OSPF_SUMMARY_LSA
, id
,
1234 area
->ospf
->router_id
);
1236 /* Set summary-LSA body fields. */
1237 ospf_summary_lsa_body_set(s
, p
, metric
);
1240 length
= stream_get_endp(s
);
1241 lsah
->length
= htons(length
);
1243 /* Create OSPF LSA instance. */
1244 new = ospf_lsa_new_and_data(length
);
1246 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
1247 new->vrf_id
= area
->ospf
->vrf_id
;
1249 /* Copy LSA to store. */
1250 memcpy(new->data
, lsah
, length
);
1256 /* Originate Summary-LSA. */
1257 static struct ospf_lsa
*
1258 ospf_summary_lsa_prepare_and_flood(struct prefix_ipv4
*p
, uint32_t metric
,
1259 struct ospf_area
*area
, struct in_addr id
)
1261 struct ospf_lsa
*new;
1263 /* Create new summary-LSA instance. */
1264 if (!(new = ospf_summary_lsa_new(area
, (struct prefix
*)p
, metric
, id
)))
1267 /* Instlal LSA to LSDB. */
1268 new = ospf_lsa_install(area
->ospf
, NULL
, new);
1270 /* Update LSA origination count. */
1271 area
->ospf
->lsa_originate_count
++;
1273 /* Flooding new LSA through area. */
1274 ospf_flood_through_area(area
, NULL
, new);
1276 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1277 zlog_debug("LSA[Type%d:%pI4]: Originate summary-LSA %p",
1278 new->data
->type
, &new->data
->id
,
1280 ospf_lsa_header_dump(new->data
);
1286 static struct ospf_lsa
*ospf_handle_summarylsa_lsId_chg(struct ospf
*ospf
,
1287 struct prefix_ipv4
*p
,
1290 struct in_addr old_id
)
1292 struct ospf_lsa
*lsa
= NULL
;
1293 struct ospf_lsa
*new = NULL
;
1294 struct summary_lsa
*sl
= NULL
;
1295 struct ospf_area
*old_area
= NULL
;
1296 struct prefix_ipv4 old_prefix
;
1297 uint32_t old_metric
;
1298 struct in_addr mask
;
1299 uint32_t metric_val
;
1302 lsa
= ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, p
->prefix
,
1306 flog_warn(EC_OSPF_LSA_NULL
, "(%s): LSA not found", __func__
);
1310 sl
= (struct summary_lsa
*)lsa
->data
;
1312 old_area
= lsa
->area
;
1313 old_metric
= GET_METRIC(sl
->metric
);
1314 old_prefix
.prefix
= sl
->header
.id
;
1315 old_prefix
.prefixlen
= ip_masklen(sl
->mask
);
1316 old_prefix
.family
= AF_INET
;
1319 /* change the mask */
1320 masklen2ip(p
->prefixlen
, &mask
);
1321 sl
->mask
.s_addr
= mask
.s_addr
;
1323 /* Copy the metric*/
1324 metric_val
= htonl(metric
);
1325 metric_buf
= (char *)&metric_val
;
1326 memcpy(sl
->metric
, metric_buf
, sizeof(metric_val
));
1328 if (type
== OSPF_SUMMARY_LSA
) {
1329 /*Refresh the LSA with new LSA*/
1330 ospf_summary_lsa_refresh(ospf
, lsa
);
1332 new = ospf_summary_lsa_prepare_and_flood(
1333 &old_prefix
, old_metric
, old_area
, old_id
);
1335 /*Refresh the LSA with new LSA*/
1336 ospf_summary_asbr_lsa_refresh(ospf
, lsa
);
1338 new = ospf_asbr_summary_lsa_prepare_and_flood(
1339 &old_prefix
, old_metric
, old_area
, old_id
);
1345 /* Originate Summary-LSA. */
1346 struct ospf_lsa
*ospf_summary_lsa_originate(struct prefix_ipv4
*p
,
1348 struct ospf_area
*area
)
1351 enum lsid_status status
;
1352 struct ospf_lsa
*new = NULL
;
1354 status
= ospf_lsa_unique_id(area
->ospf
, area
->lsdb
, OSPF_SUMMARY_LSA
, p
,
1357 if (status
== LSID_CHANGE
) {
1358 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1359 zlog_debug("Link ID has to be changed.");
1361 new = ospf_handle_summarylsa_lsId_chg(
1362 area
->ospf
, p
, OSPF_SUMMARY_LSA
, metric
, id
);
1364 } else if (status
== LSID_NOT_AVAILABLE
) {
1365 /* Link State ID not available. */
1366 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1368 "LSA[Type5]: Link ID not available, can't originate");
1373 new = ospf_summary_lsa_prepare_and_flood(p
, metric
, area
, id
);
1377 static struct ospf_lsa
*ospf_summary_lsa_refresh(struct ospf
*ospf
,
1378 struct ospf_lsa
*lsa
)
1380 struct ospf_lsa
*new;
1381 struct summary_lsa
*sl
;
1387 sl
= (struct summary_lsa
*)lsa
->data
;
1388 p
.prefixlen
= ip_masklen(sl
->mask
);
1389 new = ospf_summary_lsa_new(lsa
->area
, &p
, GET_METRIC(sl
->metric
),
1395 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
1397 ospf_lsa_install(ospf
, NULL
, new);
1399 /* Flood LSA through AS. */
1400 ospf_flood_through_area(new->area
, NULL
, new);
1402 /* Debug logging. */
1403 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1404 zlog_debug("LSA[Type%d:%pI4]: summary-LSA refresh",
1405 new->data
->type
, &new->data
->id
);
1406 ospf_lsa_header_dump(new->data
);
1413 /* summary-ASBR-LSA related functions. */
1414 static void ospf_summary_asbr_lsa_body_set(struct stream
*s
, struct prefix
*p
,
1417 /* Put Network Mask. */
1418 stream_put_ipv4(s
, (uint32_t)0);
1421 stream_putc(s
, (uint8_t)0);
1424 stream_put_ospf_metric(s
, metric
);
1427 static struct ospf_lsa
*ospf_summary_asbr_lsa_new(struct ospf_area
*area
,
1433 struct ospf_lsa
*new;
1434 struct lsa_header
*lsah
;
1437 if (id
.s_addr
== 0xffffffff) {
1438 /* Maybe Link State ID not available. */
1439 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1441 "LSA[Type%d]: Link ID not available, can't originate",
1442 OSPF_ASBR_SUMMARY_LSA
);
1446 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1447 zlog_debug("LSA[Type3]: Create summary-LSA instance");
1449 /* Create new stream for LSA. */
1450 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1451 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1453 lsa_header_set(s
, LSA_OPTIONS_GET(area
), OSPF_ASBR_SUMMARY_LSA
, id
,
1454 area
->ospf
->router_id
);
1456 /* Set summary-LSA body fields. */
1457 ospf_summary_asbr_lsa_body_set(s
, p
, metric
);
1460 length
= stream_get_endp(s
);
1461 lsah
->length
= htons(length
);
1463 /* Create OSPF LSA instance. */
1464 new = ospf_lsa_new_and_data(length
);
1466 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
1467 new->vrf_id
= area
->ospf
->vrf_id
;
1469 /* Copy LSA to store. */
1470 memcpy(new->data
, lsah
, length
);
1476 /* Originate summary-ASBR-LSA. */
1477 static struct ospf_lsa
*
1478 ospf_asbr_summary_lsa_prepare_and_flood(struct prefix_ipv4
*p
, uint32_t metric
,
1479 struct ospf_area
*area
,
1482 struct ospf_lsa
*new;
1484 /* Create new summary-LSA instance. */
1485 new = ospf_summary_asbr_lsa_new(area
, (struct prefix
*)p
, metric
, id
);
1489 /* Install LSA to LSDB. */
1490 new = ospf_lsa_install(area
->ospf
, NULL
, new);
1492 /* Update LSA origination count. */
1493 area
->ospf
->lsa_originate_count
++;
1495 /* Flooding new LSA through area. */
1496 ospf_flood_through_area(area
, NULL
, new);
1498 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1499 zlog_debug("LSA[Type%d:%pI4]: Originate summary-ASBR-LSA %p",
1500 new->data
->type
, &new->data
->id
,
1502 ospf_lsa_header_dump(new->data
);
1508 struct ospf_lsa
*ospf_summary_asbr_lsa_originate(struct prefix_ipv4
*p
,
1510 struct ospf_area
*area
)
1512 struct ospf_lsa
*new;
1514 enum lsid_status status
;
1516 status
= ospf_lsa_unique_id(area
->ospf
, area
->lsdb
,
1517 OSPF_ASBR_SUMMARY_LSA
, p
, &id
);
1519 if (status
== LSID_CHANGE
) {
1520 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1521 zlog_debug("Link ID has to be changed.");
1523 new = ospf_handle_summarylsa_lsId_chg(
1524 area
->ospf
, p
, OSPF_ASBR_SUMMARY_LSA
, metric
, id
);
1526 } else if (status
== LSID_NOT_AVAILABLE
) {
1527 /* Link State ID not available. */
1528 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1530 "LSA[Type5]: Link ID not available, can't originate");
1535 new = ospf_asbr_summary_lsa_prepare_and_flood(p
, metric
, area
, id
);
1539 static struct ospf_lsa
*ospf_summary_asbr_lsa_refresh(struct ospf
*ospf
,
1540 struct ospf_lsa
*lsa
)
1542 struct ospf_lsa
*new;
1543 struct summary_lsa
*sl
;
1545 bool ind_lsa
= false;
1550 if (lsa
->area
->fr_info
.indication_lsa_self
&&
1551 (lsa
->area
->fr_info
.indication_lsa_self
== lsa
))
1554 sl
= (struct summary_lsa
*)lsa
->data
;
1555 p
.prefixlen
= ip_masklen(sl
->mask
);
1556 new = ospf_summary_asbr_lsa_new(lsa
->area
, &p
, GET_METRIC(sl
->metric
),
1561 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
1563 ospf_lsa_install(ospf
, NULL
, new);
1565 /* Flood LSA through area. */
1566 ospf_flood_through_area(new->area
, NULL
, new);
1569 new->area
->fr_info
.indication_lsa_self
= new;
1571 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1572 zlog_debug("LSA[Type%d:%pI4]: summary-ASBR-LSA refresh",
1573 new->data
->type
, &new->data
->id
);
1574 ospf_lsa_header_dump(new->data
);
1580 /* AS-external-LSA related functions. */
1582 /* Get nexthop for AS-external-LSAs. Return nexthop if its interface
1583 is connected, else 0*/
1584 static struct in_addr
ospf_external_lsa_nexthop_get(struct ospf
*ospf
,
1585 struct in_addr nexthop
)
1589 struct listnode
*node
;
1590 struct ospf_interface
*oi
;
1594 if (!nexthop
.s_addr
)
1597 /* Check whether nexthop is covered by OSPF network. */
1598 nh
.family
= AF_INET
;
1599 nh
.u
.prefix4
= nexthop
;
1600 nh
.prefixlen
= IPV4_MAX_BITLEN
;
1602 /* XXX/SCALE: If there were a lot of oi's on an ifp, then it'd be
1603 * better to make use of the per-ifp table of ois.
1605 for (ALL_LIST_ELEMENTS_RO(ospf
->oiflist
, node
, oi
))
1606 if (if_is_operative(oi
->ifp
))
1607 if (oi
->address
->family
== AF_INET
)
1608 if (prefix_match(oi
->address
, &nh
))
1614 /* NSSA-external-LSA related functions. */
1616 /* Get 1st IP connection for Forward Addr */
1618 struct in_addr
ospf_get_ip_from_ifp(struct ospf_interface
*oi
)
1622 fwd
.s_addr
= INADDR_ANY
;
1624 if (if_is_operative(oi
->ifp
))
1625 return oi
->address
->u
.prefix4
;
1630 /* Get 1st IP connection for Forward Addr */
1631 struct in_addr
ospf_get_nssa_ip(struct ospf_area
*area
)
1634 struct in_addr best_default
;
1635 struct listnode
*node
;
1636 struct ospf_interface
*oi
;
1639 best_default
.s_addr
= 0;
1641 for (ALL_LIST_ELEMENTS_RO(area
->ospf
->oiflist
, node
, oi
)) {
1642 if (if_is_operative(oi
->ifp
))
1643 if (oi
->area
->external_routing
== OSPF_AREA_NSSA
)
1645 && oi
->address
->family
== AF_INET
) {
1646 if (best_default
.s_addr
== INADDR_ANY
)
1648 oi
->address
->u
.prefix4
;
1649 if (oi
->area
== area
)
1650 return oi
->address
->u
.prefix4
;
1653 if (best_default
.s_addr
!= INADDR_ANY
)
1654 return best_default
;
1656 if (best_default
.s_addr
!= INADDR_ANY
)
1657 return best_default
;
1662 int metric_type(struct ospf
*ospf
, uint8_t src
, unsigned short instance
)
1664 struct ospf_redist
*red
;
1666 red
= ospf_redist_lookup(ospf
, src
, instance
);
1668 return ((!red
|| red
->dmetric
.type
< 0) ? DEFAULT_METRIC_TYPE
1669 : red
->dmetric
.type
);
1672 int metric_value(struct ospf
*ospf
, uint8_t src
, unsigned short instance
)
1674 struct ospf_redist
*red
;
1676 red
= ospf_redist_lookup(ospf
, src
, instance
);
1677 if (!red
|| red
->dmetric
.value
< 0) {
1678 if (src
== DEFAULT_ROUTE
) {
1679 if (ospf
->default_originate
== DEFAULT_ORIGINATE_ZEBRA
)
1680 return DEFAULT_DEFAULT_ORIGINATE_METRIC
;
1682 return DEFAULT_DEFAULT_ALWAYS_METRIC
;
1683 } else if (ospf
->default_metric
< 0)
1684 return DEFAULT_DEFAULT_METRIC
;
1686 return ospf
->default_metric
;
1689 return red
->dmetric
.value
;
1692 /* Set AS-external-LSA body. */
1693 static void ospf_external_lsa_body_set(struct stream
*s
,
1694 struct external_info
*ei
,
1697 struct prefix_ipv4
*p
= &ei
->p
;
1698 struct in_addr mask
, fwd_addr
;
1702 unsigned short instance
;
1704 /* Put Network Mask. */
1705 masklen2ip(p
->prefixlen
, &mask
);
1706 stream_put_ipv4(s
, mask
.s_addr
);
1708 /* If prefix is default, specify DEFAULT_ROUTE. */
1709 type
= is_default_prefix4(&ei
->p
) ? DEFAULT_ROUTE
: ei
->type
;
1710 instance
= is_default_prefix4(&ei
->p
) ? 0 : ei
->instance
;
1712 mtype
= (ROUTEMAP_METRIC_TYPE(ei
) != -1)
1713 ? ROUTEMAP_METRIC_TYPE(ei
)
1714 : metric_type(ospf
, type
, instance
);
1716 mvalue
= (ROUTEMAP_METRIC(ei
) != -1)
1717 ? ROUTEMAP_METRIC(ei
)
1718 : metric_value(ospf
, type
, instance
);
1720 /* Put type of external metric. */
1721 stream_putc(s
, (mtype
== EXTERNAL_METRIC_TYPE_2
? 0x80 : 0));
1723 /* Put 0 metric. TOS metric is not supported. */
1724 stream_put_ospf_metric(s
, mvalue
);
1726 /* Get forwarding address to nexthop if on the Connection List, else 0.
1728 fwd_addr
= ospf_external_lsa_nexthop_get(ospf
, ei
->nexthop
);
1730 /* Put forwarding address. */
1731 stream_put_ipv4(s
, fwd_addr
.s_addr
);
1734 stream_putl(s
, ei
->tag
);
1737 /* Create new external-LSA. */
1738 static struct ospf_lsa
*
1739 ospf_exnl_lsa_prepare_and_flood(struct ospf
*ospf
, struct external_info
*ei
,
1743 struct lsa_header
*lsah
;
1744 struct ospf_lsa
*new;
1747 /* Create new stream for LSA. */
1748 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1749 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1751 /* Set LSA common header fields. */
1752 lsa_header_set(s
, OSPF_OPTION_E
, OSPF_AS_EXTERNAL_LSA
, id
,
1755 /* Set AS-external-LSA body fields. */
1756 ospf_external_lsa_body_set(s
, ei
, ospf
);
1759 length
= stream_get_endp(s
);
1760 lsah
->length
= htons(length
);
1762 /* Now, create OSPF LSA instance. */
1763 new = ospf_lsa_new_and_data(length
);
1765 SET_FLAG(new->flags
,
1766 OSPF_LSA_SELF
| OSPF_LSA_APPROVED
| OSPF_LSA_SELF_CHECKED
);
1767 new->vrf_id
= ospf
->vrf_id
;
1769 /* Copy LSA data to store, discard stream. */
1770 memcpy(new->data
, lsah
, length
);
1776 static struct ospf_lsa
*ospf_handle_exnl_lsa_lsId_chg(struct ospf
*ospf
,
1777 struct external_info
*ei
,
1780 struct ospf_lsa
*lsa
;
1781 struct as_external_lsa
*al
;
1782 struct in_addr mask
;
1783 struct ospf_lsa
*new;
1784 struct external_info ei_summary
= {};
1785 struct external_info
*ei_old
;
1787 lsa
= ospf_lsdb_lookup_by_id(ospf
->lsdb
, OSPF_AS_EXTERNAL_LSA
,
1788 ei
->p
.prefix
, ospf
->router_id
);
1791 flog_warn(EC_OSPF_LSA_NULL
, "(%s): LSA not found", __func__
);
1795 ei_old
= ospf_external_info_check(ospf
, lsa
);
1797 al
= (struct as_external_lsa
*)lsa
->data
;
1800 /* eii_old pointer of LSA is NULL, this
1801 * must be external aggregate route.
1803 ei_summary
.p
.family
= AF_INET
;
1804 ei_summary
.p
.prefix
= al
->header
.id
;
1805 ei_summary
.p
.prefixlen
= ip_masklen(al
->mask
);
1806 ei_summary
.tag
= (unsigned long)ntohl(al
->e
[0].route_tag
);
1807 ei_old
= &ei_summary
;
1810 /* change the mask */
1811 masklen2ip(ei
->p
.prefixlen
, &mask
);
1812 al
->mask
.s_addr
= mask
.s_addr
;
1814 /*Refresh the LSA with new LSA*/
1815 ospf_external_lsa_refresh(ospf
, lsa
, ei
, LSA_REFRESH_FORCE
, 0);
1817 /*Originate the old LSA with changed LSID*/
1818 new = ospf_exnl_lsa_prepare_and_flood(ospf
, ei_old
, id
);
1823 static struct ospf_lsa
*ospf_external_lsa_new(struct ospf
*ospf
,
1824 struct external_info
*ei
,
1825 struct in_addr
*old_id
)
1827 struct ospf_lsa
*new;
1829 enum lsid_status status
;
1832 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1834 "LSA[Type5]: External info is NULL, can't originate");
1838 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1839 zlog_debug("LSA[Type5]: Originate AS-external-LSA instance");
1841 /* If old Link State ID is specified, refresh LSA with same ID. */
1844 /* Get Link State with unique ID. */
1846 status
= ospf_lsa_unique_id(ospf
, ospf
->lsdb
,
1847 OSPF_AS_EXTERNAL_LSA
, &ei
->p
, &id
);
1849 if (status
== LSID_CHANGE
) {
1850 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1851 zlog_debug("Link ID has to be changed.");
1853 new = ospf_handle_exnl_lsa_lsId_chg(ospf
, ei
, id
);
1855 } else if (status
== LSID_NOT_AVAILABLE
) {
1856 /* Link State ID not available. */
1857 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1859 "LSA[Type5]: Link ID not available, can't originate");
1864 new = ospf_exnl_lsa_prepare_and_flood(ospf
, ei
, id
);
1870 static void ospf_install_flood_nssa(struct ospf
*ospf
, struct ospf_lsa
*lsa
,
1871 struct external_info
*ei
)
1873 struct ospf_lsa
*new;
1874 struct as_external_lsa
*extlsa
;
1875 struct ospf_area
*area
;
1876 struct listnode
*node
, *nnode
;
1878 /* LSA may be a Type-5 originated via translation of a Type-7 LSA
1879 * which originated from an NSSA area. In which case it should not be
1880 * flooded back to NSSA areas.
1882 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
))
1885 /* NSSA Originate or Refresh (If anyNSSA)
1887 LSA is self-originated. And just installed as Type-5.
1888 Additionally, install as Type-7 LSDB for every attached NSSA.
1890 P-Bit controls which ABR performs translation to outside world; If
1891 we are an ABR....do not set the P-bit, because we send the Type-5,
1892 not as the ABR Translator, but as the ASBR owner within the AS!
1894 If we are NOT ABR, Flood through NSSA as Type-7 w/P-bit set. The
1895 elected ABR Translator will see the P-bit, Translate, and re-flood.
1897 Later, ABR_TASK and P-bit will scan Type-7 LSDB and translate to
1898 Type-5's to non-NSSA Areas. (it will also attempt a re-install) */
1900 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
1901 /* Don't install Type-7 LSA's into nonNSSA area */
1902 if (area
->external_routing
!= OSPF_AREA_NSSA
)
1905 /* make lsa duplicate, lock=1 */
1906 new = ospf_lsa_dup(lsa
);
1908 new->data
->type
= OSPF_AS_NSSA_LSA
;
1910 /* set P-bit if not ABR */
1911 if (!IS_OSPF_ABR(ospf
)) {
1912 SET_FLAG(new->data
->options
, OSPF_OPTION_NP
);
1914 /* set non-zero FWD ADDR
1916 draft-ietf-ospf-nssa-update-09.txt
1918 if the network between the NSSA AS boundary router and
1920 adjacent AS is advertised into OSPF as an internal OSPF
1922 the forwarding address should be the next op address as
1924 currently done with type-5 LSAs. If the intervening
1926 not adversited into OSPF as an internal OSPF route and
1928 type-7 LSA's P-bit is set a forwarding address should be
1929 selected from one of the router's active OSPF interface
1931 which belong to the NSSA. If no such addresses exist,
1933 no type-7 LSA's with the P-bit set should originate from
1937 /* kevinm: not updating lsa anymore, just new */
1938 extlsa
= (struct as_external_lsa
*)(new->data
);
1940 if (extlsa
->e
[0].fwd_addr
.s_addr
== INADDR_ANY
)
1941 extlsa
->e
[0].fwd_addr
= ospf_get_nssa_ip(
1942 area
); /* this NSSA area in ifp */
1944 if (extlsa
->e
[0].fwd_addr
.s_addr
== INADDR_ANY
) {
1945 if (IS_DEBUG_OSPF_NSSA
)
1947 "LSA[Type-7]: Could not build FWD-ADDR");
1948 ospf_lsa_discard(new);
1953 /* install also as Type-7 */
1954 ospf_lsa_install(ospf
, NULL
,
1955 new); /* Remove Old, Lock New = 2 */
1957 /* will send each copy, lock=2+n */
1958 ospf_flood_through_as(
1959 ospf
, NULL
, new); /* all attached NSSA's, no AS/STUBs */
1963 static struct ospf_lsa
*ospf_lsa_translated_nssa_new(struct ospf
*ospf
,
1964 struct ospf_lsa
*type7
)
1967 struct ospf_lsa
*new;
1968 struct as_external_lsa
*ext
, *extnew
;
1969 struct external_info ei
;
1971 ext
= (struct as_external_lsa
*)(type7
->data
);
1973 /* need external_info struct, fill in bare minimum */
1974 ei
.p
.family
= AF_INET
;
1975 ei
.p
.prefix
= type7
->data
->id
;
1976 ei
.p
.prefixlen
= ip_masklen(ext
->mask
);
1977 ei
.type
= ZEBRA_ROUTE_OSPF
;
1978 ei
.nexthop
= ext
->header
.adv_router
;
1979 ei
.route_map_set
.metric
= -1;
1980 ei
.route_map_set
.metric_type
= -1;
1984 if ((new = ospf_external_lsa_new(ospf
, &ei
, &type7
->data
->id
))
1986 if (IS_DEBUG_OSPF_NSSA
)
1988 "%s: Could not originate Translated Type-5 for %pI4",
1989 __func__
, &ei
.p
.prefix
);
1993 extnew
= (struct as_external_lsa
*)(new->data
);
1995 /* copy over Type-7 data to new */
1996 extnew
->e
[0].tos
= ext
->e
[0].tos
;
1997 extnew
->e
[0].route_tag
= ext
->e
[0].route_tag
;
1998 if (type7
->area
->suppress_fa
) {
1999 extnew
->e
[0].fwd_addr
.s_addr
= 0;
2000 if (IS_DEBUG_OSPF_NSSA
)
2001 zlog_debug("%s: Suppress forwarding address for %pI4",
2002 __func__
, &ei
.p
.prefix
);
2004 extnew
->e
[0].fwd_addr
.s_addr
= ext
->e
[0].fwd_addr
.s_addr
;
2005 new->data
->ls_seqnum
= type7
->data
->ls_seqnum
;
2007 /* add translated flag, checksum and lock new lsa */
2008 SET_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
); /* Translated from 7 */
2009 new = ospf_lsa_lock(new);
2014 /* Originate Translated Type-5 for supplied Type-7 NSSA LSA */
2015 struct ospf_lsa
*ospf_translated_nssa_originate(struct ospf
*ospf
,
2016 struct ospf_lsa
*type7
,
2017 struct ospf_lsa
*type5
)
2019 struct ospf_lsa
*new;
2020 struct as_external_lsa
*extnew
;
2022 if (ospf
->gr_info
.restart_in_progress
) {
2023 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2025 "LSA[Translated Type5]: Graceful Restart in progress, don't originate");
2029 /* we cant use ospf_external_lsa_originate() as we need to set
2030 * the OSPF_LSA_LOCAL_XLT flag, must originate by hand
2033 if ((new = ospf_lsa_translated_nssa_new(ospf
, type7
)) == NULL
) {
2034 if (IS_DEBUG_OSPF_NSSA
)
2036 "%s: Could not translate Type-7, Id %pI4, to Type-5",
2037 __func__
, &type7
->data
->id
);
2041 extnew
= (struct as_external_lsa
*)new->data
;
2043 /* Update LSA sequence number from translated Type-5 LSA */
2045 new->data
->ls_seqnum
= lsa_seqnum_increment(type5
);
2047 if ((new = ospf_lsa_install(ospf
, NULL
, new)) == NULL
) {
2048 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE
,
2049 "%s: Could not install LSA id %pI4", __func__
,
2054 if (IS_DEBUG_OSPF_NSSA
) {
2055 zlog_debug("%s: translated Type 7, installed", __func__
);
2056 ospf_lsa_header_dump(new->data
);
2057 zlog_debug(" Network mask: %d", ip_masklen(extnew
->mask
));
2058 zlog_debug(" Forward addr: %pI4",
2059 &extnew
->e
[0].fwd_addr
);
2062 ospf
->lsa_originate_count
++;
2063 ospf_flood_through_as(ospf
, NULL
, new);
2068 /* Refresh Translated from NSSA AS-external-LSA. */
2069 struct ospf_lsa
*ospf_translated_nssa_refresh(struct ospf
*ospf
,
2070 struct ospf_lsa
*type7
,
2071 struct ospf_lsa
*type5
)
2073 struct ospf_lsa
*new = NULL
;
2074 struct as_external_lsa
*extold
= NULL
;
2075 uint32_t ls_seqnum
= 0;
2077 /* Sanity checks. */
2078 assert(type7
|| type5
);
2079 if (!(type7
|| type5
))
2082 assert(type7
->data
);
2084 assert(type5
->data
);
2085 assert(ospf
->anyNSSA
);
2087 /* get required data according to what has been given */
2088 if (type7
&& type5
== NULL
) {
2089 /* find the translated Type-5 for this Type-7 */
2090 struct as_external_lsa
*ext
=
2091 (struct as_external_lsa
*)(type7
->data
);
2092 struct prefix_ipv4 p
= {
2093 .prefix
= type7
->data
->id
,
2094 .prefixlen
= ip_masklen(ext
->mask
),
2098 type5
= ospf_external_info_find_lsa(ospf
, &p
);
2099 } else if (type5
&& type7
== NULL
) {
2100 /* find the type-7 from which supplied type-5 was translated,
2101 * ie find first type-7 with same LSA Id.
2103 struct listnode
*ln
, *lnn
;
2104 struct route_node
*rn
;
2105 struct ospf_lsa
*lsa
;
2106 struct ospf_area
*area
;
2108 for (ALL_LIST_ELEMENTS(ospf
->areas
, ln
, lnn
, area
)) {
2109 if (area
->external_routing
!= OSPF_AREA_NSSA
&& !type7
)
2112 LSDB_LOOP (NSSA_LSDB(area
), rn
, lsa
) {
2113 if (lsa
->data
->id
.s_addr
2114 == type5
->data
->id
.s_addr
) {
2122 /* do we have type7? */
2124 if (IS_DEBUG_OSPF_NSSA
)
2125 zlog_debug("%s: no Type-7 found for Type-5 LSA Id %pI4",
2126 __func__
, &type5
->data
->id
);
2130 /* do we have valid translated type5? */
2131 if (type5
== NULL
|| !CHECK_FLAG(type5
->flags
, OSPF_LSA_LOCAL_XLT
)) {
2132 if (IS_DEBUG_OSPF_NSSA
)
2134 "%s: No translated Type-5 found for Type-7 with Id %pI4",
2135 __func__
, &type7
->data
->id
);
2139 extold
= (struct as_external_lsa
*)type5
->data
;
2140 if (type7
->area
->suppress_fa
== 1) {
2141 if (extold
->e
[0].fwd_addr
.s_addr
== 0)
2142 ls_seqnum
= ntohl(type5
->data
->ls_seqnum
);
2145 /* Delete LSA from neighbor retransmit-list. */
2146 ospf_ls_retransmit_delete_nbr_as(ospf
, type5
);
2148 /* create new translated LSA */
2149 if ((new = ospf_lsa_translated_nssa_new(ospf
, type7
)) == NULL
) {
2150 if (IS_DEBUG_OSPF_NSSA
)
2152 "%s: Could not translate Type-7 for %pI4 to Type-5",
2153 __func__
, &type7
->data
->id
);
2157 if (type7
->area
->suppress_fa
== 1) {
2158 if (extold
->e
[0].fwd_addr
.s_addr
== 0)
2159 new->data
->ls_seqnum
= htonl(ls_seqnum
+ 1);
2162 if (!(new = ospf_lsa_install(ospf
, NULL
, new))) {
2163 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE
,
2164 "%s: Could not install translated LSA, Id %pI4",
2165 __func__
, &type7
->data
->id
);
2169 /* Flood LSA through area. */
2170 ospf_flood_through_as(ospf
, NULL
, new);
2175 /* Originate an AS-external-LSA, install and flood. */
2176 struct ospf_lsa
*ospf_external_lsa_originate(struct ospf
*ospf
,
2177 struct external_info
*ei
)
2179 struct ospf_lsa
*new;
2181 if (ospf
->gr_info
.restart_in_progress
) {
2182 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2184 "LSA[Type5]: Graceful Restart in progress, don't originate");
2188 /* Added for NSSA project....
2190 External LSAs are originated in ASBRs as usual, but for NSSA
2192 there is the global Type-5 LSDB and a Type-7 LSDB installed for
2193 every area. The Type-7's are flooded to every IR and every ABR; We
2194 install the Type-5 LSDB so that the normal "refresh" code operates
2195 as usual, and flag them as not used during ASE calculations. The
2196 Type-7 LSDB is used for calculations. Each Type-7 has a Forwarding
2197 Address of non-zero.
2199 If an ABR is the elected NSSA translator, following SPF and during
2200 the ABR task it will translate all the scanned Type-7's, with P-bit
2201 ON and not-self generated, and translate to Type-5's throughout the
2204 A difference in operation depends whether this ASBR is an ABR
2205 or not. If not an ABR, the P-bit is ON, to indicate that any
2206 elected NSSA-ABR can perform its translation.
2208 If an ABR, the P-bit is OFF; No ABR will perform translation and
2209 this ASBR will flood the Type-5 LSA as usual.
2211 For the case where this ASBR is not an ABR, the ASE calculations
2212 are based on the Type-5 LSDB; The Type-7 LSDB exists just to
2213 demonstrate to the user that there are LSA's that belong to any
2216 Finally, it just so happens that when the ABR is translating every
2217 Type-7 into Type-5, it installs it into the Type-5 LSDB as an
2218 approved Type-5 (translated from Type-7); at the end of translation
2219 if any Translated Type-5's remain unapproved, then they must be
2220 flushed from the AS.
2224 if (ospf
->router_id
.s_addr
== INADDR_ANY
) {
2225 if (ei
&& IS_DEBUG_OSPF_EVENT
)
2227 "LSA[Type5:%pI4]: deferring AS-external-LSA origination, router ID is zero",
2232 /* Create new AS-external-LSA instance. */
2233 if ((new = ospf_external_lsa_new(ospf
, ei
, NULL
)) == NULL
) {
2234 if (ei
&& IS_DEBUG_OSPF_EVENT
)
2236 "LSA[Type5:%pI4]: Could not originate AS-external-LSA",
2241 /* Install newly created LSA into Type-5 LSDB, lock = 1. */
2242 ospf_lsa_install(ospf
, NULL
, new);
2244 /* Update LSA origination count. */
2245 ospf
->lsa_originate_count
++;
2247 /* Flooding new LSA. only to AS (non-NSSA/STUB) */
2248 ospf_flood_through_as(ospf
, NULL
, new);
2250 /* If there is any attached NSSA, do special handling */
2251 if (ospf
->anyNSSA
&&
2252 /* stay away from translated LSAs! */
2253 !(CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
)))
2254 ospf_install_flood_nssa(
2255 ospf
, new, ei
); /* Install/Flood Type-7 to all NSSAs */
2257 /* Debug logging. */
2258 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
2259 zlog_debug("LSA[Type%d:%pI4]: Originate AS-external-LSA %p",
2260 new->data
->type
, &new->data
->id
,
2262 ospf_lsa_header_dump(new->data
);
2268 static struct external_info
*ospf_default_external_info(struct ospf
*ospf
)
2271 struct prefix_ipv4 p
;
2272 struct external_info
*default_ei
;
2276 p
.prefix
.s_addr
= 0;
2279 default_ei
= ospf_external_info_lookup(ospf
, DEFAULT_ROUTE
, 0, &p
);
2283 /* First, lookup redistributed default route. */
2284 for (type
= 0; type
<= ZEBRA_ROUTE_MAX
; type
++) {
2285 struct list
*ext_list
;
2287 if (type
== ZEBRA_ROUTE_OSPF
)
2290 ext_list
= ospf
->external
[type
];
2294 ret
= ospf_external_default_routemap_apply_walk(ospf
, ext_list
,
2303 void ospf_external_lsa_rid_change(struct ospf
*ospf
)
2305 struct external_info
*ei
;
2306 struct ospf_external_aggr_rt
*aggr
;
2307 struct ospf_lsa
*lsa
= NULL
;
2311 for (type
= 0; type
< ZEBRA_ROUTE_MAX
; type
++) {
2312 struct route_node
*rn
;
2313 struct route_table
*rt
;
2314 struct list
*ext_list
;
2315 struct listnode
*node
;
2316 struct ospf_external
*ext
;
2318 ext_list
= ospf
->external
[type
];
2322 for (ALL_LIST_ELEMENTS_RO(ext_list
, node
, ext
)) {
2323 /* Originate As-external-LSA from all type of
2324 * distribute source.
2326 rt
= ext
->external_info
;
2330 for (rn
= route_top(rt
); rn
; rn
= route_next(rn
)) {
2336 if (is_default_prefix4(&ei
->p
))
2339 lsa
= ospf_external_info_find_lsa(ospf
, &ei
->p
);
2341 aggr
= ospf_external_aggr_match(ospf
, &ei
->p
);
2344 if (!ospf_redistribute_check(ospf
, ei
,
2348 if (IS_DEBUG_OSPF(lsa
, EXTNL_LSA_AGGR
))
2350 "Originate Summary LSA after reset/router-ID change");
2352 /* Here the LSA is originated as new */
2353 ospf_originate_summary_lsa(ospf
, aggr
,
2356 /* LSA needs to be refreshed even if
2357 * there is no change in the route
2358 * params if the LSA is in maxage.
2360 if (IS_LSA_MAXAGE(lsa
))
2361 force
= LSA_REFRESH_FORCE
;
2363 force
= LSA_REFRESH_IF_CHANGED
;
2365 ospf_external_lsa_refresh(ospf
, lsa
,
2368 if (!ospf_redistribute_check(ospf
, ei
,
2372 if (!ospf_external_lsa_originate(ospf
,
2375 EC_OSPF_LSA_INSTALL_FAILURE
,
2376 "LSA: AS-external-LSA was not originated.");
2382 ei
= ospf_default_external_info(ospf
);
2383 if (ei
&& !ospf_external_lsa_originate(ospf
, ei
)) {
2384 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE
,
2385 "LSA: AS-external-LSA for default route was not originated.");
2389 /* Flush any NSSA LSAs for given prefix */
2390 void ospf_nssa_lsa_flush(struct ospf
*ospf
, struct prefix_ipv4
*p
)
2392 struct listnode
*node
, *nnode
;
2393 struct ospf_lsa
*lsa
= NULL
;
2394 struct ospf_area
*area
;
2396 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
2397 if (area
->external_routing
== OSPF_AREA_NSSA
) {
2398 lsa
= ospf_lsa_lookup(ospf
, area
, OSPF_AS_NSSA_LSA
,
2399 p
->prefix
, ospf
->router_id
);
2401 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2403 "LSA: There is no such AS-NSSA-LSA %pFX in LSDB",
2407 ospf_ls_retransmit_delete_nbr_area(area
, lsa
);
2408 if (!IS_LSA_MAXAGE(lsa
)) {
2409 ospf_refresher_unregister_lsa(ospf
, lsa
);
2410 ospf_lsa_flush_area(lsa
, area
);
2416 /* Flush an AS-external-LSA from LSDB and routing domain. */
2417 void ospf_external_lsa_flush(struct ospf
*ospf
, uint8_t type
,
2418 struct prefix_ipv4
*p
,
2419 ifindex_t ifindex
/*, struct in_addr nexthop */)
2421 struct ospf_lsa
*lsa
;
2423 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2424 zlog_debug("LSA: Flushing AS-external-LSA %pFX", p
);
2426 /* First lookup LSA from LSDB. */
2427 if (!(lsa
= ospf_external_info_find_lsa(ospf
, p
))) {
2428 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2430 "LSA: There is no such AS-external-LSA %pFX in LSDB",
2435 /* If LSA is selforiginated, not a translated LSA, and there is
2436 * NSSA area, flush Type-7 LSA's at first.
2438 if (IS_LSA_SELF(lsa
) && (ospf
->anyNSSA
)
2439 && !(CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
)))
2440 ospf_nssa_lsa_flush(ospf
, p
);
2442 if (!IS_LSA_MAXAGE(lsa
)) {
2443 /* Sweep LSA from Link State Retransmit List. */
2444 ospf_ls_retransmit_delete_nbr_as(ospf
, lsa
);
2446 /* Unregister LSA from Refresh queue. */
2447 ospf_refresher_unregister_lsa(ospf
, lsa
);
2449 /* Flush AS-external-LSA through AS. */
2450 ospf_lsa_flush_as(ospf
, lsa
);
2453 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2454 zlog_debug("%s: stop", __func__
);
2457 void ospf_external_lsa_refresh_default(struct ospf
*ospf
)
2459 struct prefix_ipv4 p
;
2460 struct external_info
*ei
;
2461 struct ospf_lsa
*lsa
;
2465 p
.prefix
.s_addr
= INADDR_ANY
;
2467 ei
= ospf_default_external_info(ospf
);
2468 lsa
= ospf_external_info_find_lsa(ospf
, &p
);
2471 if (IS_DEBUG_OSPF_EVENT
)
2472 zlog_debug("LSA[Type5:0.0.0.0]: Refresh AS-external-LSA %p",
2474 ospf_external_lsa_refresh(ospf
, lsa
, ei
, LSA_REFRESH_FORCE
,
2476 } else if (ei
&& !lsa
) {
2477 if (IS_DEBUG_OSPF_EVENT
)
2479 "LSA[Type5:0.0.0.0]: Originate AS-external-LSA");
2480 ospf_external_lsa_originate(ospf
, ei
);
2482 if (IS_DEBUG_OSPF_EVENT
)
2483 zlog_debug("LSA[Type5:0.0.0.0]: Flush AS-external-LSA");
2484 ospf_external_lsa_flush(ospf
, DEFAULT_ROUTE
, &p
, 0);
2488 void ospf_external_lsa_refresh_type(struct ospf
*ospf
, uint8_t type
,
2489 unsigned short instance
, int force
)
2491 struct route_node
*rn
;
2492 struct external_info
*ei
;
2493 struct ospf_external
*ext
;
2495 if (type
== DEFAULT_ROUTE
)
2498 ext
= ospf_external_lookup(ospf
, type
, instance
);
2500 if (ext
&& EXTERNAL_INFO(ext
)) {
2501 /* Refresh each redistributed AS-external-LSAs. */
2502 for (rn
= route_top(EXTERNAL_INFO(ext
)); rn
;
2503 rn
= route_next(rn
)) {
2506 if (!is_default_prefix4(&ei
->p
)) {
2507 struct ospf_lsa
*lsa
;
2508 struct ospf_external_aggr_rt
*aggr
;
2510 aggr
= ospf_external_aggr_match(ospf
,
2512 lsa
= ospf_external_info_find_lsa(
2515 /* Check the AS-external-LSA
2516 * should be originated.
2518 if (!ospf_redistribute_check(
2521 ospf_unlink_ei_from_aggr(
2530 "%s: Send Aggreate LSA (%pFX)",
2534 ospf_originate_summary_lsa(
2539 if (IS_LSA_MAXAGE(lsa
))
2540 force
= LSA_REFRESH_FORCE
;
2542 ospf_external_lsa_refresh(
2543 ospf
, lsa
, ei
, force
,
2546 if (!ospf_redistribute_check(
2549 ospf_external_lsa_originate(
2558 /* Refresh AS-external-LSA. */
2559 struct ospf_lsa
*ospf_external_lsa_refresh(struct ospf
*ospf
,
2560 struct ospf_lsa
*lsa
,
2561 struct external_info
*ei
, int force
,
2564 struct ospf_lsa
*new;
2567 /* Check the AS-external-LSA should be originated. */
2569 if (!ospf_redistribute_check(ospf
, ei
, &changed
)) {
2570 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2572 "LSA[Type%d:%pI4] Could not be refreshed, redist check fail",
2576 ospf_external_lsa_flush(ospf
, ei
->type
, &ei
->p
,
2577 ei
->ifindex
/*, ei->nexthop */);
2581 if (!changed
&& !force
) {
2582 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2584 "LSA[Type%d:%pI4]: Not refreshed, not changed/forced",
2585 lsa
->data
->type
, &lsa
->data
->id
);
2589 /* Delete LSA from neighbor retransmit-list. */
2590 ospf_ls_retransmit_delete_nbr_as(ospf
, lsa
);
2592 /* Unregister AS-external-LSA from refresh-list. */
2593 ospf_refresher_unregister_lsa(ospf
, lsa
);
2595 new = ospf_external_lsa_new(ospf
, ei
, &lsa
->data
->id
);
2598 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2599 zlog_debug("LSA[Type%d:%pI4]: Could not be refreshed",
2600 lsa
->data
->type
, &lsa
->data
->id
);
2604 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
2606 ospf_lsa_install(ospf
, NULL
, new); /* As type-5. */
2608 /* Flood LSA through AS. */
2609 ospf_flood_through_as(ospf
, NULL
, new);
2611 /* If any attached NSSA, install as Type-7, flood to all NSSA Areas */
2612 if (ospf
->anyNSSA
&& !(CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
)))
2613 ospf_install_flood_nssa(ospf
, new,
2614 ei
); /* Install/Flood per new rules */
2616 /* Register self-originated LSA to refresh queue.
2617 * Translated LSAs should not be registered, but refreshed upon
2618 * refresh of the Type-7
2620 if (!CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
))
2621 ospf_refresher_register_lsa(ospf
, new);
2623 /* Debug logging. */
2624 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
2625 zlog_debug("LSA[Type%d:%pI4]: AS-external-LSA refresh",
2626 new->data
->type
, &new->data
->id
);
2627 ospf_lsa_header_dump(new->data
);
2634 /* LSA installation functions. */
2636 /* Install router-LSA to an area. */
2637 static struct ospf_lsa
*
2638 ospf_router_lsa_install(struct ospf
*ospf
, struct ospf_lsa
*new, int rt_recalc
)
2640 struct ospf_area
*area
= new->area
;
2642 /* RFC 2328 Section 13.2 Router-LSAs and network-LSAs
2643 The entire routing table must be recalculated, starting with
2644 the shortest path calculations for each area (not just the
2645 area whose link-state database has changed).
2648 if (IS_LSA_SELF(new)) {
2650 /* Only install LSA if it is originated/refreshed by us.
2651 * If LSA was received by flooding, the RECEIVED flag is set so
2653 * not link the LSA */
2654 if (CHECK_FLAG(new->flags
, OSPF_LSA_RECEIVED
))
2655 return new; /* ignore stale LSA */
2657 /* Set self-originated router-LSA. */
2658 ospf_lsa_unlock(&area
->router_lsa_self
);
2659 area
->router_lsa_self
= ospf_lsa_lock(new);
2661 ospf_refresher_register_lsa(ospf
, new);
2664 ospf_spf_calculate_schedule(ospf
, SPF_FLAG_ROUTER_LSA_INSTALL
);
2668 /* Install network-LSA to an area. */
2669 static struct ospf_lsa
*ospf_network_lsa_install(struct ospf
*ospf
,
2670 struct ospf_interface
*oi
,
2671 struct ospf_lsa
*new,
2675 /* RFC 2328 Section 13.2 Router-LSAs and network-LSAs
2676 The entire routing table must be recalculated, starting with
2677 the shortest path calculations for each area (not just the
2678 area whose link-state database has changed).
2680 if (IS_LSA_SELF(new)) {
2681 /* We supposed that when LSA is originated by us, we pass the
2683 for which it was originated. If LSA was received by flooding,
2684 the RECEIVED flag is set, so we do not link the LSA to the
2686 if (CHECK_FLAG(new->flags
, OSPF_LSA_RECEIVED
))
2687 return new; /* ignore stale LSA */
2689 ospf_lsa_unlock(&oi
->network_lsa_self
);
2690 oi
->network_lsa_self
= ospf_lsa_lock(new);
2691 ospf_refresher_register_lsa(ospf
, new);
2694 ospf_spf_calculate_schedule(ospf
, SPF_FLAG_NETWORK_LSA_INSTALL
);
2699 /* Install summary-LSA to an area. */
2700 static struct ospf_lsa
*
2701 ospf_summary_lsa_install(struct ospf
*ospf
, struct ospf_lsa
*new, int rt_recalc
)
2703 if (rt_recalc
&& !IS_LSA_SELF(new)) {
2704 /* RFC 2328 Section 13.2 Summary-LSAs
2705 The best route to the destination described by the summary-
2706 LSA must be recalculated (see Section 16.5). If this
2707 destination is an AS boundary router, it may also be
2708 necessary to re-examine all the AS-external-LSAs.
2711 ospf_spf_calculate_schedule(ospf
, SPF_FLAG_SUMMARY_LSA_INSTALL
);
2714 if (IS_LSA_SELF(new))
2715 ospf_refresher_register_lsa(ospf
, new);
2720 /* Install ASBR-summary-LSA to an area. */
2721 static struct ospf_lsa
*ospf_summary_asbr_lsa_install(struct ospf
*ospf
,
2722 struct ospf_lsa
*new,
2725 if (rt_recalc
&& !IS_LSA_SELF(new)) {
2726 /* RFC 2328 Section 13.2 Summary-LSAs
2727 The best route to the destination described by the summary-
2728 LSA must be recalculated (see Section 16.5). If this
2729 destination is an AS boundary router, it may also be
2730 necessary to re-examine all the AS-external-LSAs.
2732 ospf_spf_calculate_schedule(ospf
,
2733 SPF_FLAG_ASBR_SUMMARY_LSA_INSTALL
);
2736 /* register LSA to refresh-list. */
2737 if (IS_LSA_SELF(new))
2738 ospf_refresher_register_lsa(ospf
, new);
2743 /* Install AS-external-LSA. */
2744 static struct ospf_lsa
*ospf_external_lsa_install(struct ospf
*ospf
,
2745 struct ospf_lsa
*new,
2748 ospf_ase_register_external_lsa(new, ospf
);
2749 /* If LSA is not self-originated, calculate an external route. */
2751 /* RFC 2328 Section 13.2 AS-external-LSAs
2752 The best route to the destination described by the AS-
2753 external-LSA must be recalculated (see Section 16.6).
2756 if (!IS_LSA_SELF(new))
2757 ospf_ase_incremental_update(ospf
, new);
2760 if (new->data
->type
== OSPF_AS_NSSA_LSA
) {
2761 /* There is no point to register selforiginate Type-7 LSA for
2762 * refreshing. We rely on refreshing Type-5 LSA's
2764 if (IS_LSA_SELF(new))
2767 /* Try refresh type-5 translated LSA for this LSA, if
2769 * New translations will be taken care of by the
2772 ospf_translated_nssa_refresh(ospf
, new, NULL
);
2773 ospf_schedule_abr_task(ospf
);
2777 /* Register self-originated LSA to refresh queue.
2778 * Leave Translated LSAs alone if NSSA is enabled
2780 if (IS_LSA_SELF(new) && !CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
))
2781 ospf_refresher_register_lsa(ospf
, new);
2786 void ospf_discard_from_db(struct ospf
*ospf
, struct ospf_lsdb
*lsdb
,
2787 struct ospf_lsa
*lsa
)
2789 struct ospf_lsa
*old
;
2794 old
= ospf_lsdb_lookup(lsdb
, lsa
);
2799 if (old
->refresh_list
>= 0)
2800 ospf_refresher_unregister_lsa(ospf
, old
);
2802 switch (old
->data
->type
) {
2803 case OSPF_AS_EXTERNAL_LSA
:
2804 ospf_ase_unregister_external_lsa(old
, ospf
);
2805 ospf_ls_retransmit_delete_nbr_as(ospf
, old
);
2807 case OSPF_OPAQUE_AS_LSA
:
2808 ospf_ls_retransmit_delete_nbr_as(ospf
, old
);
2810 case OSPF_AS_NSSA_LSA
:
2811 ospf_ls_retransmit_delete_nbr_area(old
->area
, old
);
2812 ospf_ase_unregister_external_lsa(old
, ospf
);
2815 ospf_ls_retransmit_delete_nbr_area(old
->area
, old
);
2819 ospf_lsa_maxage_delete(ospf
, old
);
2820 ospf_lsa_discard(old
);
2823 struct ospf_lsa
*ospf_lsa_install(struct ospf
*ospf
, struct ospf_interface
*oi
,
2824 struct ospf_lsa
*lsa
)
2826 struct ospf_lsa
*new = NULL
;
2827 struct ospf_lsa
*old
= NULL
;
2828 struct ospf_lsdb
*lsdb
= NULL
;
2832 switch (lsa
->data
->type
) {
2834 case OSPF_AS_NSSA_LSA
:
2836 lsdb
= lsa
->area
->lsdb
;
2840 case OSPF_AS_EXTERNAL_LSA
:
2841 case OSPF_OPAQUE_AS_LSA
:
2846 lsdb
= lsa
->area
->lsdb
;
2852 /* RFC 2328 13.2. Installing LSAs in the database
2854 Installing a new LSA in the database, either as the result of
2855 flooding or a newly self-originated LSA, may cause the OSPF
2856 routing table structure to be recalculated. The contents of the
2857 new LSA should be compared to the old instance, if present. If
2858 there is no difference, there is no need to recalculate the
2859 routing table. When comparing an LSA to its previous instance,
2860 the following are all considered to be differences in contents:
2862 o The LSA's Options field has changed.
2864 o One of the LSA instances has LS age set to MaxAge, and
2867 o The length field in the LSA header has changed.
2869 o The body of the LSA (i.e., anything outside the 20-byte
2870 LSA header) has changed. Note that this excludes changes
2871 in LS Sequence Number and LS Checksum.
2874 /* Look up old LSA and determine if any SPF calculation or incremental
2876 old
= ospf_lsdb_lookup(lsdb
, lsa
);
2878 /* Do comparison and record if recalc needed. */
2880 if (old
== NULL
|| ospf_lsa_different(old
, lsa
, false)) {
2881 /* Ref rfc3623 section 3.2.3
2882 * Installing new lsa or change in the existing LSA
2883 * or flushing existing LSA leads to topo change
2884 * and trigger SPF caculation.
2885 * So, router should be aborted from HELPER role
2886 * if it is detected as TOPO change.
2888 if (ospf
->active_restarter_cnt
&&
2889 CHECK_LSA_TYPE_1_TO_5_OR_7(lsa
->data
->type
)) {
2890 if (old
== NULL
|| ospf_lsa_different(old
, lsa
, true))
2891 ospf_helper_handle_topo_chg(ospf
, lsa
);
2898 Sequence number check (Section 14.1 of rfc 2328)
2899 "Premature aging is used when it is time for a self-originated
2900 LSA's sequence number field to wrap. At this point, the current
2901 LSA instance (having LS sequence number MaxSequenceNumber) must
2902 be prematurely aged and flushed from the routing domain before a
2903 new instance with sequence number equal to InitialSequenceNumber
2904 can be originated. "
2907 if (ntohl(lsa
->data
->ls_seqnum
) - 1 == OSPF_MAX_SEQUENCE_NUMBER
) {
2908 if (ospf_lsa_is_self_originated(ospf
, lsa
)) {
2909 lsa
->data
->ls_seqnum
= htonl(OSPF_MAX_SEQUENCE_NUMBER
);
2911 if (!IS_LSA_MAXAGE(lsa
))
2912 lsa
->flags
|= OSPF_LSA_PREMATURE_AGE
;
2913 lsa
->data
->ls_age
= htons(OSPF_LSA_MAXAGE
);
2915 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
)) {
2917 "%s() Premature Aging lsa %p, seqnum 0x%x",
2919 ntohl(lsa
->data
->ls_seqnum
));
2920 ospf_lsa_header_dump(lsa
->data
);
2923 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
2925 "%s() got an lsa with seq 0x80000000 that was not self originated. Ignoring",
2927 ospf_lsa_header_dump(lsa
->data
);
2933 /* discard old LSA from LSDB */
2935 ospf_discard_from_db(ospf
, lsdb
, lsa
);
2937 /* Calculate Checksum if self-originated?. */
2938 if (IS_LSA_SELF(lsa
))
2939 ospf_lsa_checksum(lsa
->data
);
2941 /* Insert LSA to LSDB. */
2942 ospf_lsdb_add(lsdb
, lsa
);
2945 /* Do LSA specific installation process. */
2946 switch (lsa
->data
->type
) {
2947 case OSPF_ROUTER_LSA
:
2948 new = ospf_router_lsa_install(ospf
, lsa
, rt_recalc
);
2950 case OSPF_NETWORK_LSA
:
2952 new = ospf_network_lsa_install(ospf
, oi
, lsa
, rt_recalc
);
2954 case OSPF_SUMMARY_LSA
:
2955 new = ospf_summary_lsa_install(ospf
, lsa
, rt_recalc
);
2957 case OSPF_ASBR_SUMMARY_LSA
:
2958 new = ospf_summary_asbr_lsa_install(ospf
, lsa
, rt_recalc
);
2960 case OSPF_AS_EXTERNAL_LSA
:
2961 new = ospf_external_lsa_install(ospf
, lsa
, rt_recalc
);
2963 case OSPF_OPAQUE_LINK_LSA
:
2964 if (IS_LSA_SELF(lsa
))
2965 lsa
->oi
= oi
; /* Specify outgoing ospf-interface for
2968 /* Incoming "oi" for this LSA has set at LSUpd
2972 case OSPF_OPAQUE_AREA_LSA
:
2973 case OSPF_OPAQUE_AS_LSA
:
2974 new = ospf_opaque_lsa_install(lsa
, rt_recalc
);
2976 case OSPF_AS_NSSA_LSA
:
2977 new = ospf_external_lsa_install(ospf
, lsa
, rt_recalc
);
2978 default: /* type-6,8,9....nothing special */
2983 return new; /* Installation failed, cannot proceed further --
2987 if (IS_DEBUG_OSPF(lsa
, LSA_INSTALL
)) {
2988 switch (lsa
->data
->type
) {
2989 case OSPF_AS_EXTERNAL_LSA
:
2990 case OSPF_OPAQUE_AS_LSA
:
2991 case OSPF_AS_NSSA_LSA
:
2992 zlog_debug("LSA[%s]: Install %s", dump_lsa_key(new),
2993 lookup_msg(ospf_lsa_type_msg
,
2994 new->data
->type
, NULL
));
2997 zlog_debug("LSA[%s]: Install %s to Area %pI4",
2999 lookup_msg(ospf_lsa_type_msg
,
3000 new->data
->type
, NULL
),
3001 &new->area
->area_id
);
3007 If received LSA' ls_age is MaxAge, or lsa is being prematurely aged
3008 (it's getting flushed out of the area), set LSA on MaxAge LSA list.
3010 if (IS_LSA_MAXAGE(new)) {
3011 if (IS_DEBUG_OSPF(lsa
, LSA_INSTALL
))
3012 zlog_debug("LSA[%s]: Install LSA %p, MaxAge",
3013 dump_lsa_key(new), lsa
);
3014 ospf_lsa_maxage(ospf
, lsa
);
3021 int ospf_check_nbr_status(struct ospf
*ospf
)
3023 struct listnode
*node
, *nnode
;
3024 struct ospf_interface
*oi
;
3026 for (ALL_LIST_ELEMENTS(ospf
->oiflist
, node
, nnode
, oi
)) {
3027 struct route_node
*rn
;
3028 struct ospf_neighbor
*nbr
;
3030 if (ospf_if_is_enable(oi
))
3031 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
3032 if ((nbr
= rn
->info
) != NULL
)
3033 if (nbr
->state
== NSM_Exchange
3034 || nbr
->state
== NSM_Loading
) {
3035 route_unlock_node(rn
);
3044 void ospf_maxage_lsa_remover(struct thread
*thread
)
3046 struct ospf
*ospf
= THREAD_ARG(thread
);
3047 struct ospf_lsa
*lsa
, *old
;
3048 struct route_node
*rn
;
3051 ospf
->t_maxage
= NULL
;
3053 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3054 zlog_debug("LSA[MaxAge]: remover Start");
3056 reschedule
= !ospf_check_nbr_status(ospf
);
3059 for (rn
= route_top(ospf
->maxage_lsa
); rn
;
3060 rn
= route_next(rn
)) {
3061 if ((lsa
= rn
->info
) == NULL
) {
3065 /* There is at least one neighbor from which we still
3067 * for that LSA, so we are not allowed to remove it from
3069 * as per RFC 2328 section 14 para 4 a) */
3070 if (lsa
->retransmit_counter
> 0) {
3075 /* TODO: maybe convert this function to a work-queue */
3076 if (thread_should_yield(thread
)) {
3077 OSPF_TIMER_ON(ospf
->t_maxage
,
3078 ospf_maxage_lsa_remover
, 0);
3080 rn
); /* route_top/route_next */
3084 /* Remove LSA from the LSDB */
3085 if (IS_LSA_SELF(lsa
))
3086 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3088 "LSA[Type%d:%pI4]: LSA 0x%lx is self-originated: ",
3091 (unsigned long)lsa
);
3093 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3095 "LSA[%s]: MaxAge LSA removed from list",
3098 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_PREMATURE_AGE
)) {
3099 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3101 "originating new lsa for lsa %p",
3103 ospf_lsa_refresh(ospf
, lsa
);
3106 /* Remove from lsdb. */
3108 old
= ospf_lsdb_lookup(lsa
->lsdb
, lsa
);
3109 /* The max age LSA here must be the same
3110 * as the LSA in LSDB
3113 flog_err(EC_OSPF_LSA_MISSING
,
3114 "%s: LSA[%s]: LSA not in LSDB",
3115 __func__
, dump_lsa_key(lsa
));
3119 ospf_discard_from_db(ospf
, lsa
->lsdb
, lsa
);
3120 ospf_lsdb_delete(lsa
->lsdb
, lsa
);
3122 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3124 "%s: LSA[%s]: No associated LSDB!",
3125 __func__
, dump_lsa_key(lsa
));
3129 /* A MaxAge LSA must be removed immediately from the router's link
3130 state database as soon as both a) it is no longer contained on any
3131 neighbor Link state retransmission lists and b) none of the
3133 neighbors are in states Exchange or Loading. */
3135 OSPF_TIMER_ON(ospf
->t_maxage
, ospf_maxage_lsa_remover
,
3136 ospf
->maxage_delay
);
3139 /* This function checks whether an LSA with initial sequence number should be
3140 * originated after a wrap in sequence number
3142 void ospf_check_and_gen_init_seq_lsa(struct ospf_interface
*oi
,
3143 struct ospf_lsa
*recv_lsa
)
3145 struct ospf_lsa
*lsa
= NULL
;
3146 struct ospf
*ospf
= oi
->ospf
;
3148 lsa
= ospf_lsa_lookup_by_header(oi
->area
, recv_lsa
->data
);
3150 if ((lsa
== NULL
) || (!CHECK_FLAG(lsa
->flags
, OSPF_LSA_PREMATURE_AGE
))
3151 || (lsa
->retransmit_counter
!= 0)) {
3152 if (IS_DEBUG_OSPF(lsa
, LSA
))
3154 "Do not generate LSA with initial seqence number.");
3158 ospf_lsa_maxage_delete(ospf
, lsa
);
3160 lsa
->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
3162 ospf_lsa_refresh(ospf
, lsa
);
3165 void ospf_lsa_maxage_delete(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3167 struct route_node
*rn
;
3168 struct prefix lsa_prefix
;
3170 memset(&lsa_prefix
, 0, sizeof(lsa_prefix
));
3171 lsa_prefix
.family
= AF_UNSPEC
;
3172 lsa_prefix
.prefixlen
= sizeof(lsa_prefix
.u
.ptr
) * CHAR_BIT
;
3173 lsa_prefix
.u
.ptr
= (uintptr_t)lsa
;
3175 if ((rn
= route_node_lookup(ospf
->maxage_lsa
, &lsa_prefix
))) {
3176 if (rn
->info
== lsa
) {
3177 UNSET_FLAG(lsa
->flags
, OSPF_LSA_IN_MAXAGE
);
3178 ospf_lsa_unlock(&lsa
); /* maxage_lsa */
3181 rn
); /* unlock node because lsa is deleted */
3183 route_unlock_node(rn
); /* route_node_lookup */
3185 if (IS_DEBUG_OSPF_EVENT
)
3186 zlog_debug("%s: lsa %s is not found in maxage db.",
3187 __func__
, dump_lsa_key(lsa
));
3191 /* Add LSA onto the MaxAge list, and schedule for removal.
3192 * This does *not* lead to the LSA being flooded, that must be taken
3193 * care of elsewhere, see, e.g., ospf_lsa_flush* (which are callers of this
3196 void ospf_lsa_maxage(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3198 struct prefix lsa_prefix
;
3199 struct route_node
*rn
;
3201 /* When we saw a MaxAge LSA flooded to us, we put it on the list
3202 and schedule the MaxAge LSA remover. */
3203 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_IN_MAXAGE
)) {
3204 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3206 "LSA[%s]: %p already exists on MaxAge LSA list",
3207 dump_lsa_key(lsa
), lsa
);
3211 memset(&lsa_prefix
, 0, sizeof(lsa_prefix
));
3212 lsa_prefix
.family
= AF_UNSPEC
;
3213 lsa_prefix
.prefixlen
= sizeof(lsa_prefix
.u
.ptr
) * CHAR_BIT
;
3214 lsa_prefix
.u
.ptr
= (uintptr_t)lsa
;
3216 rn
= route_node_get(ospf
->maxage_lsa
, &lsa_prefix
);
3217 if (rn
->info
!= NULL
) {
3218 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3220 "LSA[%s]: found LSA (%p) in table for LSA %p %d",
3221 dump_lsa_key(lsa
), rn
->info
,
3222 (void *)lsa
, lsa_prefix
.prefixlen
);
3223 route_unlock_node(rn
);
3225 rn
->info
= ospf_lsa_lock(lsa
);
3226 SET_FLAG(lsa
->flags
, OSPF_LSA_IN_MAXAGE
);
3229 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3230 zlog_debug("LSA[%s]: MaxAge LSA remover scheduled.",
3233 OSPF_TIMER_ON(ospf
->t_maxage
, ospf_maxage_lsa_remover
,
3234 ospf
->maxage_delay
);
3237 static int ospf_lsa_maxage_walker_remover(struct ospf
*ospf
,
3238 struct ospf_lsa
*lsa
)
3240 /* Stay away from any Local Translated Type-7 LSAs */
3241 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
))
3244 if (IS_LSA_MAXAGE(lsa
))
3245 /* Self-originated LSAs should NOT time-out instead,
3246 they're flushed and submitted to the max_age list explicitly.
3248 if (!ospf_lsa_is_self_originated(ospf
, lsa
)) {
3249 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3250 zlog_debug("LSA[%s]: is MaxAge",
3253 switch (lsa
->data
->type
) {
3254 case OSPF_OPAQUE_LINK_LSA
:
3255 case OSPF_OPAQUE_AREA_LSA
:
3256 case OSPF_OPAQUE_AS_LSA
:
3258 * As a general rule, whenever network topology
3260 * (due to an LSA removal in this case), routing
3262 * should be triggered. However, this is not
3264 * LSAs. Even if an opaque LSA instance is going
3266 * from the routing domain, it does not mean a
3268 * topology, and thus, routing recalculation is
3272 case OSPF_AS_EXTERNAL_LSA
:
3273 case OSPF_AS_NSSA_LSA
:
3274 ospf_ase_incremental_update(ospf
, lsa
);
3277 ospf_spf_calculate_schedule(ospf
,
3281 ospf_lsa_maxage(ospf
, lsa
);
3284 if (IS_LSA_MAXAGE(lsa
) && !ospf_lsa_is_self_originated(ospf
, lsa
))
3285 if (LS_AGE(lsa
) > OSPF_LSA_MAXAGE
+ 30)
3286 printf("Eek! Shouldn't happen!\n");
3291 /* Periodical check of MaxAge LSA. */
3292 void ospf_lsa_maxage_walker(struct thread
*thread
)
3294 struct ospf
*ospf
= THREAD_ARG(thread
);
3295 struct route_node
*rn
;
3296 struct ospf_lsa
*lsa
;
3297 struct ospf_area
*area
;
3298 struct listnode
*node
, *nnode
;
3300 ospf
->t_maxage_walker
= NULL
;
3302 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
3303 LSDB_LOOP (ROUTER_LSDB(area
), rn
, lsa
)
3304 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3305 LSDB_LOOP (NETWORK_LSDB(area
), rn
, lsa
)
3306 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3307 LSDB_LOOP (SUMMARY_LSDB(area
), rn
, lsa
)
3308 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3309 LSDB_LOOP (ASBR_SUMMARY_LSDB(area
), rn
, lsa
)
3310 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3311 LSDB_LOOP (OPAQUE_AREA_LSDB(area
), rn
, lsa
)
3312 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3313 LSDB_LOOP (OPAQUE_LINK_LSDB(area
), rn
, lsa
)
3314 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3315 LSDB_LOOP (NSSA_LSDB(area
), rn
, lsa
)
3316 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3319 /* for AS-external-LSAs. */
3321 LSDB_LOOP (EXTERNAL_LSDB(ospf
), rn
, lsa
)
3322 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3323 LSDB_LOOP (OPAQUE_AS_LSDB(ospf
), rn
, lsa
)
3324 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3327 OSPF_TIMER_ON(ospf
->t_maxage_walker
, ospf_lsa_maxage_walker
,
3328 OSPF_LSA_MAXAGE_CHECK_INTERVAL
);
3331 struct ospf_lsa
*ospf_lsa_lookup_by_prefix(struct ospf_lsdb
*lsdb
, uint8_t type
,
3332 struct prefix_ipv4
*p
,
3333 struct in_addr router_id
)
3335 struct ospf_lsa
*lsa
;
3336 struct in_addr mask
, id
;
3337 struct lsa_header_mask
{
3338 struct lsa_header header
;
3339 struct in_addr mask
;
3342 lsa
= ospf_lsdb_lookup_by_id(lsdb
, type
, p
->prefix
, router_id
);
3346 masklen2ip(p
->prefixlen
, &mask
);
3348 hmask
= (struct lsa_header_mask
*)lsa
->data
;
3350 if (mask
.s_addr
!= hmask
->mask
.s_addr
) {
3351 id
.s_addr
= p
->prefix
.s_addr
| (~mask
.s_addr
);
3352 lsa
= ospf_lsdb_lookup_by_id(lsdb
, type
, id
, router_id
);
3360 struct ospf_lsa
*ospf_lsa_lookup(struct ospf
*ospf
, struct ospf_area
*area
,
3361 uint32_t type
, struct in_addr id
,
3362 struct in_addr adv_router
)
3368 case OSPF_ROUTER_LSA
:
3369 case OSPF_NETWORK_LSA
:
3370 case OSPF_SUMMARY_LSA
:
3371 case OSPF_ASBR_SUMMARY_LSA
:
3372 case OSPF_AS_NSSA_LSA
:
3373 case OSPF_OPAQUE_LINK_LSA
:
3374 case OSPF_OPAQUE_AREA_LSA
:
3375 return ospf_lsdb_lookup_by_id(area
->lsdb
, type
, id
, adv_router
);
3376 case OSPF_AS_EXTERNAL_LSA
:
3377 case OSPF_OPAQUE_AS_LSA
:
3378 return ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, id
, adv_router
);
3386 struct ospf_lsa
*ospf_lsa_lookup_by_id(struct ospf_area
*area
, uint32_t type
,
3389 struct ospf_lsa
*lsa
;
3390 struct route_node
*rn
;
3393 case OSPF_ROUTER_LSA
:
3394 return ospf_lsdb_lookup_by_id(area
->lsdb
, type
, id
, id
);
3395 case OSPF_NETWORK_LSA
:
3396 for (rn
= route_top(NETWORK_LSDB(area
)); rn
;
3397 rn
= route_next(rn
))
3398 if ((lsa
= rn
->info
))
3399 if (IPV4_ADDR_SAME(&lsa
->data
->id
, &id
)) {
3400 route_unlock_node(rn
);
3404 case OSPF_SUMMARY_LSA
:
3405 case OSPF_ASBR_SUMMARY_LSA
:
3406 /* Currently not used. */
3408 return ospf_lsdb_lookup_by_id(area
->lsdb
, type
, id
, id
);
3409 case OSPF_AS_EXTERNAL_LSA
:
3410 case OSPF_AS_NSSA_LSA
:
3411 case OSPF_OPAQUE_LINK_LSA
:
3412 case OSPF_OPAQUE_AREA_LSA
:
3413 case OSPF_OPAQUE_AS_LSA
:
3414 /* Currently not used. */
3423 struct ospf_lsa
*ospf_lsa_lookup_by_header(struct ospf_area
*area
,
3424 struct lsa_header
*lsah
)
3426 struct ospf_lsa
*match
;
3429 * Strictly speaking, the LSA-ID field for Opaque-LSAs (type-9/10/11)
3430 * is redefined to have two subfields; opaque-type and opaque-id.
3431 * However, it is harmless to treat the two sub fields together, as if
3432 * they two were forming a unique LSA-ID.
3435 match
= ospf_lsa_lookup(area
->ospf
, area
, lsah
->type
, lsah
->id
,
3439 if (IS_DEBUG_OSPF(lsa
, LSA
) == OSPF_DEBUG_LSA
)
3440 zlog_debug("LSA[Type%d:%pI4]: Lookup by header, NO MATCH",
3441 lsah
->type
, &lsah
->id
);
3446 /* return +n, l1 is more recent.
3447 return -n, l2 is more recent.
3448 return 0, l1 and l2 is identical. */
3449 int ospf_lsa_more_recent(struct ospf_lsa
*l1
, struct ospf_lsa
*l2
)
3454 if (l1
== NULL
&& l2
== NULL
)
3461 /* compare LS sequence number. */
3462 x
= (int)ntohl(l1
->data
->ls_seqnum
);
3463 y
= (int)ntohl(l2
->data
->ls_seqnum
);
3469 /* compare LS checksum. */
3470 r
= ntohs(l1
->data
->checksum
) - ntohs(l2
->data
->checksum
);
3474 /* compare LS age. */
3475 if (IS_LSA_MAXAGE(l1
) && !IS_LSA_MAXAGE(l2
))
3477 else if (!IS_LSA_MAXAGE(l1
) && IS_LSA_MAXAGE(l2
))
3480 /* compare LS age with MaxAgeDiff. */
3481 if (LS_AGE(l1
) - LS_AGE(l2
) > OSPF_LSA_MAXAGE_DIFF
)
3483 else if (LS_AGE(l2
) - LS_AGE(l1
) > OSPF_LSA_MAXAGE_DIFF
)
3486 /* LSAs are identical. */
3491 * Check if two LSAs are different.
3494 * The first LSA to compare.
3497 * The second LSA to compare.
3500 * When set to true, ignore whether the LSAs were received from the network
3501 * or not. This parameter should be set to true when checking for topology
3502 * changes as part of the Graceful Restart helper neighbor procedures.
3505 * true if the LSAs are different, false otherwise.
3507 int ospf_lsa_different(struct ospf_lsa
*l1
, struct ospf_lsa
*l2
,
3508 bool ignore_rcvd_flag
)
3516 if (l1
->data
->options
!= l2
->data
->options
)
3519 if (IS_LSA_MAXAGE(l1
) && !IS_LSA_MAXAGE(l2
))
3522 if (IS_LSA_MAXAGE(l2
) && !IS_LSA_MAXAGE(l1
))
3525 if (l1
->size
!= l2
->size
)
3531 if (!ignore_rcvd_flag
3532 && CHECK_FLAG((l1
->flags
^ l2
->flags
), OSPF_LSA_RECEIVED
))
3533 return 1; /* May be a stale LSA in the LSBD */
3535 if (l1
->size
== OSPF_LSA_HEADER_SIZE
)
3536 return 0; /* nothing to compare */
3538 p1
= (char *)l1
->data
;
3539 p2
= (char *)l2
->data
;
3541 if (memcmp(p1
+ OSPF_LSA_HEADER_SIZE
, p2
+ OSPF_LSA_HEADER_SIZE
,
3542 l1
->size
- OSPF_LSA_HEADER_SIZE
)
3549 int ospf_lsa_flush_schedule(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3551 if (lsa
== NULL
|| !IS_LSA_SELF(lsa
))
3554 if (IS_DEBUG_OSPF_EVENT
)
3556 "LSA[Type%d:%pI4]: Schedule self-originated LSA to FLUSH",
3557 lsa
->data
->type
, &lsa
->data
->id
);
3559 /* Force given lsa's age to MaxAge. */
3560 lsa
->data
->ls_age
= htons(OSPF_LSA_MAXAGE
);
3562 switch (lsa
->data
->type
) {
3563 /* Opaque wants to be notified of flushes */
3564 case OSPF_OPAQUE_LINK_LSA
:
3565 case OSPF_OPAQUE_AREA_LSA
:
3566 case OSPF_OPAQUE_AS_LSA
:
3567 ospf_opaque_lsa_refresh(lsa
);
3570 ospf_refresher_unregister_lsa(ospf
, lsa
);
3571 ospf_lsa_flush(ospf
, lsa
);
3578 void ospf_flush_self_originated_lsas_now(struct ospf
*ospf
)
3580 struct listnode
*node
, *nnode
;
3581 struct listnode
*node2
, *nnode2
;
3582 struct ospf_area
*area
;
3583 struct ospf_interface
*oi
;
3584 struct ospf_lsa
*lsa
;
3585 struct route_node
*rn
;
3586 struct ospf_if_params
*oip
;
3587 int need_to_flush_ase
= 0;
3589 ospf
->inst_shutdown
= 1;
3591 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
3592 if ((lsa
= area
->router_lsa_self
) != NULL
) {
3593 if (IS_DEBUG_OSPF_EVENT
)
3595 "LSA[Type%d:%pI4]: Schedule self-originated LSA to FLUSH",
3599 ospf_refresher_unregister_lsa(ospf
, lsa
);
3600 ospf_lsa_flush_area(lsa
, area
);
3601 ospf_lsa_unlock(&area
->router_lsa_self
);
3602 area
->router_lsa_self
= NULL
;
3605 for (ALL_LIST_ELEMENTS(area
->oiflist
, node2
, nnode2
, oi
)) {
3606 if ((lsa
= oi
->network_lsa_self
) != NULL
3607 && oi
->state
== ISM_DR
&& oi
->full_nbrs
> 0) {
3608 if (IS_DEBUG_OSPF_EVENT
)
3610 "LSA[Type%d:%pI4]: Schedule self-originated LSA to FLUSH",
3614 ospf_refresher_unregister_lsa(
3615 ospf
, oi
->network_lsa_self
);
3616 ospf_lsa_flush_area(oi
->network_lsa_self
, area
);
3617 ospf_lsa_unlock(&oi
->network_lsa_self
);
3618 oi
->network_lsa_self
= NULL
;
3620 oip
= ospf_lookup_if_params(
3621 oi
->ifp
, oi
->address
->u
.prefix4
);
3623 oip
->network_lsa_seqnum
= htonl(
3624 OSPF_INVALID_SEQUENCE_NUMBER
);
3627 if (oi
->type
!= OSPF_IFTYPE_VIRTUALLINK
3628 && area
->external_routing
== OSPF_AREA_DEFAULT
)
3629 need_to_flush_ase
= 1;
3632 LSDB_LOOP (SUMMARY_LSDB(area
), rn
, lsa
)
3633 ospf_lsa_flush_schedule(ospf
, lsa
);
3634 LSDB_LOOP (ASBR_SUMMARY_LSDB(area
), rn
, lsa
)
3635 ospf_lsa_flush_schedule(ospf
, lsa
);
3636 LSDB_LOOP (OPAQUE_LINK_LSDB(area
), rn
, lsa
)
3637 ospf_lsa_flush_schedule(ospf
, lsa
);
3638 LSDB_LOOP (OPAQUE_AREA_LSDB(area
), rn
, lsa
)
3639 ospf_lsa_flush_schedule(ospf
, lsa
);
3642 if (need_to_flush_ase
) {
3643 LSDB_LOOP (EXTERNAL_LSDB(ospf
), rn
, lsa
)
3644 ospf_lsa_flush_schedule(ospf
, lsa
);
3645 LSDB_LOOP (OPAQUE_AS_LSDB(ospf
), rn
, lsa
)
3646 ospf_lsa_flush_schedule(ospf
, lsa
);
3650 * Make sure that the MaxAge LSA remover is executed immediately,
3651 * without conflicting to other threads.
3653 if (ospf
->t_maxage
!= NULL
) {
3654 THREAD_OFF(ospf
->t_maxage
);
3655 thread_execute(master
, ospf_maxage_lsa_remover
, ospf
, 0);
3661 /** @brief Function to refresh all the self originated
3662 * LSAs for area, when FR state change happens.
3663 * @param area pointer.
3666 void ospf_refresh_area_self_lsas(struct ospf_area
*area
)
3668 struct listnode
*node2
;
3669 struct listnode
*nnode2
;
3670 struct ospf_interface
*oi
;
3671 struct route_node
*rn
;
3672 struct ospf_lsa
*lsa
;
3677 if (area
->router_lsa_self
)
3678 ospf_lsa_refresh(area
->ospf
, area
->router_lsa_self
);
3680 for (ALL_LIST_ELEMENTS(area
->oiflist
, node2
, nnode2
, oi
))
3681 if (oi
->network_lsa_self
)
3682 ospf_lsa_refresh(oi
->ospf
, oi
->network_lsa_self
);
3684 LSDB_LOOP (SUMMARY_LSDB(area
), rn
, lsa
)
3685 if (IS_LSA_SELF(lsa
))
3686 ospf_lsa_refresh(area
->ospf
, lsa
);
3687 LSDB_LOOP (ASBR_SUMMARY_LSDB(area
), rn
, lsa
)
3688 if (IS_LSA_SELF(lsa
))
3689 ospf_lsa_refresh(area
->ospf
, lsa
);
3690 LSDB_LOOP (OPAQUE_LINK_LSDB(area
), rn
, lsa
)
3691 if (IS_LSA_SELF(lsa
))
3692 ospf_lsa_refresh(area
->ospf
, lsa
);
3693 LSDB_LOOP (OPAQUE_AREA_LSDB(area
), rn
, lsa
)
3694 if (IS_LSA_SELF(lsa
))
3695 ospf_lsa_refresh(area
->ospf
, lsa
);
3696 LSDB_LOOP (EXTERNAL_LSDB(area
->ospf
), rn
, lsa
)
3697 if (IS_LSA_SELF(lsa
))
3698 ospf_lsa_refresh(area
->ospf
, lsa
);
3699 LSDB_LOOP (OPAQUE_AS_LSDB(area
->ospf
), rn
, lsa
)
3700 if (IS_LSA_SELF(lsa
))
3701 ospf_lsa_refresh(area
->ospf
, lsa
);
3704 /* If there is self-originated LSA, then return 1, otherwise return 0. */
3705 /* An interface-independent version of ospf_lsa_is_self_originated */
3706 int ospf_lsa_is_self_originated(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3708 struct listnode
*node
;
3709 struct ospf_interface
*oi
;
3711 /* This LSA is already checked. */
3712 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_SELF_CHECKED
))
3713 return IS_LSA_SELF(lsa
);
3715 /* Make sure LSA is self-checked. */
3716 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF_CHECKED
);
3718 /* AdvRouter and Router ID is the same. */
3719 if (IPV4_ADDR_SAME(&lsa
->data
->adv_router
, &ospf
->router_id
))
3720 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF
);
3722 /* LSA is router-LSA. */
3723 else if (lsa
->data
->type
== OSPF_ROUTER_LSA
3724 && IPV4_ADDR_SAME(&lsa
->data
->id
, &ospf
->router_id
))
3725 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF
);
3727 /* LSA is network-LSA. Compare Link ID with all interfaces. */
3728 else if (lsa
->data
->type
== OSPF_NETWORK_LSA
)
3729 for (ALL_LIST_ELEMENTS_RO(ospf
->oiflist
, node
, oi
)) {
3730 /* Ignore virtual link. */
3731 if (oi
->type
!= OSPF_IFTYPE_VIRTUALLINK
)
3732 if (oi
->address
->family
== AF_INET
)
3735 &oi
->address
->u
.prefix4
)) {
3736 /* to make it easier later */
3737 SET_FLAG(lsa
->flags
,
3739 return IS_LSA_SELF(lsa
);
3743 return IS_LSA_SELF(lsa
);
3746 /* Get unique Link State ID. */
3747 enum lsid_status
ospf_lsa_unique_id(struct ospf
*ospf
, struct ospf_lsdb
*lsdb
,
3748 uint8_t type
, struct prefix_ipv4
*p
,
3751 struct ospf_lsa
*lsa
;
3752 struct in_addr mask
;
3756 /* Check existence of LSA instance. */
3757 lsa
= ospf_lsdb_lookup_by_id(lsdb
, type
, *id
, ospf
->router_id
);
3759 struct as_external_lsa
*al
=
3760 (struct as_external_lsa
*)lsa
->data
;
3761 /* Ref rfc2328,Appendex E.1
3762 * If router already originated the external lsa with lsid
3763 * as the current prefix, and the masklens are same then
3764 * terminate the LSID algorithem.
3766 if (ip_masklen(al
->mask
) == p
->prefixlen
) {
3767 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
3769 "%s: Can't get Link State ID for %pFX",
3771 /* id.s_addr = 0; */
3772 id
->s_addr
= 0xffffffff;
3773 return LSID_NOT_AVAILABLE
;
3774 } else if (ip_masklen(al
->mask
) < p
->prefixlen
) {
3775 /* Ref rfc2328,Appendex E.2
3776 * the current prefix masklen is greater than the
3777 * existing LSA, then generate the Link state ID,
3778 * by setting all host bits in prefix addressa and
3781 * Eg: 1st Route : 10.0.0.0/16 - LSID:10.0.0.0
3782 * 2nd Route : 10.0.0.0/24 - LSID:10.0.0.255
3784 masklen2ip(p
->prefixlen
, &mask
);
3786 id
->s_addr
= p
->prefix
.s_addr
| (~mask
.s_addr
);
3787 lsa
= ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, *id
,
3790 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
3792 "%s: Can't get Link State ID for %pFX",
3794 id
->s_addr
= 0xffffffff;
3795 return LSID_NOT_AVAILABLE
;
3798 /* Ref rfc2328,Appendex E.3
3799 * the current prefix masklen is lesser than the
3800 * existing LSA,then the originated LSA has to be
3801 * refreshed by modifying masklen, cost and tag.
3802 * Originate the old route info with new LSID by
3803 * setting the host bits in prefix address.
3805 * Eg: 1st Route : 10.0.0.0/24 - LSID:10.0.0.0
3806 * 2nd Route : 10.0.0.0/16 - ?
3807 * Since 2nd route mask len is less than firstone
3808 * LSID has to be changed.
3809 * 1st route LSID:10.0.0.255
3810 * 2nd route LSID:10.0.0.0
3812 id
->s_addr
= lsa
->data
->id
.s_addr
| (~al
->mask
.s_addr
);
3813 lsa
= ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, *id
,
3815 if (lsa
&& (ip_masklen(al
->mask
) != IPV4_MAX_BITLEN
)) {
3816 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
3818 "%s: Can't get Link State ID for %pFX",
3820 id
->s_addr
= 0xffffffff;
3821 return LSID_NOT_AVAILABLE
;
3827 return LSID_AVAILABLE
;
3831 #define LSA_ACTION_FLOOD_AREA 1
3832 #define LSA_ACTION_FLUSH_AREA 2
3836 struct ospf_area
*area
;
3837 struct ospf_lsa
*lsa
;
3840 static void ospf_lsa_action(struct thread
*t
)
3842 struct lsa_action
*data
;
3844 data
= THREAD_ARG(t
);
3846 if (IS_DEBUG_OSPF(lsa
, LSA
) == OSPF_DEBUG_LSA
)
3847 zlog_debug("LSA[Action]: Performing scheduled LSA action: %d",
3850 switch (data
->action
) {
3851 case LSA_ACTION_FLOOD_AREA
:
3852 ospf_flood_through_area(data
->area
, NULL
, data
->lsa
);
3854 case LSA_ACTION_FLUSH_AREA
:
3855 ospf_lsa_flush_area(data
->lsa
, data
->area
);
3859 ospf_lsa_unlock(&data
->lsa
); /* Message */
3860 XFREE(MTYPE_OSPF_MESSAGE
, data
);
3863 void ospf_schedule_lsa_flood_area(struct ospf_area
*area
, struct ospf_lsa
*lsa
)
3865 struct lsa_action
*data
;
3867 data
= XCALLOC(MTYPE_OSPF_MESSAGE
, sizeof(struct lsa_action
));
3868 data
->action
= LSA_ACTION_FLOOD_AREA
;
3870 data
->lsa
= ospf_lsa_lock(lsa
); /* Message / Flood area */
3872 thread_add_event(master
, ospf_lsa_action
, data
, 0, NULL
);
3875 void ospf_schedule_lsa_flush_area(struct ospf_area
*area
, struct ospf_lsa
*lsa
)
3877 struct lsa_action
*data
;
3879 data
= XCALLOC(MTYPE_OSPF_MESSAGE
, sizeof(struct lsa_action
));
3880 data
->action
= LSA_ACTION_FLUSH_AREA
;
3882 data
->lsa
= ospf_lsa_lock(lsa
); /* Message / Flush area */
3884 thread_add_event(master
, ospf_lsa_action
, data
, 0, NULL
);
3888 /* LSA Refreshment functions. */
3889 struct ospf_lsa
*ospf_lsa_refresh(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3891 struct external_info
*ei
;
3892 struct ospf_external_aggr_rt
*aggr
;
3893 struct ospf_lsa
*new = NULL
;
3894 struct as_external_lsa
*al
;
3895 struct prefix_ipv4 p
;
3897 assert(CHECK_FLAG(lsa
->flags
, OSPF_LSA_SELF
));
3898 assert(IS_LSA_SELF(lsa
));
3899 assert(lsa
->lock
> 0);
3901 switch (lsa
->data
->type
) {
3902 /* Router and Network LSAs are processed differently. */
3903 case OSPF_ROUTER_LSA
:
3904 new = ospf_router_lsa_refresh(lsa
);
3906 case OSPF_NETWORK_LSA
:
3907 new = ospf_network_lsa_refresh(lsa
);
3909 case OSPF_SUMMARY_LSA
:
3910 new = ospf_summary_lsa_refresh(ospf
, lsa
);
3912 case OSPF_ASBR_SUMMARY_LSA
:
3913 new = ospf_summary_asbr_lsa_refresh(ospf
, lsa
);
3915 case OSPF_AS_EXTERNAL_LSA
:
3916 /* Translated from NSSA Type-5s are refreshed when
3917 * from refresh of Type-7 - do not refresh these directly.
3920 al
= (struct as_external_lsa
*)lsa
->data
;
3922 p
.prefixlen
= ip_masklen(al
->mask
);
3923 p
.prefix
= lsa
->data
->id
;
3925 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
))
3927 ei
= ospf_external_info_check(ospf
, lsa
);
3929 new = ospf_external_lsa_refresh(
3930 ospf
, lsa
, ei
, LSA_REFRESH_FORCE
, false);
3932 aggr
= (struct ospf_external_aggr_rt
*)
3933 ospf_extrenal_aggregator_lookup(ospf
, &p
);
3935 struct external_info ei_aggr
;
3937 memset(&ei_aggr
, 0, sizeof(ei_aggr
));
3938 ei_aggr
.p
= aggr
->p
;
3939 ei_aggr
.tag
= aggr
->tag
;
3940 ei_aggr
.instance
= ospf
->instance
;
3941 ei_aggr
.route_map_set
.metric
= -1;
3942 ei_aggr
.route_map_set
.metric_type
= -1;
3944 ospf_external_lsa_refresh(ospf
, lsa
, &ei_aggr
,
3945 LSA_REFRESH_FORCE
, true);
3946 SET_FLAG(aggr
->flags
,
3947 OSPF_EXTERNAL_AGGRT_ORIGINATED
);
3949 ospf_lsa_flush_as(ospf
, lsa
);
3952 case OSPF_OPAQUE_LINK_LSA
:
3953 case OSPF_OPAQUE_AREA_LSA
:
3954 case OSPF_OPAQUE_AS_LSA
:
3955 new = ospf_opaque_lsa_refresh(lsa
);
3963 void ospf_refresher_register_lsa(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3965 uint16_t index
, current_index
;
3967 assert(lsa
->lock
> 0);
3968 assert(IS_LSA_SELF(lsa
));
3970 if (lsa
->refresh_list
< 0) {
3973 ospf
->lsa_refresh_timer
- (2 * OSPF_LS_REFRESH_JITTER
);
3975 ospf
->lsa_refresh_timer
- OSPF_LS_REFRESH_JITTER
;
3977 /* We want to refresh the LSA within OSPF_LS_REFRESH_TIME which
3979 * 1800s. Use jitter so that we send the LSA sometime between
3983 delay
= (frr_weak_random() % (max_delay
- min_delay
))
3986 current_index
= ospf
->lsa_refresh_queue
.index
3987 + (monotime(NULL
) - ospf
->lsa_refresher_started
)
3988 / OSPF_LSA_REFRESHER_GRANULARITY
;
3990 index
= (current_index
+ delay
/ OSPF_LSA_REFRESHER_GRANULARITY
)
3991 % (OSPF_LSA_REFRESHER_SLOTS
);
3993 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3995 "LSA[Refresh:Type%d:%pI4]: age %d, added to index %d",
3996 lsa
->data
->type
, &lsa
->data
->id
,
3997 LS_AGE(lsa
), index
);
3999 if (!ospf
->lsa_refresh_queue
.qs
[index
])
4000 ospf
->lsa_refresh_queue
.qs
[index
] = list_new();
4002 listnode_add(ospf
->lsa_refresh_queue
.qs
[index
],
4003 ospf_lsa_lock(lsa
)); /* lsa_refresh_queue */
4004 lsa
->refresh_list
= index
;
4006 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
4008 "LSA[Refresh:Type%d:%pI4]: %s: setting refresh_list on lsa %p (slot %d)",
4009 lsa
->data
->type
, &lsa
->data
->id
, __func__
,
4010 (void *)lsa
, index
);
4014 void ospf_refresher_unregister_lsa(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
4016 assert(lsa
->lock
> 0);
4017 assert(IS_LSA_SELF(lsa
));
4018 if (lsa
->refresh_list
>= 0) {
4019 struct list
*refresh_list
=
4020 ospf
->lsa_refresh_queue
.qs
[lsa
->refresh_list
];
4021 listnode_delete(refresh_list
, lsa
);
4022 if (!listcount(refresh_list
)) {
4023 list_delete(&refresh_list
);
4024 ospf
->lsa_refresh_queue
.qs
[lsa
->refresh_list
] = NULL
;
4026 lsa
->refresh_list
= -1;
4027 ospf_lsa_unlock(&lsa
); /* lsa_refresh_queue */
4031 void ospf_lsa_refresh_walker(struct thread
*t
)
4033 struct list
*refresh_list
;
4034 struct listnode
*node
, *nnode
;
4035 struct ospf
*ospf
= THREAD_ARG(t
);
4036 struct ospf_lsa
*lsa
;
4038 struct list
*lsa_to_refresh
= list_new();
4041 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
4042 zlog_debug("LSA[Refresh]: %s: start", __func__
);
4045 i
= ospf
->lsa_refresh_queue
.index
;
4047 /* Note: if clock has jumped backwards, then time change could be
4049 so we are careful to cast the expression to unsigned before taking
4051 ospf
->lsa_refresh_queue
.index
=
4052 ((unsigned long)(ospf
->lsa_refresh_queue
.index
4054 - ospf
->lsa_refresher_started
)
4055 / OSPF_LSA_REFRESHER_GRANULARITY
))
4056 % OSPF_LSA_REFRESHER_SLOTS
;
4058 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
4059 zlog_debug("LSA[Refresh]: %s: next index %d", __func__
,
4060 ospf
->lsa_refresh_queue
.index
);
4062 for (; i
!= ospf
->lsa_refresh_queue
.index
;
4063 i
= (i
+ 1) % OSPF_LSA_REFRESHER_SLOTS
) {
4064 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
4065 zlog_debug("LSA[Refresh]: %s: refresh index %d",
4068 refresh_list
= ospf
->lsa_refresh_queue
.qs
[i
];
4072 ospf
->lsa_refresh_queue
.qs
[i
] = NULL
;
4075 for (ALL_LIST_ELEMENTS(refresh_list
, node
, nnode
,
4077 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
4079 "LSA[Refresh:Type%d:%pI4]: %s: refresh lsa %p (slot %d)",
4080 lsa
->data
->type
, &lsa
->data
->id
,
4081 __func__
, (void *)lsa
, i
);
4083 assert(lsa
->lock
> 0);
4084 list_delete_node(refresh_list
, node
);
4085 lsa
->refresh_list
= -1;
4086 listnode_add(lsa_to_refresh
, lsa
);
4088 list_delete(&refresh_list
);
4092 ospf
->t_lsa_refresher
= NULL
;
4093 thread_add_timer(master
, ospf_lsa_refresh_walker
, ospf
,
4094 ospf
->lsa_refresh_interval
, &ospf
->t_lsa_refresher
);
4095 ospf
->lsa_refresher_started
= monotime(NULL
);
4097 for (ALL_LIST_ELEMENTS(lsa_to_refresh
, node
, nnode
, lsa
)) {
4098 dna_lsa
= ospf_check_dna_lsa(lsa
);
4099 if (!dna_lsa
) { /* refresh only non-DNA LSAs */
4100 ospf_lsa_refresh(ospf
, lsa
);
4101 assert(lsa
->lock
> 0);
4102 ospf_lsa_unlock(&lsa
); /* lsa_refresh_queue & temp for
4108 list_delete(&lsa_to_refresh
);
4110 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
4111 zlog_debug("LSA[Refresh]: %s: end", __func__
);
4114 /* Flush the LSAs for the specific area */
4115 void ospf_flush_lsa_from_area(struct ospf
*ospf
, struct in_addr area_id
,
4118 struct ospf_area
*area
;
4119 struct route_node
*rn
;
4120 struct ospf_lsa
*lsa
;
4122 area
= ospf_area_get(ospf
, area_id
);
4125 case OSPF_AS_EXTERNAL_LSA
:
4126 if ((area
->external_routing
== OSPF_AREA_NSSA
) ||
4127 (area
->external_routing
== OSPF_AREA_STUB
)) {
4128 LSDB_LOOP (EXTERNAL_LSDB(ospf
), rn
, lsa
)
4129 if (IS_LSA_SELF(lsa
) &&
4130 !(CHECK_FLAG(lsa
->flags
,
4131 OSPF_LSA_LOCAL_XLT
)))
4132 ospf_lsa_flush_area(lsa
, area
);
4135 case OSPF_AS_NSSA_LSA
:
4136 LSDB_LOOP (NSSA_LSDB(area
), rn
, lsa
)
4137 if (IS_LSA_SELF(lsa
))
4138 ospf_lsa_flush_area(lsa
, area
);