2 * OSPF Link State Advertisement
3 * Copyright (C) 1999, 2000 Toshiaki Takada
5 * This file is part of GNU Zebra.
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include "sockunion.h" /* for inet_aton() */
38 #include "ospfd/ospfd.h"
39 #include "ospfd/ospf_interface.h"
40 #include "ospfd/ospf_ism.h"
41 #include "ospfd/ospf_asbr.h"
42 #include "ospfd/ospf_lsa.h"
43 #include "ospfd/ospf_lsdb.h"
44 #include "ospfd/ospf_neighbor.h"
45 #include "ospfd/ospf_nsm.h"
46 #include "ospfd/ospf_flood.h"
47 #include "ospfd/ospf_packet.h"
48 #include "ospfd/ospf_spf.h"
49 #include "ospfd/ospf_dump.h"
50 #include "ospfd/ospf_route.h"
51 #include "ospfd/ospf_ase.h"
52 #include "ospfd/ospf_zebra.h"
53 #include "ospfd/ospf_abr.h"
54 #include "ospfd/ospf_errors.h"
56 static struct ospf_lsa
*ospf_handle_summarylsa_lsId_chg(struct ospf
*ospf
,
57 struct prefix_ipv4
*p
,
60 struct in_addr old_id
);
61 static struct ospf_lsa
*
62 ospf_summary_lsa_prepare_and_flood(struct prefix_ipv4
*p
, uint32_t metric
,
63 struct ospf_area
*area
, struct in_addr id
);
64 static struct ospf_lsa
*ospf_summary_lsa_refresh(struct ospf
*ospf
,
65 struct ospf_lsa
*lsa
);
66 static struct ospf_lsa
*
67 ospf_asbr_summary_lsa_prepare_and_flood(struct prefix_ipv4
*p
, uint32_t metric
,
68 struct ospf_area
*area
,
70 static struct ospf_lsa
*ospf_summary_asbr_lsa_refresh(struct ospf
*ospf
,
71 struct ospf_lsa
*lsa
);
72 static struct ospf_lsa
*ospf_handle_exnl_lsa_lsId_chg(struct ospf
*ospf
,
73 struct external_info
*ei
,
75 static struct ospf_lsa
*
76 ospf_exnl_lsa_prepare_and_flood(struct ospf
*ospf
, struct external_info
*ei
,
79 uint32_t get_metric(uint8_t *metric
)
83 m
= (m
<< 8) + metric
[1];
84 m
= (m
<< 8) + metric
[2];
89 struct timeval
int2tv(int a
)
99 struct timeval
msec2tv(int a
)
103 ret
.tv_sec
= a
/ 1000;
104 ret
.tv_usec
= (a
% 1000) * 1000;
109 int ospf_lsa_refresh_delay(struct ospf_lsa
*lsa
)
111 struct timeval delta
;
114 if (monotime_since(&lsa
->tv_orig
, &delta
)
115 < OSPF_MIN_LS_INTERVAL
* 1000LL) {
116 struct timeval minv
= msec2tv(OSPF_MIN_LS_INTERVAL
);
117 timersub(&minv
, &delta
, &minv
);
119 /* TBD: remove padding to full sec, return timeval instead */
120 delay
= minv
.tv_sec
+ !!minv
.tv_usec
;
122 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
124 "LSA[Type%d:%pI4]: Refresh timer delay %d seconds",
125 lsa
->data
->type
, &lsa
->data
->id
,
135 int get_age(struct ospf_lsa
*lsa
)
139 monotime_since(&lsa
->tv_recv
, &rel
);
140 return ntohs(lsa
->data
->ls_age
) + rel
.tv_sec
;
144 /* Fletcher Checksum -- Refer to RFC1008. */
146 /* All the offsets are zero-based. The offsets in the RFC1008 are
148 uint16_t ospf_lsa_checksum(struct lsa_header
*lsa
)
150 uint8_t *buffer
= &lsa
->options
;
151 int options_offset
= buffer
- (uint8_t *)&lsa
->ls_age
; /* should be 2 */
153 /* Skip the AGE field */
154 uint16_t len
= ntohs(lsa
->length
) - options_offset
;
156 /* Checksum offset starts from "options" field, not the beginning of the
157 lsa_header struct. The offset is 14, rather than 16. */
158 int checksum_offset
= (uint8_t *)&lsa
->checksum
- buffer
;
160 return fletcher_checksum(buffer
, len
, checksum_offset
);
163 int ospf_lsa_checksum_valid(struct lsa_header
*lsa
)
165 uint8_t *buffer
= &lsa
->options
;
166 int options_offset
= buffer
- (uint8_t *)&lsa
->ls_age
; /* should be 2 */
168 /* Skip the AGE field */
169 uint16_t len
= ntohs(lsa
->length
) - options_offset
;
171 return (fletcher_checksum(buffer
, len
, FLETCHER_CHECKSUM_VALIDATE
)
176 /* Create OSPF LSA. */
177 struct ospf_lsa
*ospf_lsa_new(void)
179 struct ospf_lsa
*new;
181 new = XCALLOC(MTYPE_OSPF_LSA
, sizeof(struct ospf_lsa
));
185 new->retransmit_counter
= 0;
186 monotime(&new->tv_recv
);
187 new->tv_orig
= new->tv_recv
;
188 new->refresh_list
= -1;
189 new->vrf_id
= VRF_DEFAULT
;
190 new->to_be_acknowledged
= 0;
195 struct ospf_lsa
*ospf_lsa_new_and_data(size_t size
)
197 struct ospf_lsa
*new;
199 new = ospf_lsa_new();
200 new->data
= ospf_lsa_data_new(size
);
206 /* Duplicate OSPF LSA. */
207 struct ospf_lsa
*ospf_lsa_dup(struct ospf_lsa
*lsa
)
209 struct ospf_lsa
*new;
214 new = XCALLOC(MTYPE_OSPF_LSA
, sizeof(struct ospf_lsa
));
216 memcpy(new, lsa
, sizeof(struct ospf_lsa
));
217 UNSET_FLAG(new->flags
, OSPF_LSA_DISCARD
);
219 new->retransmit_counter
= 0;
220 new->data
= ospf_lsa_data_dup(lsa
->data
);
222 /* kevinm: Clear the refresh_list, otherwise there are going
223 to be problems when we try to remove the LSA from the
224 queue (which it's not a member of.)
225 XXX: Should we add the LSA to the refresh_list queue? */
226 new->refresh_list
= -1;
228 if (IS_DEBUG_OSPF(lsa
, LSA
))
229 zlog_debug("LSA: duplicated %p (new: %p)", (void *)lsa
,
236 void ospf_lsa_free(struct ospf_lsa
*lsa
)
238 assert(lsa
->lock
== 0);
240 if (IS_DEBUG_OSPF(lsa
, LSA
))
241 zlog_debug("LSA: freed %p", (void *)lsa
);
243 /* Delete LSA data. */
244 if (lsa
->data
!= NULL
)
245 ospf_lsa_data_free(lsa
->data
);
247 assert(lsa
->refresh_list
< 0);
249 memset(lsa
, 0, sizeof(struct ospf_lsa
));
250 XFREE(MTYPE_OSPF_LSA
, lsa
);
254 struct ospf_lsa
*ospf_lsa_lock(struct ospf_lsa
*lsa
)
261 void ospf_lsa_unlock(struct ospf_lsa
**lsa
)
263 /* This is sanity check. */
269 assert((*lsa
)->lock
>= 0);
271 if ((*lsa
)->lock
== 0) {
272 assert(CHECK_FLAG((*lsa
)->flags
, OSPF_LSA_DISCARD
));
278 /* Check discard flag. */
279 void ospf_lsa_discard(struct ospf_lsa
*lsa
)
281 if (!CHECK_FLAG(lsa
->flags
, OSPF_LSA_DISCARD
)) {
282 SET_FLAG(lsa
->flags
, OSPF_LSA_DISCARD
);
283 ospf_lsa_unlock(&lsa
);
287 /* Create LSA data. */
288 struct lsa_header
*ospf_lsa_data_new(size_t size
)
290 return XCALLOC(MTYPE_OSPF_LSA_DATA
, size
);
293 /* Duplicate LSA data. */
294 struct lsa_header
*ospf_lsa_data_dup(struct lsa_header
*lsah
)
296 struct lsa_header
*new;
298 new = ospf_lsa_data_new(ntohs(lsah
->length
));
299 memcpy(new, lsah
, ntohs(lsah
->length
));
305 void ospf_lsa_data_free(struct lsa_header
*lsah
)
307 if (IS_DEBUG_OSPF(lsa
, LSA
))
308 zlog_debug("LSA[Type%d:%pI4]: data freed %p", lsah
->type
,
309 &lsah
->id
, (void *)lsah
);
311 XFREE(MTYPE_OSPF_LSA_DATA
, lsah
);
315 /* LSA general functions. */
317 const char *dump_lsa_key(struct ospf_lsa
*lsa
)
319 static char buf
[sizeof("Type255,id(255.255.255.255),ar(255.255.255.255)")+1];
320 struct lsa_header
*lsah
;
322 if (lsa
!= NULL
&& (lsah
= lsa
->data
) != NULL
) {
323 char id
[INET_ADDRSTRLEN
], ar
[INET_ADDRSTRLEN
];
324 inet_ntop(AF_INET
, &lsah
->id
, id
, sizeof(id
));
325 inet_ntop(AF_INET
, &lsah
->adv_router
, ar
, sizeof(ar
));
327 snprintf(buf
, sizeof(buf
), "Type%d,id(%s),ar(%s)", lsah
->type
,
330 strlcpy(buf
, "NULL", sizeof(buf
));
335 uint32_t lsa_seqnum_increment(struct ospf_lsa
*lsa
)
339 seqnum
= ntohl(lsa
->data
->ls_seqnum
) + 1;
341 return htonl(seqnum
);
344 void lsa_header_set(struct stream
*s
, uint8_t options
, uint8_t type
,
345 struct in_addr id
, struct in_addr router_id
)
347 struct lsa_header
*lsah
;
349 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
351 lsah
->ls_age
= htons(OSPF_LSA_INITIAL_AGE
);
352 lsah
->options
= options
;
355 lsah
->adv_router
= router_id
;
356 lsah
->ls_seqnum
= htonl(OSPF_INITIAL_SEQUENCE_NUMBER
);
358 stream_forward_endp(s
, OSPF_LSA_HEADER_SIZE
);
362 /* router-LSA related functions. */
363 /* Get router-LSA flags. */
364 uint8_t router_lsa_flags(struct ospf_area
*area
)
368 flags
= area
->ospf
->flags
;
370 /* Set virtual link flag. */
371 if (ospf_full_virtual_nbrs(area
))
372 SET_FLAG(flags
, ROUTER_LSA_VIRTUAL
);
374 /* Just sanity check */
375 UNSET_FLAG(flags
, ROUTER_LSA_VIRTUAL
);
377 /* Set Shortcut ABR behabiour flag. */
378 UNSET_FLAG(flags
, ROUTER_LSA_SHORTCUT
);
379 if (area
->ospf
->abr_type
== OSPF_ABR_SHORTCUT
)
380 if (!OSPF_IS_AREA_BACKBONE(area
))
381 if ((area
->shortcut_configured
== OSPF_SHORTCUT_DEFAULT
382 && area
->ospf
->backbone
== NULL
)
383 || area
->shortcut_configured
384 == OSPF_SHORTCUT_ENABLE
)
385 SET_FLAG(flags
, ROUTER_LSA_SHORTCUT
);
387 /* ASBR can't exit in stub area. */
388 if (area
->external_routing
== OSPF_AREA_STUB
)
389 UNSET_FLAG(flags
, ROUTER_LSA_EXTERNAL
);
390 /* If ASBR set External flag */
391 else if (IS_OSPF_ASBR(area
->ospf
))
392 SET_FLAG(flags
, ROUTER_LSA_EXTERNAL
);
394 /* Set ABR dependent flags */
395 if (IS_OSPF_ABR(area
->ospf
)) {
396 SET_FLAG(flags
, ROUTER_LSA_BORDER
);
397 /* If Area is NSSA and we are both ABR and unconditional
399 * set Nt bit to inform other routers.
401 if ((area
->external_routing
== OSPF_AREA_NSSA
)
402 && (area
->NSSATranslatorRole
== OSPF_NSSA_ROLE_ALWAYS
))
403 SET_FLAG(flags
, ROUTER_LSA_NT
);
408 /* Lookup neighbor other than myself.
409 And check neighbor count,
410 Point-to-Point link must have only 1 neighbor. */
411 struct ospf_neighbor
*ospf_nbr_lookup_ptop(struct ospf_interface
*oi
)
413 struct ospf_neighbor
*nbr
= NULL
;
414 struct route_node
*rn
;
416 /* Search neighbor, there must be one of two nbrs. */
417 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
418 if ((nbr
= rn
->info
))
419 if (!IPV4_ADDR_SAME(&nbr
->router_id
,
420 &oi
->ospf
->router_id
))
421 if (nbr
->state
== NSM_Full
) {
422 route_unlock_node(rn
);
426 /* PtoP link must have only 1 neighbor. */
427 if (ospf_nbr_count(oi
, 0) > 1)
428 flog_warn(EC_OSPF_PTP_NEIGHBOR
,
429 "Point-to-Point link has more than 1 neighobrs.");
434 /* Determine cost of link, taking RFC3137 stub-router support into
437 static uint16_t ospf_link_cost(struct ospf_interface
*oi
)
439 /* RFC3137 stub router support */
440 if (!CHECK_FLAG(oi
->area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
))
441 return oi
->output_cost
;
443 return OSPF_OUTPUT_COST_INFINITE
;
446 /* Set a link information. */
447 char link_info_set(struct stream
**s
, struct in_addr id
, struct in_addr data
,
448 uint8_t type
, uint8_t tos
, uint16_t cost
)
450 /* LSA stream is initially allocated to OSPF_MAX_LSA_SIZE, suits
451 * vast majority of cases. Some rare routers with lots of links need
453 * we try accommodate those here.
455 if (STREAM_WRITEABLE(*s
) < OSPF_ROUTER_LSA_LINK_SIZE
) {
456 size_t ret
= OSPF_MAX_LSA_SIZE
;
458 /* Can we enlarge the stream still? */
459 if (STREAM_SIZE(*s
) == OSPF_MAX_LSA_SIZE
) {
460 /* we futz the size here for simplicity, really we need
463 * IP Header - (sizeof(struct ip))
464 * OSPF Header - OSPF_HEADER_SIZE
465 * LSA Header - OSPF_LSA_HEADER_SIZE
466 * MD5 auth data, if MD5 is configured -
467 * OSPF_AUTH_MD5_SIZE.
469 * Simpler just to subtract OSPF_MAX_LSA_SIZE though.
471 ret
= stream_resize_inplace(
472 s
, OSPF_MAX_PACKET_SIZE
- OSPF_MAX_LSA_SIZE
);
475 if (ret
== OSPF_MAX_LSA_SIZE
) {
478 "%s: Out of space in LSA stream, left %zd, size %zd",
479 __func__
, STREAM_WRITEABLE(*s
),
485 /* TOS based routing is not supported. */
486 stream_put_ipv4(*s
, id
.s_addr
); /* Link ID. */
487 stream_put_ipv4(*s
, data
.s_addr
); /* Link Data. */
488 stream_putc(*s
, type
); /* Link Type. */
489 stream_putc(*s
, tos
); /* TOS = 0. */
490 stream_putw(*s
, cost
); /* Link Cost. */
495 /* Describe Point-to-Point link (Section 12.4.1.1). */
497 /* Note: If the interface is configured as point-to-point dmvpn then the other
498 * end of link is dmvpn hub with point-to-multipoint ospf network type. The
499 * hub then expects this router to populate the stub network and also Link Data
500 * Field set to IP Address and not MIB-II ifIndex
502 static int lsa_link_ptop_set(struct stream
**s
, struct ospf_interface
*oi
)
505 struct ospf_neighbor
*nbr
;
506 struct in_addr id
, mask
, data
;
507 uint16_t cost
= ospf_link_cost(oi
);
509 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
510 zlog_debug("LSA[Type1]: Set link Point-to-Point");
512 if ((nbr
= ospf_nbr_lookup_ptop(oi
)))
513 if (nbr
->state
== NSM_Full
) {
514 if (CHECK_FLAG(oi
->connected
->flags
,
515 ZEBRA_IFA_UNNUMBERED
)
517 /* For unnumbered point-to-point networks, the
519 should specify the interface's MIB-II ifIndex
521 data
.s_addr
= htonl(oi
->ifp
->ifindex
);
522 links
+= link_info_set(
523 s
, nbr
->router_id
, data
,
524 LSA_LINK_TYPE_POINTOPOINT
, 0, cost
);
526 links
+= link_info_set(
528 oi
->address
->u
.prefix4
,
529 LSA_LINK_TYPE_POINTOPOINT
, 0, cost
);
533 /* no need for a stub link for unnumbered interfaces */
535 || !CHECK_FLAG(oi
->connected
->flags
, ZEBRA_IFA_UNNUMBERED
)) {
536 /* Regardless of the state of the neighboring router, we must
537 add a Type 3 link (stub network).
538 N.B. Options 1 & 2 share basically the same logic. */
539 masklen2ip(oi
->address
->prefixlen
, &mask
);
540 id
.s_addr
= CONNECTED_PREFIX(oi
->connected
)->u
.prefix4
.s_addr
542 links
+= link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0,
549 /* Describe Broadcast Link. */
550 static int lsa_link_broadcast_set(struct stream
**s
, struct ospf_interface
*oi
)
552 struct ospf_neighbor
*dr
;
553 struct in_addr id
, mask
;
554 uint16_t cost
= ospf_link_cost(oi
);
556 /* Describe Type 3 Link. */
557 if (oi
->state
== ISM_Waiting
) {
558 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
560 "LSA[Type1]: Interface %s is in state Waiting. Adding stub interface",
562 masklen2ip(oi
->address
->prefixlen
, &mask
);
563 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
& mask
.s_addr
;
564 return link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0,
568 dr
= ospf_nbr_lookup_by_addr(oi
->nbrs
, &DR(oi
));
569 /* Describe Type 2 link. */
570 if (dr
&& (dr
->state
== NSM_Full
571 || IPV4_ADDR_SAME(&oi
->address
->u
.prefix4
, &DR(oi
)))
572 && ospf_nbr_count(oi
, NSM_Full
) > 0) {
573 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
575 "LSA[Type1]: Interface %s has a DR. Adding transit interface",
577 return link_info_set(s
, DR(oi
), oi
->address
->u
.prefix4
,
578 LSA_LINK_TYPE_TRANSIT
, 0, cost
);
580 /* Describe type 3 link. */
582 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
584 "LSA[Type1]: Interface %s has no DR. Adding stub interface",
586 masklen2ip(oi
->address
->prefixlen
, &mask
);
587 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
& mask
.s_addr
;
588 return link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0,
593 static int lsa_link_loopback_set(struct stream
**s
, struct ospf_interface
*oi
)
595 struct in_addr id
, mask
;
597 /* Describe Type 3 Link. */
598 if (oi
->state
!= ISM_Loopback
)
601 mask
.s_addr
= 0xffffffff;
602 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
;
603 return link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0, 0);
606 /* Describe Virtual Link. */
607 static int lsa_link_virtuallink_set(struct stream
**s
,
608 struct ospf_interface
*oi
)
610 struct ospf_neighbor
*nbr
;
611 uint16_t cost
= ospf_link_cost(oi
);
613 if (oi
->state
== ISM_PointToPoint
)
614 if ((nbr
= ospf_nbr_lookup_ptop(oi
)))
615 if (nbr
->state
== NSM_Full
) {
616 return link_info_set(s
, nbr
->router_id
,
617 oi
->address
->u
.prefix4
,
618 LSA_LINK_TYPE_VIRTUALLINK
,
625 #define lsa_link_nbma_set(S,O) lsa_link_broadcast_set (S, O)
627 /* this function add for support point-to-multipoint ,see rfc2328
629 /* from "edward rrr" <edward_rrr@hotmail.com>
630 http://marc.theaimsgroup.com/?l=zebra&m=100739222210507&w=2 */
631 static int lsa_link_ptomp_set(struct stream
**s
, struct ospf_interface
*oi
)
634 struct route_node
*rn
;
635 struct ospf_neighbor
*nbr
= NULL
;
636 struct in_addr id
, mask
;
637 uint16_t cost
= ospf_link_cost(oi
);
639 mask
.s_addr
= 0xffffffff;
640 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
;
641 links
+= link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0, 0);
643 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
644 zlog_debug("PointToMultipoint: running ptomultip_set");
646 /* Search neighbor, */
647 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
648 if ((nbr
= rn
->info
) != NULL
)
650 if (!IPV4_ADDR_SAME(&nbr
->router_id
,
651 &oi
->ospf
->router_id
))
652 if (nbr
->state
== NSM_Full
)
655 links
+= link_info_set(
657 oi
->address
->u
.prefix4
,
658 LSA_LINK_TYPE_POINTOPOINT
, 0,
660 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
662 "PointToMultipoint: set link to %pI4",
663 &oi
->address
->u
.prefix4
);
669 /* Set router-LSA link information. */
670 static int router_lsa_link_set(struct stream
**s
, struct ospf_area
*area
)
672 struct listnode
*node
;
673 struct ospf_interface
*oi
;
676 for (ALL_LIST_ELEMENTS_RO(area
->oiflist
, node
, oi
)) {
677 struct interface
*ifp
= oi
->ifp
;
679 /* Check interface is up, OSPF is enable. */
680 if (if_is_operative(ifp
)) {
681 if (oi
->state
!= ISM_Down
) {
682 oi
->lsa_pos_beg
= links
;
683 /* Describe each link. */
685 case OSPF_IFTYPE_POINTOPOINT
:
686 links
+= lsa_link_ptop_set(s
, oi
);
688 case OSPF_IFTYPE_BROADCAST
:
689 links
+= lsa_link_broadcast_set(s
, oi
);
691 case OSPF_IFTYPE_NBMA
:
692 links
+= lsa_link_nbma_set(s
, oi
);
694 case OSPF_IFTYPE_POINTOMULTIPOINT
:
695 links
+= lsa_link_ptomp_set(s
, oi
);
697 case OSPF_IFTYPE_VIRTUALLINK
:
699 lsa_link_virtuallink_set(s
, oi
);
701 case OSPF_IFTYPE_LOOPBACK
:
702 links
+= lsa_link_loopback_set(s
, oi
);
704 oi
->lsa_pos_end
= links
;
712 /* Set router-LSA body. */
713 void ospf_router_lsa_body_set(struct stream
**s
, struct ospf_area
*area
)
719 stream_putc(*s
, router_lsa_flags(area
));
721 /* Set Zero fields. */
724 /* Keep pointer to # links. */
725 putp
= stream_get_endp(*s
);
730 /* Set all link information. */
731 cnt
= router_lsa_link_set(s
, area
);
733 /* Set # of links here. */
734 stream_putw_at(*s
, putp
, cnt
);
737 static void ospf_stub_router_timer(struct thread
*t
)
739 struct ospf_area
*area
= THREAD_ARG(t
);
741 area
->t_stub_router
= NULL
;
743 SET_FLAG(area
->stub_router_state
, OSPF_AREA_WAS_START_STUB_ROUTED
);
745 /* clear stub route state and generate router-lsa refresh, don't
746 * clobber an administratively set stub-router state though.
748 if (CHECK_FLAG(area
->stub_router_state
, OSPF_AREA_ADMIN_STUB_ROUTED
))
751 UNSET_FLAG(area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
);
753 ospf_router_lsa_update_area(area
);
756 static void ospf_stub_router_check(struct ospf_area
*area
)
758 /* area must either be administratively configured to be stub
759 * or startup-time stub-router must be configured and we must in a
763 if (CHECK_FLAG(area
->stub_router_state
, OSPF_AREA_ADMIN_STUB_ROUTED
)) {
764 SET_FLAG(area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
);
768 /* not admin-stubbed, check whether startup stubbing is configured and
769 * whether it's not been done yet
771 if (CHECK_FLAG(area
->stub_router_state
,
772 OSPF_AREA_WAS_START_STUB_ROUTED
))
775 if (area
->ospf
->stub_router_startup_time
776 == OSPF_STUB_ROUTER_UNCONFIGURED
) {
777 /* stub-router is hence done forever for this area, even if
779 * tries configure it (take effect next restart).
781 SET_FLAG(area
->stub_router_state
,
782 OSPF_AREA_WAS_START_STUB_ROUTED
);
786 /* startup stub-router configured and not yet done */
787 SET_FLAG(area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
);
789 OSPF_AREA_TIMER_ON(area
->t_stub_router
, ospf_stub_router_timer
,
790 area
->ospf
->stub_router_startup_time
);
793 /* Create new router-LSA. */
794 static struct ospf_lsa
*ospf_router_lsa_new(struct ospf_area
*area
)
796 struct ospf
*ospf
= area
->ospf
;
798 struct lsa_header
*lsah
;
799 struct ospf_lsa
*new;
802 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
803 zlog_debug("LSA[Type1]: Create router-LSA instance");
805 /* check whether stub-router is desired, and if this is the first
808 ospf_stub_router_check(area
);
810 /* Create a stream for LSA. */
811 s
= stream_new(OSPF_MAX_LSA_SIZE
);
812 /* Set LSA common header fields. */
813 lsa_header_set(s
, LSA_OPTIONS_GET(area
) | LSA_OPTIONS_NSSA_GET(area
),
814 OSPF_ROUTER_LSA
, ospf
->router_id
, ospf
->router_id
);
816 /* Set router-LSA body fields. */
817 ospf_router_lsa_body_set(&s
, area
);
820 length
= stream_get_endp(s
);
821 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
822 lsah
->length
= htons(length
);
824 /* Now, create OSPF LSA instance. */
825 new = ospf_lsa_new_and_data(length
);
828 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
829 new->vrf_id
= area
->ospf
->vrf_id
;
831 /* Copy LSA data to store, discard stream. */
832 memcpy(new->data
, lsah
, length
);
838 /* Originate Router-LSA. */
839 static struct ospf_lsa
*ospf_router_lsa_originate(struct ospf_area
*area
)
841 struct ospf_lsa
*new;
843 if (area
->ospf
->gr_info
.restart_in_progress
) {
844 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
846 "LSA[Type%d]: Graceful Restart in progress, don't originate",
851 /* Create new router-LSA instance. */
852 if ((new = ospf_router_lsa_new(area
)) == NULL
) {
853 zlog_err("%s: ospf_router_lsa_new returned NULL", __func__
);
858 if (new->data
->adv_router
.s_addr
== INADDR_ANY
) {
859 if (IS_DEBUG_OSPF_EVENT
)
860 zlog_debug("LSA[Type1]: AdvRouter is 0, discard");
861 ospf_lsa_discard(new);
865 /* Install LSA to LSDB. */
866 new = ospf_lsa_install(area
->ospf
, NULL
, new);
868 /* Update LSA origination count. */
869 area
->ospf
->lsa_originate_count
++;
871 /* Flooding new LSA through area. */
872 ospf_flood_through_area(area
, NULL
, new);
874 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
875 zlog_debug("LSA[Type%d:%pI4]: Originate router-LSA %p",
876 new->data
->type
, &new->data
->id
,
878 ospf_lsa_header_dump(new->data
);
884 /* Refresh router-LSA. */
885 static struct ospf_lsa
*ospf_router_lsa_refresh(struct ospf_lsa
*lsa
)
887 struct ospf_area
*area
= lsa
->area
;
888 struct ospf_lsa
*new;
893 /* Delete LSA from neighbor retransmit-list. */
894 ospf_ls_retransmit_delete_nbr_area(area
, lsa
);
896 /* Unregister LSA from refresh-list */
897 ospf_refresher_unregister_lsa(area
->ospf
, lsa
);
899 /* Create new router-LSA instance. */
900 if ((new = ospf_router_lsa_new(area
)) == NULL
) {
901 zlog_err("%s: ospf_router_lsa_new returned NULL", __func__
);
905 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
907 ospf_lsa_install(area
->ospf
, NULL
, new);
909 /* Flood LSA through area. */
910 ospf_flood_through_area(area
, NULL
, new);
913 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
914 zlog_debug("LSA[Type%d:%pI4]: router-LSA refresh",
915 new->data
->type
, &new->data
->id
);
916 ospf_lsa_header_dump(new->data
);
922 int ospf_router_lsa_update_area(struct ospf_area
*area
)
924 if (IS_DEBUG_OSPF_EVENT
)
925 zlog_debug("[router-LSA]: (router-LSA area update)");
927 /* Now refresh router-LSA. */
928 if (area
->router_lsa_self
)
929 ospf_lsa_refresh(area
->ospf
, area
->router_lsa_self
);
930 /* Newly originate router-LSA. */
932 ospf_router_lsa_originate(area
);
937 int ospf_router_lsa_update(struct ospf
*ospf
)
939 struct listnode
*node
, *nnode
;
940 struct ospf_area
*area
;
942 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
943 zlog_debug("Timer[router-LSA Update]: (timer expire)");
945 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
946 struct ospf_lsa
*lsa
= area
->router_lsa_self
;
947 struct router_lsa
*rl
;
948 const char *area_str
;
950 /* Keep Area ID string. */
951 area_str
= AREA_NAME(area
);
953 /* If LSA not exist in this Area, originate new. */
955 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
957 "LSA[Type1]: Create router-LSA for Area %s",
960 ospf_router_lsa_originate(area
);
962 /* If router-ID is changed, Link ID must change.
963 First flush old LSA, then originate new. */
964 else if (!IPV4_ADDR_SAME(&lsa
->data
->id
, &ospf
->router_id
)) {
965 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
967 "LSA[Type%d:%pI4]: Refresh router-LSA for Area %s",
969 &lsa
->data
->id
, area_str
);
970 ospf_refresher_unregister_lsa(ospf
, lsa
);
971 ospf_lsa_flush_area(lsa
, area
);
972 ospf_lsa_unlock(&area
->router_lsa_self
);
973 area
->router_lsa_self
= NULL
;
975 /* Refresh router-LSA, (not install) and flood through
977 ospf_router_lsa_update_area(area
);
979 rl
= (struct router_lsa
*)lsa
->data
;
980 /* Refresh router-LSA, (not install) and flood through
982 if (rl
->flags
!= ospf
->flags
)
983 ospf_router_lsa_update_area(area
);
991 /* network-LSA related functions. */
992 /* Originate Network-LSA. */
993 static void ospf_network_lsa_body_set(struct stream
*s
,
994 struct ospf_interface
*oi
)
997 struct route_node
*rn
;
998 struct ospf_neighbor
*nbr
;
1000 masklen2ip(oi
->address
->prefixlen
, &mask
);
1001 stream_put_ipv4(s
, mask
.s_addr
);
1003 /* The network-LSA lists those routers that are fully adjacent to
1004 the Designated Router; each fully adjacent router is identified by
1005 its OSPF Router ID. The Designated Router includes itself in this
1006 list. RFC2328, Section 12.4.2 */
1008 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
1009 if ((nbr
= rn
->info
) != NULL
)
1010 if (nbr
->state
== NSM_Full
|| nbr
== oi
->nbr_self
)
1011 stream_put_ipv4(s
, nbr
->router_id
.s_addr
);
1014 static struct ospf_lsa
*ospf_network_lsa_new(struct ospf_interface
*oi
)
1017 struct ospf_lsa
*new;
1018 struct lsa_header
*lsah
;
1019 struct ospf_if_params
*oip
;
1022 /* If there are no neighbours on this network (the net is stub),
1023 the router does not originate network-LSA (see RFC 12.4.2) */
1024 if (oi
->full_nbrs
== 0)
1027 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1028 zlog_debug("LSA[Type2]: Create network-LSA instance");
1030 /* Create new stream for LSA. */
1031 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1032 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1034 lsa_header_set(s
, (OPTIONS(oi
) | LSA_OPTIONS_GET(oi
->area
)),
1035 OSPF_NETWORK_LSA
, DR(oi
), oi
->ospf
->router_id
);
1037 /* Set network-LSA body fields. */
1038 ospf_network_lsa_body_set(s
, oi
);
1041 length
= stream_get_endp(s
);
1042 lsah
->length
= htons(length
);
1044 /* Create OSPF LSA instance. */
1045 new = ospf_lsa_new_and_data(length
);
1047 new->area
= oi
->area
;
1048 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
1049 new->vrf_id
= oi
->ospf
->vrf_id
;
1051 /* Copy LSA to store. */
1052 memcpy(new->data
, lsah
, length
);
1055 /* Remember prior network LSA sequence numbers, even if we stop
1056 * originating one for this oi, to try avoid re-originating LSAs with a
1057 * prior sequence number, and thus speed up adjency forming &
1060 if ((oip
= ospf_lookup_if_params(oi
->ifp
, oi
->address
->u
.prefix4
))) {
1061 new->data
->ls_seqnum
= oip
->network_lsa_seqnum
;
1062 new->data
->ls_seqnum
= lsa_seqnum_increment(new);
1064 oip
= ospf_get_if_params(oi
->ifp
, oi
->address
->u
.prefix4
);
1065 ospf_if_update_params(oi
->ifp
, oi
->address
->u
.prefix4
);
1067 oip
->network_lsa_seqnum
= new->data
->ls_seqnum
;
1072 /* Originate network-LSA. */
1073 void ospf_network_lsa_update(struct ospf_interface
*oi
)
1075 struct ospf_lsa
*new;
1077 if (oi
->area
->ospf
->gr_info
.restart_in_progress
) {
1078 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1080 "LSA[Type%d]: Graceful Restart in progress, don't originate",
1085 if (oi
->network_lsa_self
!= NULL
) {
1086 ospf_lsa_refresh(oi
->ospf
, oi
->network_lsa_self
);
1090 /* Create new network-LSA instance. */
1091 new = ospf_network_lsa_new(oi
);
1095 /* Install LSA to LSDB. */
1096 new = ospf_lsa_install(oi
->ospf
, oi
, new);
1098 /* Update LSA origination count. */
1099 oi
->ospf
->lsa_originate_count
++;
1101 /* Flooding new LSA through area. */
1102 ospf_flood_through_area(oi
->area
, NULL
, new);
1104 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1105 zlog_debug("LSA[Type%d:%pI4]: Originate network-LSA %p",
1106 new->data
->type
, &new->data
->id
,
1108 ospf_lsa_header_dump(new->data
);
1114 static struct ospf_lsa
*ospf_network_lsa_refresh(struct ospf_lsa
*lsa
)
1116 struct ospf_area
*area
= lsa
->area
;
1117 struct ospf_lsa
*new, *new2
;
1118 struct ospf_if_params
*oip
;
1119 struct ospf_interface
*oi
;
1123 /* Retrieve the oi for the network LSA */
1124 oi
= ospf_if_lookup_by_local_addr(area
->ospf
, NULL
, lsa
->data
->id
);
1126 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1128 "LSA[Type%d:%pI4]: network-LSA refresh: no oi found, ick, ignoring.",
1129 lsa
->data
->type
, &lsa
->data
->id
);
1130 ospf_lsa_header_dump(lsa
->data
);
1134 /* Delete LSA from neighbor retransmit-list. */
1135 ospf_ls_retransmit_delete_nbr_area(area
, lsa
);
1137 /* Unregister LSA from refresh-list */
1138 ospf_refresher_unregister_lsa(area
->ospf
, lsa
);
1140 /* Create new network-LSA instance. */
1141 new = ospf_network_lsa_new(oi
);
1145 oip
= ospf_lookup_if_params(oi
->ifp
, oi
->address
->u
.prefix4
);
1146 assert(oip
!= NULL
);
1147 oip
->network_lsa_seqnum
= new->data
->ls_seqnum
=
1148 lsa_seqnum_increment(lsa
);
1150 new2
= ospf_lsa_install(area
->ospf
, oi
, new);
1152 assert(new2
== new);
1154 /* Flood LSA through aera. */
1155 ospf_flood_through_area(area
, NULL
, new);
1157 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1158 zlog_debug("LSA[Type%d:%pI4]: network-LSA refresh",
1159 new->data
->type
, &new->data
->id
);
1160 ospf_lsa_header_dump(new->data
);
1166 static void stream_put_ospf_metric(struct stream
*s
, uint32_t metric_value
)
1171 /* Put 0 metric. TOS metric is not supported. */
1172 metric
= htonl(metric_value
);
1173 mp
= (char *)&metric
;
1175 stream_put(s
, mp
, 3);
1178 /* summary-LSA related functions. */
1179 static void ospf_summary_lsa_body_set(struct stream
*s
, struct prefix
*p
,
1182 struct in_addr mask
;
1184 masklen2ip(p
->prefixlen
, &mask
);
1186 /* Put Network Mask. */
1187 stream_put_ipv4(s
, mask
.s_addr
);
1190 stream_putc(s
, (uint8_t)0);
1193 stream_put_ospf_metric(s
, metric
);
1196 static struct ospf_lsa
*ospf_summary_lsa_new(struct ospf_area
*area
,
1197 struct prefix
*p
, uint32_t metric
,
1201 struct ospf_lsa
*new;
1202 struct lsa_header
*lsah
;
1205 if (id
.s_addr
== 0xffffffff) {
1206 /* Maybe Link State ID not available. */
1207 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1209 "LSA[Type%d]: Link ID not available, can't originate",
1214 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1215 zlog_debug("LSA[Type3]: Create summary-LSA instance");
1217 /* Create new stream for LSA. */
1218 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1219 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1221 lsa_header_set(s
, LSA_OPTIONS_GET(area
), OSPF_SUMMARY_LSA
, id
,
1222 area
->ospf
->router_id
);
1224 /* Set summary-LSA body fields. */
1225 ospf_summary_lsa_body_set(s
, p
, metric
);
1228 length
= stream_get_endp(s
);
1229 lsah
->length
= htons(length
);
1231 /* Create OSPF LSA instance. */
1232 new = ospf_lsa_new_and_data(length
);
1234 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
1235 new->vrf_id
= area
->ospf
->vrf_id
;
1237 /* Copy LSA to store. */
1238 memcpy(new->data
, lsah
, length
);
1244 /* Originate Summary-LSA. */
1245 static struct ospf_lsa
*
1246 ospf_summary_lsa_prepare_and_flood(struct prefix_ipv4
*p
, uint32_t metric
,
1247 struct ospf_area
*area
, struct in_addr id
)
1249 struct ospf_lsa
*new;
1251 /* Create new summary-LSA instance. */
1252 if (!(new = ospf_summary_lsa_new(area
, (struct prefix
*)p
, metric
, id
)))
1255 /* Instlal LSA to LSDB. */
1256 new = ospf_lsa_install(area
->ospf
, NULL
, new);
1258 /* Update LSA origination count. */
1259 area
->ospf
->lsa_originate_count
++;
1261 /* Flooding new LSA through area. */
1262 ospf_flood_through_area(area
, NULL
, new);
1264 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1265 zlog_debug("LSA[Type%d:%pI4]: Originate summary-LSA %p",
1266 new->data
->type
, &new->data
->id
,
1268 ospf_lsa_header_dump(new->data
);
1274 static struct ospf_lsa
*ospf_handle_summarylsa_lsId_chg(struct ospf
*ospf
,
1275 struct prefix_ipv4
*p
,
1278 struct in_addr old_id
)
1280 struct ospf_lsa
*lsa
= NULL
;
1281 struct ospf_lsa
*new = NULL
;
1282 struct summary_lsa
*sl
= NULL
;
1283 struct ospf_area
*old_area
= NULL
;
1284 struct prefix_ipv4 old_prefix
;
1285 uint32_t old_metric
;
1286 struct in_addr mask
;
1287 uint32_t metric_val
;
1290 lsa
= ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, p
->prefix
,
1294 flog_warn(EC_OSPF_LSA_NULL
, "(%s): LSA not found", __func__
);
1298 sl
= (struct summary_lsa
*)lsa
->data
;
1300 old_area
= lsa
->area
;
1301 old_metric
= GET_METRIC(sl
->metric
);
1302 old_prefix
.prefix
= sl
->header
.id
;
1303 old_prefix
.prefixlen
= ip_masklen(sl
->mask
);
1304 old_prefix
.family
= AF_INET
;
1307 /* change the mask */
1308 masklen2ip(p
->prefixlen
, &mask
);
1309 sl
->mask
.s_addr
= mask
.s_addr
;
1311 /* Copy the metric*/
1312 metric_val
= htonl(metric
);
1313 metric_buf
= (char *)&metric_val
;
1314 memcpy(sl
->metric
, metric_buf
, sizeof(metric_val
));
1316 if (type
== OSPF_SUMMARY_LSA
) {
1317 /*Refresh the LSA with new LSA*/
1318 ospf_summary_lsa_refresh(ospf
, lsa
);
1320 new = ospf_summary_lsa_prepare_and_flood(
1321 &old_prefix
, old_metric
, old_area
, old_id
);
1323 /*Refresh the LSA with new LSA*/
1324 ospf_summary_asbr_lsa_refresh(ospf
, lsa
);
1326 new = ospf_asbr_summary_lsa_prepare_and_flood(
1327 &old_prefix
, old_metric
, old_area
, old_id
);
1333 /* Originate Summary-LSA. */
1334 struct ospf_lsa
*ospf_summary_lsa_originate(struct prefix_ipv4
*p
,
1336 struct ospf_area
*area
)
1339 enum lsid_status status
;
1340 struct ospf_lsa
*new = NULL
;
1342 status
= ospf_lsa_unique_id(area
->ospf
, area
->lsdb
, OSPF_SUMMARY_LSA
, p
,
1345 if (status
== LSID_CHANGE
) {
1346 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1347 zlog_debug("Link ID has to be changed.");
1349 new = ospf_handle_summarylsa_lsId_chg(
1350 area
->ospf
, p
, OSPF_SUMMARY_LSA
, metric
, id
);
1352 } else if (status
== LSID_NOT_AVAILABLE
) {
1353 /* Link State ID not available. */
1354 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1356 "LSA[Type5]: Link ID not available, can't originate");
1361 new = ospf_summary_lsa_prepare_and_flood(p
, metric
, area
, id
);
1365 static struct ospf_lsa
*ospf_summary_lsa_refresh(struct ospf
*ospf
,
1366 struct ospf_lsa
*lsa
)
1368 struct ospf_lsa
*new;
1369 struct summary_lsa
*sl
;
1375 sl
= (struct summary_lsa
*)lsa
->data
;
1376 p
.prefixlen
= ip_masklen(sl
->mask
);
1377 new = ospf_summary_lsa_new(lsa
->area
, &p
, GET_METRIC(sl
->metric
),
1383 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
1385 ospf_lsa_install(ospf
, NULL
, new);
1387 /* Flood LSA through AS. */
1388 ospf_flood_through_area(new->area
, NULL
, new);
1390 /* Debug logging. */
1391 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1392 zlog_debug("LSA[Type%d:%pI4]: summary-LSA refresh",
1393 new->data
->type
, &new->data
->id
);
1394 ospf_lsa_header_dump(new->data
);
1401 /* summary-ASBR-LSA related functions. */
1402 static void ospf_summary_asbr_lsa_body_set(struct stream
*s
, struct prefix
*p
,
1405 /* Put Network Mask. */
1406 stream_put_ipv4(s
, (uint32_t)0);
1409 stream_putc(s
, (uint8_t)0);
1412 stream_put_ospf_metric(s
, metric
);
1415 static struct ospf_lsa
*ospf_summary_asbr_lsa_new(struct ospf_area
*area
,
1421 struct ospf_lsa
*new;
1422 struct lsa_header
*lsah
;
1425 if (id
.s_addr
== 0xffffffff) {
1426 /* Maybe Link State ID not available. */
1427 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1429 "LSA[Type%d]: Link ID not available, can't originate",
1430 OSPF_ASBR_SUMMARY_LSA
);
1434 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1435 zlog_debug("LSA[Type3]: Create summary-LSA instance");
1437 /* Create new stream for LSA. */
1438 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1439 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1441 lsa_header_set(s
, LSA_OPTIONS_GET(area
), OSPF_ASBR_SUMMARY_LSA
, id
,
1442 area
->ospf
->router_id
);
1444 /* Set summary-LSA body fields. */
1445 ospf_summary_asbr_lsa_body_set(s
, p
, metric
);
1448 length
= stream_get_endp(s
);
1449 lsah
->length
= htons(length
);
1451 /* Create OSPF LSA instance. */
1452 new = ospf_lsa_new_and_data(length
);
1454 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
1455 new->vrf_id
= area
->ospf
->vrf_id
;
1457 /* Copy LSA to store. */
1458 memcpy(new->data
, lsah
, length
);
1464 /* Originate summary-ASBR-LSA. */
1465 static struct ospf_lsa
*
1466 ospf_asbr_summary_lsa_prepare_and_flood(struct prefix_ipv4
*p
, uint32_t metric
,
1467 struct ospf_area
*area
,
1470 struct ospf_lsa
*new;
1472 /* Create new summary-LSA instance. */
1473 new = ospf_summary_asbr_lsa_new(area
, (struct prefix
*)p
, metric
, id
);
1477 /* Install LSA to LSDB. */
1478 new = ospf_lsa_install(area
->ospf
, NULL
, new);
1480 /* Update LSA origination count. */
1481 area
->ospf
->lsa_originate_count
++;
1483 /* Flooding new LSA through area. */
1484 ospf_flood_through_area(area
, NULL
, new);
1486 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1487 zlog_debug("LSA[Type%d:%pI4]: Originate summary-ASBR-LSA %p",
1488 new->data
->type
, &new->data
->id
,
1490 ospf_lsa_header_dump(new->data
);
1496 struct ospf_lsa
*ospf_summary_asbr_lsa_originate(struct prefix_ipv4
*p
,
1498 struct ospf_area
*area
)
1500 struct ospf_lsa
*new;
1502 enum lsid_status status
;
1504 status
= ospf_lsa_unique_id(area
->ospf
, area
->lsdb
,
1505 OSPF_ASBR_SUMMARY_LSA
, p
, &id
);
1507 if (status
== LSID_CHANGE
) {
1508 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1509 zlog_debug("Link ID has to be changed.");
1511 new = ospf_handle_summarylsa_lsId_chg(
1512 area
->ospf
, p
, OSPF_ASBR_SUMMARY_LSA
, metric
, id
);
1514 } else if (status
== LSID_NOT_AVAILABLE
) {
1515 /* Link State ID not available. */
1516 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1518 "LSA[Type5]: Link ID not available, can't originate");
1523 new = ospf_asbr_summary_lsa_prepare_and_flood(p
, metric
, area
, id
);
1527 static struct ospf_lsa
*ospf_summary_asbr_lsa_refresh(struct ospf
*ospf
,
1528 struct ospf_lsa
*lsa
)
1530 struct ospf_lsa
*new;
1531 struct summary_lsa
*sl
;
1537 sl
= (struct summary_lsa
*)lsa
->data
;
1538 p
.prefixlen
= ip_masklen(sl
->mask
);
1539 new = ospf_summary_asbr_lsa_new(lsa
->area
, &p
, GET_METRIC(sl
->metric
),
1544 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
1546 ospf_lsa_install(ospf
, NULL
, new);
1548 /* Flood LSA through area. */
1549 ospf_flood_through_area(new->area
, NULL
, new);
1551 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1552 zlog_debug("LSA[Type%d:%pI4]: summary-ASBR-LSA refresh",
1553 new->data
->type
, &new->data
->id
);
1554 ospf_lsa_header_dump(new->data
);
1560 /* AS-external-LSA related functions. */
1562 /* Get nexthop for AS-external-LSAs. Return nexthop if its interface
1563 is connected, else 0*/
1564 static struct in_addr
ospf_external_lsa_nexthop_get(struct ospf
*ospf
,
1565 struct in_addr nexthop
)
1569 struct listnode
*node
;
1570 struct ospf_interface
*oi
;
1574 if (!nexthop
.s_addr
)
1577 /* Check whether nexthop is covered by OSPF network. */
1578 nh
.family
= AF_INET
;
1579 nh
.u
.prefix4
= nexthop
;
1580 nh
.prefixlen
= IPV4_MAX_BITLEN
;
1582 /* XXX/SCALE: If there were a lot of oi's on an ifp, then it'd be
1583 * better to make use of the per-ifp table of ois.
1585 for (ALL_LIST_ELEMENTS_RO(ospf
->oiflist
, node
, oi
))
1586 if (if_is_operative(oi
->ifp
))
1587 if (oi
->address
->family
== AF_INET
)
1588 if (prefix_match(oi
->address
, &nh
))
1594 /* NSSA-external-LSA related functions. */
1596 /* Get 1st IP connection for Forward Addr */
1598 struct in_addr
ospf_get_ip_from_ifp(struct ospf_interface
*oi
)
1602 fwd
.s_addr
= INADDR_ANY
;
1604 if (if_is_operative(oi
->ifp
))
1605 return oi
->address
->u
.prefix4
;
1610 /* Get 1st IP connection for Forward Addr */
1611 struct in_addr
ospf_get_nssa_ip(struct ospf_area
*area
)
1614 struct in_addr best_default
;
1615 struct listnode
*node
;
1616 struct ospf_interface
*oi
;
1619 best_default
.s_addr
= 0;
1621 for (ALL_LIST_ELEMENTS_RO(area
->ospf
->oiflist
, node
, oi
)) {
1622 if (if_is_operative(oi
->ifp
))
1623 if (oi
->area
->external_routing
== OSPF_AREA_NSSA
)
1625 && oi
->address
->family
== AF_INET
) {
1626 if (best_default
.s_addr
== INADDR_ANY
)
1628 oi
->address
->u
.prefix4
;
1629 if (oi
->area
== area
)
1630 return oi
->address
->u
.prefix4
;
1633 if (best_default
.s_addr
!= INADDR_ANY
)
1634 return best_default
;
1636 if (best_default
.s_addr
!= INADDR_ANY
)
1637 return best_default
;
1642 int metric_type(struct ospf
*ospf
, uint8_t src
, unsigned short instance
)
1644 struct ospf_redist
*red
;
1646 red
= ospf_redist_lookup(ospf
, src
, instance
);
1648 return ((!red
|| red
->dmetric
.type
< 0) ? DEFAULT_METRIC_TYPE
1649 : red
->dmetric
.type
);
1652 int metric_value(struct ospf
*ospf
, uint8_t src
, unsigned short instance
)
1654 struct ospf_redist
*red
;
1656 red
= ospf_redist_lookup(ospf
, src
, instance
);
1657 if (!red
|| red
->dmetric
.value
< 0) {
1658 if (src
== DEFAULT_ROUTE
) {
1659 if (ospf
->default_originate
== DEFAULT_ORIGINATE_ZEBRA
)
1660 return DEFAULT_DEFAULT_ORIGINATE_METRIC
;
1662 return DEFAULT_DEFAULT_ALWAYS_METRIC
;
1663 } else if (ospf
->default_metric
< 0)
1664 return DEFAULT_DEFAULT_METRIC
;
1666 return ospf
->default_metric
;
1669 return red
->dmetric
.value
;
1672 /* Set AS-external-LSA body. */
1673 static void ospf_external_lsa_body_set(struct stream
*s
,
1674 struct external_info
*ei
,
1677 struct prefix_ipv4
*p
= &ei
->p
;
1678 struct in_addr mask
, fwd_addr
;
1682 unsigned short instance
;
1684 /* Put Network Mask. */
1685 masklen2ip(p
->prefixlen
, &mask
);
1686 stream_put_ipv4(s
, mask
.s_addr
);
1688 /* If prefix is default, specify DEFAULT_ROUTE. */
1689 type
= is_default_prefix4(&ei
->p
) ? DEFAULT_ROUTE
: ei
->type
;
1690 instance
= is_default_prefix4(&ei
->p
) ? 0 : ei
->instance
;
1692 mtype
= (ROUTEMAP_METRIC_TYPE(ei
) != -1)
1693 ? ROUTEMAP_METRIC_TYPE(ei
)
1694 : metric_type(ospf
, type
, instance
);
1696 mvalue
= (ROUTEMAP_METRIC(ei
) != -1)
1697 ? ROUTEMAP_METRIC(ei
)
1698 : metric_value(ospf
, type
, instance
);
1700 /* Put type of external metric. */
1701 stream_putc(s
, (mtype
== EXTERNAL_METRIC_TYPE_2
? 0x80 : 0));
1703 /* Put 0 metric. TOS metric is not supported. */
1704 stream_put_ospf_metric(s
, mvalue
);
1706 /* Get forwarding address to nexthop if on the Connection List, else 0.
1708 fwd_addr
= ospf_external_lsa_nexthop_get(ospf
, ei
->nexthop
);
1710 /* Put forwarding address. */
1711 stream_put_ipv4(s
, fwd_addr
.s_addr
);
1714 stream_putl(s
, ei
->tag
);
1717 /* Create new external-LSA. */
1718 static struct ospf_lsa
*
1719 ospf_exnl_lsa_prepare_and_flood(struct ospf
*ospf
, struct external_info
*ei
,
1723 struct lsa_header
*lsah
;
1724 struct ospf_lsa
*new;
1727 /* Create new stream for LSA. */
1728 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1729 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1731 /* Set LSA common header fields. */
1732 lsa_header_set(s
, OSPF_OPTION_E
, OSPF_AS_EXTERNAL_LSA
, id
,
1735 /* Set AS-external-LSA body fields. */
1736 ospf_external_lsa_body_set(s
, ei
, ospf
);
1739 length
= stream_get_endp(s
);
1740 lsah
->length
= htons(length
);
1742 /* Now, create OSPF LSA instance. */
1743 new = ospf_lsa_new_and_data(length
);
1745 SET_FLAG(new->flags
,
1746 OSPF_LSA_SELF
| OSPF_LSA_APPROVED
| OSPF_LSA_SELF_CHECKED
);
1747 new->vrf_id
= ospf
->vrf_id
;
1749 /* Copy LSA data to store, discard stream. */
1750 memcpy(new->data
, lsah
, length
);
1756 static struct ospf_lsa
*ospf_handle_exnl_lsa_lsId_chg(struct ospf
*ospf
,
1757 struct external_info
*ei
,
1760 struct ospf_lsa
*lsa
;
1761 struct as_external_lsa
*al
;
1762 struct in_addr mask
;
1763 struct ospf_lsa
*new;
1764 struct external_info ei_summary
;
1765 struct external_info
*ei_old
;
1767 lsa
= ospf_lsdb_lookup_by_id(ospf
->lsdb
, OSPF_AS_EXTERNAL_LSA
,
1768 ei
->p
.prefix
, ospf
->router_id
);
1771 flog_warn(EC_OSPF_LSA_NULL
, "(%s): LSA not found", __func__
);
1775 ei_old
= ospf_external_info_check(ospf
, lsa
);
1777 al
= (struct as_external_lsa
*)lsa
->data
;
1780 /* eii_old pointer of LSA is NULL, this
1781 * must be external aggregate route.
1783 ei_summary
.p
.family
= AF_INET
;
1784 ei_summary
.p
.prefix
= al
->header
.id
;
1785 ei_summary
.p
.prefixlen
= ip_masklen(al
->mask
);
1786 ei_summary
.tag
= (unsigned long)ntohl(al
->e
[0].route_tag
);
1787 ei_old
= &ei_summary
;
1790 /* change the mask */
1791 masklen2ip(ei
->p
.prefixlen
, &mask
);
1792 al
->mask
.s_addr
= mask
.s_addr
;
1794 /*Refresh the LSA with new LSA*/
1795 ospf_external_lsa_refresh(ospf
, lsa
, ei
, LSA_REFRESH_FORCE
, 0);
1797 /*Originate the old LSA with changed LSID*/
1798 new = ospf_exnl_lsa_prepare_and_flood(ospf
, ei_old
, id
);
1803 static struct ospf_lsa
*ospf_external_lsa_new(struct ospf
*ospf
,
1804 struct external_info
*ei
,
1805 struct in_addr
*old_id
)
1807 struct ospf_lsa
*new;
1809 enum lsid_status status
;
1812 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1814 "LSA[Type5]: External info is NULL, can't originate");
1818 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1819 zlog_debug("LSA[Type5]: Originate AS-external-LSA instance");
1821 /* If old Link State ID is specified, refresh LSA with same ID. */
1824 /* Get Link State with unique ID. */
1826 status
= ospf_lsa_unique_id(ospf
, ospf
->lsdb
,
1827 OSPF_AS_EXTERNAL_LSA
, &ei
->p
, &id
);
1829 if (status
== LSID_CHANGE
) {
1830 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1831 zlog_debug("Link ID has to be changed.");
1833 new = ospf_handle_exnl_lsa_lsId_chg(ospf
, ei
, id
);
1835 } else if (status
== LSID_NOT_AVAILABLE
) {
1836 /* Link State ID not available. */
1837 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1839 "LSA[Type5]: Link ID not available, can't originate");
1844 new = ospf_exnl_lsa_prepare_and_flood(ospf
, ei
, id
);
1850 static void ospf_install_flood_nssa(struct ospf
*ospf
, struct ospf_lsa
*lsa
,
1851 struct external_info
*ei
)
1853 struct ospf_lsa
*new;
1854 struct as_external_lsa
*extlsa
;
1855 struct ospf_area
*area
;
1856 struct listnode
*node
, *nnode
;
1858 /* LSA may be a Type-5 originated via translation of a Type-7 LSA
1859 * which originated from an NSSA area. In which case it should not be
1860 * flooded back to NSSA areas.
1862 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
))
1865 /* NSSA Originate or Refresh (If anyNSSA)
1867 LSA is self-originated. And just installed as Type-5.
1868 Additionally, install as Type-7 LSDB for every attached NSSA.
1870 P-Bit controls which ABR performs translation to outside world; If
1871 we are an ABR....do not set the P-bit, because we send the Type-5,
1872 not as the ABR Translator, but as the ASBR owner within the AS!
1874 If we are NOT ABR, Flood through NSSA as Type-7 w/P-bit set. The
1875 elected ABR Translator will see the P-bit, Translate, and re-flood.
1877 Later, ABR_TASK and P-bit will scan Type-7 LSDB and translate to
1878 Type-5's to non-NSSA Areas. (it will also attempt a re-install) */
1880 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
1881 /* Don't install Type-7 LSA's into nonNSSA area */
1882 if (area
->external_routing
!= OSPF_AREA_NSSA
)
1885 /* make lsa duplicate, lock=1 */
1886 new = ospf_lsa_dup(lsa
);
1888 new->data
->type
= OSPF_AS_NSSA_LSA
;
1890 /* set P-bit if not ABR */
1891 if (!IS_OSPF_ABR(ospf
)) {
1892 SET_FLAG(new->data
->options
, OSPF_OPTION_NP
);
1894 /* set non-zero FWD ADDR
1896 draft-ietf-ospf-nssa-update-09.txt
1898 if the network between the NSSA AS boundary router and
1900 adjacent AS is advertised into OSPF as an internal OSPF
1902 the forwarding address should be the next op address as
1904 currently done with type-5 LSAs. If the intervening
1906 not adversited into OSPF as an internal OSPF route and
1908 type-7 LSA's P-bit is set a forwarding address should be
1909 selected from one of the router's active OSPF interface
1911 which belong to the NSSA. If no such addresses exist,
1913 no type-7 LSA's with the P-bit set should originate from
1917 /* kevinm: not updating lsa anymore, just new */
1918 extlsa
= (struct as_external_lsa
*)(new->data
);
1920 if (extlsa
->e
[0].fwd_addr
.s_addr
== INADDR_ANY
)
1921 extlsa
->e
[0].fwd_addr
= ospf_get_nssa_ip(
1922 area
); /* this NSSA area in ifp */
1924 if (extlsa
->e
[0].fwd_addr
.s_addr
== INADDR_ANY
) {
1925 if (IS_DEBUG_OSPF_NSSA
)
1927 "LSA[Type-7]: Could not build FWD-ADDR");
1928 ospf_lsa_discard(new);
1933 /* install also as Type-7 */
1934 ospf_lsa_install(ospf
, NULL
,
1935 new); /* Remove Old, Lock New = 2 */
1937 /* will send each copy, lock=2+n */
1938 ospf_flood_through_as(
1939 ospf
, NULL
, new); /* all attached NSSA's, no AS/STUBs */
1943 static struct ospf_lsa
*ospf_lsa_translated_nssa_new(struct ospf
*ospf
,
1944 struct ospf_lsa
*type7
)
1947 struct ospf_lsa
*new;
1948 struct as_external_lsa
*ext
, *extnew
;
1949 struct external_info ei
;
1951 ext
= (struct as_external_lsa
*)(type7
->data
);
1953 /* need external_info struct, fill in bare minimum */
1954 ei
.p
.family
= AF_INET
;
1955 ei
.p
.prefix
= type7
->data
->id
;
1956 ei
.p
.prefixlen
= ip_masklen(ext
->mask
);
1957 ei
.type
= ZEBRA_ROUTE_OSPF
;
1958 ei
.nexthop
= ext
->header
.adv_router
;
1959 ei
.route_map_set
.metric
= -1;
1960 ei
.route_map_set
.metric_type
= -1;
1964 if ((new = ospf_external_lsa_new(ospf
, &ei
, &type7
->data
->id
))
1966 if (IS_DEBUG_OSPF_NSSA
)
1968 "%s: Could not originate Translated Type-5 for %pI4",
1969 __func__
, &ei
.p
.prefix
);
1973 extnew
= (struct as_external_lsa
*)(new->data
);
1975 /* copy over Type-7 data to new */
1976 extnew
->e
[0].tos
= ext
->e
[0].tos
;
1977 extnew
->e
[0].route_tag
= ext
->e
[0].route_tag
;
1978 if (type7
->area
->suppress_fa
) {
1979 extnew
->e
[0].fwd_addr
.s_addr
= 0;
1980 if (IS_DEBUG_OSPF_NSSA
)
1982 "ospf_lsa_translated_nssa_new(): Suppress forwarding address for %pI4",
1985 extnew
->e
[0].fwd_addr
.s_addr
= ext
->e
[0].fwd_addr
.s_addr
;
1986 new->data
->ls_seqnum
= type7
->data
->ls_seqnum
;
1988 /* add translated flag, checksum and lock new lsa */
1989 SET_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
); /* Translated from 7 */
1990 new = ospf_lsa_lock(new);
1995 /* Originate Translated Type-5 for supplied Type-7 NSSA LSA */
1996 struct ospf_lsa
*ospf_translated_nssa_originate(struct ospf
*ospf
,
1997 struct ospf_lsa
*type7
,
1998 struct ospf_lsa
*type5
)
2000 struct ospf_lsa
*new;
2001 struct as_external_lsa
*extnew
;
2003 if (ospf
->gr_info
.restart_in_progress
) {
2004 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2006 "LSA[Translated Type5]: Graceful Restart in progress, don't originate");
2010 /* we cant use ospf_external_lsa_originate() as we need to set
2011 * the OSPF_LSA_LOCAL_XLT flag, must originate by hand
2014 if ((new = ospf_lsa_translated_nssa_new(ospf
, type7
)) == NULL
) {
2015 if (IS_DEBUG_OSPF_NSSA
)
2017 "%s: Could not translate Type-7, Id %pI4, to Type-5",
2018 __func__
, &type7
->data
->id
);
2022 extnew
= (struct as_external_lsa
*)new->data
;
2024 /* Update LSA sequence number from translated Type-5 LSA */
2026 new->data
->ls_seqnum
= lsa_seqnum_increment(type5
);
2028 if ((new = ospf_lsa_install(ospf
, NULL
, new)) == NULL
) {
2029 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE
,
2030 "%s: Could not install LSA id %pI4", __func__
,
2035 if (IS_DEBUG_OSPF_NSSA
) {
2036 zlog_debug("%s: translated Type 7, installed", __func__
);
2037 ospf_lsa_header_dump(new->data
);
2038 zlog_debug(" Network mask: %d", ip_masklen(extnew
->mask
));
2039 zlog_debug(" Forward addr: %pI4",
2040 &extnew
->e
[0].fwd_addr
);
2043 ospf
->lsa_originate_count
++;
2044 ospf_flood_through_as(ospf
, NULL
, new);
2049 /* Refresh Translated from NSSA AS-external-LSA. */
2050 struct ospf_lsa
*ospf_translated_nssa_refresh(struct ospf
*ospf
,
2051 struct ospf_lsa
*type7
,
2052 struct ospf_lsa
*type5
)
2054 struct ospf_lsa
*new = NULL
;
2055 struct as_external_lsa
*extold
= NULL
;
2056 uint32_t ls_seqnum
= 0;
2058 /* Sanity checks. */
2059 assert(type7
|| type5
);
2060 if (!(type7
|| type5
))
2063 assert(type7
->data
);
2065 assert(type5
->data
);
2066 assert(ospf
->anyNSSA
);
2068 /* get required data according to what has been given */
2069 if (type7
&& type5
== NULL
) {
2070 /* find the translated Type-5 for this Type-7 */
2071 struct as_external_lsa
*ext
=
2072 (struct as_external_lsa
*)(type7
->data
);
2073 struct prefix_ipv4 p
= {
2074 .prefix
= type7
->data
->id
,
2075 .prefixlen
= ip_masklen(ext
->mask
),
2079 type5
= ospf_external_info_find_lsa(ospf
, &p
);
2080 } else if (type5
&& type7
== NULL
) {
2081 /* find the type-7 from which supplied type-5 was translated,
2082 * ie find first type-7 with same LSA Id.
2084 struct listnode
*ln
, *lnn
;
2085 struct route_node
*rn
;
2086 struct ospf_lsa
*lsa
;
2087 struct ospf_area
*area
;
2089 for (ALL_LIST_ELEMENTS(ospf
->areas
, ln
, lnn
, area
)) {
2090 if (area
->external_routing
!= OSPF_AREA_NSSA
&& !type7
)
2093 LSDB_LOOP (NSSA_LSDB(area
), rn
, lsa
) {
2094 if (lsa
->data
->id
.s_addr
2095 == type5
->data
->id
.s_addr
) {
2103 /* do we have type7? */
2105 if (IS_DEBUG_OSPF_NSSA
)
2107 "ospf_translated_nssa_refresh(): no Type-7 found for Type-5 LSA Id %pI4",
2112 /* do we have valid translated type5? */
2113 if (type5
== NULL
|| !CHECK_FLAG(type5
->flags
, OSPF_LSA_LOCAL_XLT
)) {
2114 if (IS_DEBUG_OSPF_NSSA
)
2116 "ospf_translated_nssa_refresh(): No translated Type-5 found for Type-7 with Id %pI4",
2121 extold
= (struct as_external_lsa
*)type5
->data
;
2122 if (type7
->area
->suppress_fa
== 1) {
2123 if (extold
->e
[0].fwd_addr
.s_addr
== 0)
2124 ls_seqnum
= ntohl(type5
->data
->ls_seqnum
);
2127 /* Delete LSA from neighbor retransmit-list. */
2128 ospf_ls_retransmit_delete_nbr_as(ospf
, type5
);
2130 /* create new translated LSA */
2131 if ((new = ospf_lsa_translated_nssa_new(ospf
, type7
)) == NULL
) {
2132 if (IS_DEBUG_OSPF_NSSA
)
2134 "ospf_translated_nssa_refresh(): Could not translate Type-7 for %pI4 to Type-5",
2139 if (type7
->area
->suppress_fa
== 1) {
2140 if (extold
->e
[0].fwd_addr
.s_addr
== 0)
2141 new->data
->ls_seqnum
= htonl(ls_seqnum
+ 1);
2144 if (!(new = ospf_lsa_install(ospf
, NULL
, new))) {
2146 EC_OSPF_LSA_INSTALL_FAILURE
,
2147 "ospf_translated_nssa_refresh(): Could not install translated LSA, Id %pI4",
2152 /* Flood LSA through area. */
2153 ospf_flood_through_as(ospf
, NULL
, new);
2158 /* Originate an AS-external-LSA, install and flood. */
2159 struct ospf_lsa
*ospf_external_lsa_originate(struct ospf
*ospf
,
2160 struct external_info
*ei
)
2162 struct ospf_lsa
*new;
2164 if (ospf
->gr_info
.restart_in_progress
) {
2165 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2167 "LSA[Type5]: Graceful Restart in progress, don't originate");
2171 /* Added for NSSA project....
2173 External LSAs are originated in ASBRs as usual, but for NSSA
2175 there is the global Type-5 LSDB and a Type-7 LSDB installed for
2176 every area. The Type-7's are flooded to every IR and every ABR; We
2177 install the Type-5 LSDB so that the normal "refresh" code operates
2178 as usual, and flag them as not used during ASE calculations. The
2179 Type-7 LSDB is used for calculations. Each Type-7 has a Forwarding
2180 Address of non-zero.
2182 If an ABR is the elected NSSA translator, following SPF and during
2183 the ABR task it will translate all the scanned Type-7's, with P-bit
2184 ON and not-self generated, and translate to Type-5's throughout the
2187 A difference in operation depends whether this ASBR is an ABR
2188 or not. If not an ABR, the P-bit is ON, to indicate that any
2189 elected NSSA-ABR can perform its translation.
2191 If an ABR, the P-bit is OFF; No ABR will perform translation and
2192 this ASBR will flood the Type-5 LSA as usual.
2194 For the case where this ASBR is not an ABR, the ASE calculations
2195 are based on the Type-5 LSDB; The Type-7 LSDB exists just to
2196 demonstrate to the user that there are LSA's that belong to any
2199 Finally, it just so happens that when the ABR is translating every
2200 Type-7 into Type-5, it installs it into the Type-5 LSDB as an
2201 approved Type-5 (translated from Type-7); at the end of translation
2202 if any Translated Type-5's remain unapproved, then they must be
2203 flushed from the AS.
2207 if (ospf
->router_id
.s_addr
== INADDR_ANY
) {
2208 if (IS_DEBUG_OSPF_EVENT
)
2210 "LSA[Type5:%pI4]: deferring AS-external-LSA origination, router ID is zero",
2215 /* Create new AS-external-LSA instance. */
2216 if ((new = ospf_external_lsa_new(ospf
, ei
, NULL
)) == NULL
) {
2217 if (IS_DEBUG_OSPF_EVENT
)
2219 "LSA[Type5:%pI4]: Could not originate AS-external-LSA",
2224 /* Install newly created LSA into Type-5 LSDB, lock = 1. */
2225 ospf_lsa_install(ospf
, NULL
, new);
2227 /* Update LSA origination count. */
2228 ospf
->lsa_originate_count
++;
2230 /* Flooding new LSA. only to AS (non-NSSA/STUB) */
2231 ospf_flood_through_as(ospf
, NULL
, new);
2233 /* If there is any attached NSSA, do special handling */
2234 if (ospf
->anyNSSA
&&
2235 /* stay away from translated LSAs! */
2236 !(CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
)))
2237 ospf_install_flood_nssa(
2238 ospf
, new, ei
); /* Install/Flood Type-7 to all NSSAs */
2240 /* Debug logging. */
2241 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
2242 zlog_debug("LSA[Type%d:%pI4]: Originate AS-external-LSA %p",
2243 new->data
->type
, &new->data
->id
,
2245 ospf_lsa_header_dump(new->data
);
2251 static struct external_info
*ospf_default_external_info(struct ospf
*ospf
)
2254 struct prefix_ipv4 p
;
2255 struct external_info
*default_ei
;
2259 p
.prefix
.s_addr
= 0;
2262 default_ei
= ospf_external_info_lookup(ospf
, DEFAULT_ROUTE
, 0, &p
);
2266 /* First, lookup redistributed default route. */
2267 for (type
= 0; type
<= ZEBRA_ROUTE_MAX
; type
++) {
2268 struct list
*ext_list
;
2270 if (type
== ZEBRA_ROUTE_OSPF
)
2273 ext_list
= ospf
->external
[type
];
2277 ret
= ospf_external_default_routemap_apply_walk(ospf
, ext_list
,
2286 void ospf_external_lsa_rid_change(struct ospf
*ospf
)
2288 struct external_info
*ei
;
2289 struct ospf_external_aggr_rt
*aggr
;
2290 struct ospf_lsa
*lsa
= NULL
;
2294 for (type
= 0; type
< ZEBRA_ROUTE_MAX
; type
++) {
2295 struct route_node
*rn
;
2296 struct route_table
*rt
;
2297 struct list
*ext_list
;
2298 struct listnode
*node
;
2299 struct ospf_external
*ext
;
2301 ext_list
= ospf
->external
[type
];
2305 for (ALL_LIST_ELEMENTS_RO(ext_list
, node
, ext
)) {
2306 /* Originate As-external-LSA from all type of
2307 * distribute source.
2309 rt
= ext
->external_info
;
2313 for (rn
= route_top(rt
); rn
; rn
= route_next(rn
)) {
2319 if (is_default_prefix4(&ei
->p
))
2322 lsa
= ospf_external_info_find_lsa(ospf
, &ei
->p
);
2324 aggr
= ospf_external_aggr_match(ospf
, &ei
->p
);
2327 if (!ospf_redistribute_check(ospf
, ei
,
2331 if (IS_DEBUG_OSPF(lsa
, EXTNL_LSA_AGGR
))
2333 "Originate Summary LSA after reset/router-ID change");
2335 /* Here the LSA is originated as new */
2336 ospf_originate_summary_lsa(ospf
, aggr
,
2339 /* LSA needs to be refreshed even if
2340 * there is no change in the route
2341 * params if the LSA is in maxage.
2343 if (IS_LSA_MAXAGE(lsa
))
2344 force
= LSA_REFRESH_FORCE
;
2346 force
= LSA_REFRESH_IF_CHANGED
;
2348 ospf_external_lsa_refresh(ospf
, lsa
,
2351 if (!ospf_redistribute_check(ospf
, ei
,
2355 if (!ospf_external_lsa_originate(ospf
,
2358 EC_OSPF_LSA_INSTALL_FAILURE
,
2359 "LSA: AS-external-LSA was not originated.");
2365 ei
= ospf_default_external_info(ospf
);
2366 if (ei
&& !ospf_external_lsa_originate(ospf
, ei
)) {
2367 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE
,
2368 "LSA: AS-external-LSA for default route was not originated.");
2372 /* Flush any NSSA LSAs for given prefix */
2373 void ospf_nssa_lsa_flush(struct ospf
*ospf
, struct prefix_ipv4
*p
)
2375 struct listnode
*node
, *nnode
;
2376 struct ospf_lsa
*lsa
= NULL
;
2377 struct ospf_area
*area
;
2379 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
2380 if (area
->external_routing
== OSPF_AREA_NSSA
) {
2381 lsa
= ospf_lsa_lookup(ospf
, area
, OSPF_AS_NSSA_LSA
,
2382 p
->prefix
, ospf
->router_id
);
2384 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2386 "LSA: There is no such AS-NSSA-LSA %pFX in LSDB",
2390 ospf_ls_retransmit_delete_nbr_area(area
, lsa
);
2391 if (!IS_LSA_MAXAGE(lsa
)) {
2392 ospf_refresher_unregister_lsa(ospf
, lsa
);
2393 ospf_lsa_flush_area(lsa
, area
);
2399 /* Flush an AS-external-LSA from LSDB and routing domain. */
2400 void ospf_external_lsa_flush(struct ospf
*ospf
, uint8_t type
,
2401 struct prefix_ipv4
*p
,
2402 ifindex_t ifindex
/*, struct in_addr nexthop */)
2404 struct ospf_lsa
*lsa
;
2406 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2407 zlog_debug("LSA: Flushing AS-external-LSA %pFX", p
);
2409 /* First lookup LSA from LSDB. */
2410 if (!(lsa
= ospf_external_info_find_lsa(ospf
, p
))) {
2411 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2413 "LSA: There is no such AS-external-LSA %pFX in LSDB",
2418 /* If LSA is selforiginated, not a translated LSA, and there is
2419 * NSSA area, flush Type-7 LSA's at first.
2421 if (IS_LSA_SELF(lsa
) && (ospf
->anyNSSA
)
2422 && !(CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
)))
2423 ospf_nssa_lsa_flush(ospf
, p
);
2425 if (!IS_LSA_MAXAGE(lsa
)) {
2426 /* Sweep LSA from Link State Retransmit List. */
2427 ospf_ls_retransmit_delete_nbr_as(ospf
, lsa
);
2429 /* Unregister LSA from Refresh queue. */
2430 ospf_refresher_unregister_lsa(ospf
, lsa
);
2432 /* Flush AS-external-LSA through AS. */
2433 ospf_lsa_flush_as(ospf
, lsa
);
2436 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2437 zlog_debug("ospf_external_lsa_flush(): stop");
2440 void ospf_external_lsa_refresh_default(struct ospf
*ospf
)
2442 struct prefix_ipv4 p
;
2443 struct external_info
*ei
;
2444 struct ospf_lsa
*lsa
;
2448 p
.prefix
.s_addr
= INADDR_ANY
;
2450 ei
= ospf_default_external_info(ospf
);
2451 lsa
= ospf_external_info_find_lsa(ospf
, &p
);
2454 if (IS_DEBUG_OSPF_EVENT
)
2455 zlog_debug("LSA[Type5:0.0.0.0]: Refresh AS-external-LSA %p",
2457 ospf_external_lsa_refresh(ospf
, lsa
, ei
, LSA_REFRESH_FORCE
,
2459 } else if (ei
&& !lsa
) {
2460 if (IS_DEBUG_OSPF_EVENT
)
2462 "LSA[Type5:0.0.0.0]: Originate AS-external-LSA");
2463 ospf_external_lsa_originate(ospf
, ei
);
2465 if (IS_DEBUG_OSPF_EVENT
)
2466 zlog_debug("LSA[Type5:0.0.0.0]: Flush AS-external-LSA");
2467 ospf_external_lsa_flush(ospf
, DEFAULT_ROUTE
, &p
, 0);
2471 void ospf_external_lsa_refresh_type(struct ospf
*ospf
, uint8_t type
,
2472 unsigned short instance
, int force
)
2474 struct route_node
*rn
;
2475 struct external_info
*ei
;
2476 struct ospf_external
*ext
;
2478 if (type
== DEFAULT_ROUTE
)
2481 ext
= ospf_external_lookup(ospf
, type
, instance
);
2483 if (ext
&& EXTERNAL_INFO(ext
)) {
2484 /* Refresh each redistributed AS-external-LSAs. */
2485 for (rn
= route_top(EXTERNAL_INFO(ext
)); rn
;
2486 rn
= route_next(rn
)) {
2489 if (!is_default_prefix4(&ei
->p
)) {
2490 struct ospf_lsa
*lsa
;
2491 struct ospf_external_aggr_rt
*aggr
;
2493 aggr
= ospf_external_aggr_match(ospf
,
2495 lsa
= ospf_external_info_find_lsa(
2498 /* Check the AS-external-LSA
2499 * should be originated.
2501 if (!ospf_redistribute_check(
2504 ospf_unlink_ei_from_aggr(
2513 "%s: Send Aggreate LSA (%pFX)",
2517 ospf_originate_summary_lsa(
2522 if (IS_LSA_MAXAGE(lsa
))
2523 force
= LSA_REFRESH_FORCE
;
2525 ospf_external_lsa_refresh(
2526 ospf
, lsa
, ei
, force
,
2529 if (!ospf_redistribute_check(
2532 ospf_external_lsa_originate(
2541 /* Refresh AS-external-LSA. */
2542 struct ospf_lsa
*ospf_external_lsa_refresh(struct ospf
*ospf
,
2543 struct ospf_lsa
*lsa
,
2544 struct external_info
*ei
, int force
,
2547 struct ospf_lsa
*new;
2550 /* Check the AS-external-LSA should be originated. */
2552 if (!ospf_redistribute_check(ospf
, ei
, &changed
)) {
2553 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2555 "LSA[Type%d:%pI4] Could not be refreshed, redist check fail",
2559 ospf_external_lsa_flush(ospf
, ei
->type
, &ei
->p
,
2560 ei
->ifindex
/*, ei->nexthop */);
2564 if (!changed
&& !force
) {
2565 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2567 "LSA[Type%d:%pI4]: Not refreshed, not changed/forced",
2568 lsa
->data
->type
, &lsa
->data
->id
);
2572 /* Delete LSA from neighbor retransmit-list. */
2573 ospf_ls_retransmit_delete_nbr_as(ospf
, lsa
);
2575 /* Unregister AS-external-LSA from refresh-list. */
2576 ospf_refresher_unregister_lsa(ospf
, lsa
);
2578 new = ospf_external_lsa_new(ospf
, ei
, &lsa
->data
->id
);
2581 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2582 zlog_debug("LSA[Type%d:%pI4]: Could not be refreshed",
2583 lsa
->data
->type
, &lsa
->data
->id
);
2587 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
2589 ospf_lsa_install(ospf
, NULL
, new); /* As type-5. */
2591 /* Flood LSA through AS. */
2592 ospf_flood_through_as(ospf
, NULL
, new);
2594 /* If any attached NSSA, install as Type-7, flood to all NSSA Areas */
2595 if (ospf
->anyNSSA
&& !(CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
)))
2596 ospf_install_flood_nssa(ospf
, new,
2597 ei
); /* Install/Flood per new rules */
2599 /* Register self-originated LSA to refresh queue.
2600 * Translated LSAs should not be registered, but refreshed upon
2601 * refresh of the Type-7
2603 if (!CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
))
2604 ospf_refresher_register_lsa(ospf
, new);
2606 /* Debug logging. */
2607 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
2608 zlog_debug("LSA[Type%d:%pI4]: AS-external-LSA refresh",
2609 new->data
->type
, &new->data
->id
);
2610 ospf_lsa_header_dump(new->data
);
2617 /* LSA installation functions. */
2619 /* Install router-LSA to an area. */
2620 static struct ospf_lsa
*
2621 ospf_router_lsa_install(struct ospf
*ospf
, struct ospf_lsa
*new, int rt_recalc
)
2623 struct ospf_area
*area
= new->area
;
2625 /* RFC 2328 Section 13.2 Router-LSAs and network-LSAs
2626 The entire routing table must be recalculated, starting with
2627 the shortest path calculations for each area (not just the
2628 area whose link-state database has changed).
2631 if (IS_LSA_SELF(new)) {
2633 /* Only install LSA if it is originated/refreshed by us.
2634 * If LSA was received by flooding, the RECEIVED flag is set so
2636 * not link the LSA */
2637 if (CHECK_FLAG(new->flags
, OSPF_LSA_RECEIVED
))
2638 return new; /* ignore stale LSA */
2640 /* Set self-originated router-LSA. */
2641 ospf_lsa_unlock(&area
->router_lsa_self
);
2642 area
->router_lsa_self
= ospf_lsa_lock(new);
2644 ospf_refresher_register_lsa(ospf
, new);
2647 ospf_spf_calculate_schedule(ospf
, SPF_FLAG_ROUTER_LSA_INSTALL
);
2651 /* Install network-LSA to an area. */
2652 static struct ospf_lsa
*ospf_network_lsa_install(struct ospf
*ospf
,
2653 struct ospf_interface
*oi
,
2654 struct ospf_lsa
*new,
2658 /* RFC 2328 Section 13.2 Router-LSAs and network-LSAs
2659 The entire routing table must be recalculated, starting with
2660 the shortest path calculations for each area (not just the
2661 area whose link-state database has changed).
2663 if (IS_LSA_SELF(new)) {
2664 /* We supposed that when LSA is originated by us, we pass the
2666 for which it was originated. If LSA was received by flooding,
2667 the RECEIVED flag is set, so we do not link the LSA to the
2669 if (CHECK_FLAG(new->flags
, OSPF_LSA_RECEIVED
))
2670 return new; /* ignore stale LSA */
2672 ospf_lsa_unlock(&oi
->network_lsa_self
);
2673 oi
->network_lsa_self
= ospf_lsa_lock(new);
2674 ospf_refresher_register_lsa(ospf
, new);
2677 ospf_spf_calculate_schedule(ospf
, SPF_FLAG_NETWORK_LSA_INSTALL
);
2682 /* Install summary-LSA to an area. */
2683 static struct ospf_lsa
*
2684 ospf_summary_lsa_install(struct ospf
*ospf
, struct ospf_lsa
*new, int rt_recalc
)
2686 if (rt_recalc
&& !IS_LSA_SELF(new)) {
2687 /* RFC 2328 Section 13.2 Summary-LSAs
2688 The best route to the destination described by the summary-
2689 LSA must be recalculated (see Section 16.5). If this
2690 destination is an AS boundary router, it may also be
2691 necessary to re-examine all the AS-external-LSAs.
2694 ospf_spf_calculate_schedule(ospf
, SPF_FLAG_SUMMARY_LSA_INSTALL
);
2697 if (IS_LSA_SELF(new))
2698 ospf_refresher_register_lsa(ospf
, new);
2703 /* Install ASBR-summary-LSA to an area. */
2704 static struct ospf_lsa
*ospf_summary_asbr_lsa_install(struct ospf
*ospf
,
2705 struct ospf_lsa
*new,
2708 if (rt_recalc
&& !IS_LSA_SELF(new)) {
2709 /* RFC 2328 Section 13.2 Summary-LSAs
2710 The best route to the destination described by the summary-
2711 LSA must be recalculated (see Section 16.5). If this
2712 destination is an AS boundary router, it may also be
2713 necessary to re-examine all the AS-external-LSAs.
2715 ospf_spf_calculate_schedule(ospf
,
2716 SPF_FLAG_ASBR_SUMMARY_LSA_INSTALL
);
2719 /* register LSA to refresh-list. */
2720 if (IS_LSA_SELF(new))
2721 ospf_refresher_register_lsa(ospf
, new);
2726 /* Install AS-external-LSA. */
2727 static struct ospf_lsa
*ospf_external_lsa_install(struct ospf
*ospf
,
2728 struct ospf_lsa
*new,
2731 ospf_ase_register_external_lsa(new, ospf
);
2732 /* If LSA is not self-originated, calculate an external route. */
2734 /* RFC 2328 Section 13.2 AS-external-LSAs
2735 The best route to the destination described by the AS-
2736 external-LSA must be recalculated (see Section 16.6).
2739 if (!IS_LSA_SELF(new))
2740 ospf_ase_incremental_update(ospf
, new);
2743 if (new->data
->type
== OSPF_AS_NSSA_LSA
) {
2744 /* There is no point to register selforiginate Type-7 LSA for
2745 * refreshing. We rely on refreshing Type-5 LSA's
2747 if (IS_LSA_SELF(new))
2750 /* Try refresh type-5 translated LSA for this LSA, if
2752 * New translations will be taken care of by the
2755 ospf_translated_nssa_refresh(ospf
, new, NULL
);
2756 ospf_schedule_abr_task(ospf
);
2760 /* Register self-originated LSA to refresh queue.
2761 * Leave Translated LSAs alone if NSSA is enabled
2763 if (IS_LSA_SELF(new) && !CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
))
2764 ospf_refresher_register_lsa(ospf
, new);
2769 void ospf_discard_from_db(struct ospf
*ospf
, struct ospf_lsdb
*lsdb
,
2770 struct ospf_lsa
*lsa
)
2772 struct ospf_lsa
*old
;
2777 old
= ospf_lsdb_lookup(lsdb
, lsa
);
2782 if (old
->refresh_list
>= 0)
2783 ospf_refresher_unregister_lsa(ospf
, old
);
2785 switch (old
->data
->type
) {
2786 case OSPF_AS_EXTERNAL_LSA
:
2787 ospf_ase_unregister_external_lsa(old
, ospf
);
2788 ospf_ls_retransmit_delete_nbr_as(ospf
, old
);
2790 case OSPF_OPAQUE_AS_LSA
:
2791 ospf_ls_retransmit_delete_nbr_as(ospf
, old
);
2793 case OSPF_AS_NSSA_LSA
:
2794 ospf_ls_retransmit_delete_nbr_area(old
->area
, old
);
2795 ospf_ase_unregister_external_lsa(old
, ospf
);
2798 ospf_ls_retransmit_delete_nbr_area(old
->area
, old
);
2802 ospf_lsa_maxage_delete(ospf
, old
);
2803 ospf_lsa_discard(old
);
2806 struct ospf_lsa
*ospf_lsa_install(struct ospf
*ospf
, struct ospf_interface
*oi
,
2807 struct ospf_lsa
*lsa
)
2809 struct ospf_lsa
*new = NULL
;
2810 struct ospf_lsa
*old
= NULL
;
2811 struct ospf_lsdb
*lsdb
= NULL
;
2815 switch (lsa
->data
->type
) {
2817 case OSPF_AS_NSSA_LSA
:
2819 lsdb
= lsa
->area
->lsdb
;
2823 case OSPF_AS_EXTERNAL_LSA
:
2824 case OSPF_OPAQUE_AS_LSA
:
2829 lsdb
= lsa
->area
->lsdb
;
2835 /* RFC 2328 13.2. Installing LSAs in the database
2837 Installing a new LSA in the database, either as the result of
2838 flooding or a newly self-originated LSA, may cause the OSPF
2839 routing table structure to be recalculated. The contents of the
2840 new LSA should be compared to the old instance, if present. If
2841 there is no difference, there is no need to recalculate the
2842 routing table. When comparing an LSA to its previous instance,
2843 the following are all considered to be differences in contents:
2845 o The LSA's Options field has changed.
2847 o One of the LSA instances has LS age set to MaxAge, and
2850 o The length field in the LSA header has changed.
2852 o The body of the LSA (i.e., anything outside the 20-byte
2853 LSA header) has changed. Note that this excludes changes
2854 in LS Sequence Number and LS Checksum.
2857 /* Look up old LSA and determine if any SPF calculation or incremental
2859 old
= ospf_lsdb_lookup(lsdb
, lsa
);
2861 /* Do comparison and record if recalc needed. */
2863 if (old
== NULL
|| ospf_lsa_different(old
, lsa
, false)) {
2864 /* Ref rfc3623 section 3.2.3
2865 * Installing new lsa or change in the existing LSA
2866 * or flushing existing LSA leads to topo change
2867 * and trigger SPF caculation.
2868 * So, router should be aborted from HELPER role
2869 * if it is detected as TOPO change.
2871 if (ospf
->active_restarter_cnt
2872 && CHECK_LSA_TYPE_1_TO_5_OR_7(lsa
->data
->type
)
2873 && ospf_lsa_different(old
, lsa
, true))
2874 ospf_helper_handle_topo_chg(ospf
, lsa
);
2880 Sequence number check (Section 14.1 of rfc 2328)
2881 "Premature aging is used when it is time for a self-originated
2882 LSA's sequence number field to wrap. At this point, the current
2883 LSA instance (having LS sequence number MaxSequenceNumber) must
2884 be prematurely aged and flushed from the routing domain before a
2885 new instance with sequence number equal to InitialSequenceNumber
2886 can be originated. "
2889 if (ntohl(lsa
->data
->ls_seqnum
) - 1 == OSPF_MAX_SEQUENCE_NUMBER
) {
2890 if (ospf_lsa_is_self_originated(ospf
, lsa
)) {
2891 lsa
->data
->ls_seqnum
= htonl(OSPF_MAX_SEQUENCE_NUMBER
);
2893 if (!IS_LSA_MAXAGE(lsa
))
2894 lsa
->flags
|= OSPF_LSA_PREMATURE_AGE
;
2895 lsa
->data
->ls_age
= htons(OSPF_LSA_MAXAGE
);
2897 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
)) {
2899 "%s() Premature Aging lsa %p, seqnum 0x%x",
2901 ntohl(lsa
->data
->ls_seqnum
));
2902 ospf_lsa_header_dump(lsa
->data
);
2905 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
2907 "%s() got an lsa with seq 0x80000000 that was not self originated. Ignoring",
2909 ospf_lsa_header_dump(lsa
->data
);
2915 /* discard old LSA from LSDB */
2917 ospf_discard_from_db(ospf
, lsdb
, lsa
);
2919 /* Calculate Checksum if self-originated?. */
2920 if (IS_LSA_SELF(lsa
))
2921 ospf_lsa_checksum(lsa
->data
);
2923 /* Insert LSA to LSDB. */
2924 ospf_lsdb_add(lsdb
, lsa
);
2927 /* Do LSA specific installation process. */
2928 switch (lsa
->data
->type
) {
2929 case OSPF_ROUTER_LSA
:
2930 new = ospf_router_lsa_install(ospf
, lsa
, rt_recalc
);
2932 case OSPF_NETWORK_LSA
:
2934 new = ospf_network_lsa_install(ospf
, oi
, lsa
, rt_recalc
);
2936 case OSPF_SUMMARY_LSA
:
2937 new = ospf_summary_lsa_install(ospf
, lsa
, rt_recalc
);
2939 case OSPF_ASBR_SUMMARY_LSA
:
2940 new = ospf_summary_asbr_lsa_install(ospf
, lsa
, rt_recalc
);
2942 case OSPF_AS_EXTERNAL_LSA
:
2943 new = ospf_external_lsa_install(ospf
, lsa
, rt_recalc
);
2945 case OSPF_OPAQUE_LINK_LSA
:
2946 if (IS_LSA_SELF(lsa
))
2947 lsa
->oi
= oi
; /* Specify outgoing ospf-interface for
2950 /* Incoming "oi" for this LSA has set at LSUpd
2954 case OSPF_OPAQUE_AREA_LSA
:
2955 case OSPF_OPAQUE_AS_LSA
:
2956 new = ospf_opaque_lsa_install(lsa
, rt_recalc
);
2958 case OSPF_AS_NSSA_LSA
:
2959 new = ospf_external_lsa_install(ospf
, lsa
, rt_recalc
);
2960 default: /* type-6,8,9....nothing special */
2965 return new; /* Installation failed, cannot proceed further --
2969 if (IS_DEBUG_OSPF(lsa
, LSA_INSTALL
)) {
2970 switch (lsa
->data
->type
) {
2971 case OSPF_AS_EXTERNAL_LSA
:
2972 case OSPF_OPAQUE_AS_LSA
:
2973 case OSPF_AS_NSSA_LSA
:
2974 zlog_debug("LSA[%s]: Install %s", dump_lsa_key(new),
2975 lookup_msg(ospf_lsa_type_msg
,
2976 new->data
->type
, NULL
));
2979 zlog_debug("LSA[%s]: Install %s to Area %pI4",
2981 lookup_msg(ospf_lsa_type_msg
,
2982 new->data
->type
, NULL
),
2983 &new->area
->area_id
);
2989 If received LSA' ls_age is MaxAge, or lsa is being prematurely aged
2990 (it's getting flushed out of the area), set LSA on MaxAge LSA list.
2992 if (IS_LSA_MAXAGE(new)) {
2993 if (IS_DEBUG_OSPF(lsa
, LSA_INSTALL
))
2994 zlog_debug("LSA[%s]: Install LSA %p, MaxAge",
2995 dump_lsa_key(new), lsa
);
2996 ospf_lsa_maxage(ospf
, lsa
);
3003 int ospf_check_nbr_status(struct ospf
*ospf
)
3005 struct listnode
*node
, *nnode
;
3006 struct ospf_interface
*oi
;
3008 for (ALL_LIST_ELEMENTS(ospf
->oiflist
, node
, nnode
, oi
)) {
3009 struct route_node
*rn
;
3010 struct ospf_neighbor
*nbr
;
3012 if (ospf_if_is_enable(oi
))
3013 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
3014 if ((nbr
= rn
->info
) != NULL
)
3015 if (nbr
->state
== NSM_Exchange
3016 || nbr
->state
== NSM_Loading
) {
3017 route_unlock_node(rn
);
3026 static void ospf_maxage_lsa_remover(struct thread
*thread
)
3028 struct ospf
*ospf
= THREAD_ARG(thread
);
3029 struct ospf_lsa
*lsa
, *old
;
3030 struct route_node
*rn
;
3033 ospf
->t_maxage
= NULL
;
3035 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3036 zlog_debug("LSA[MaxAge]: remover Start");
3038 reschedule
= !ospf_check_nbr_status(ospf
);
3041 for (rn
= route_top(ospf
->maxage_lsa
); rn
;
3042 rn
= route_next(rn
)) {
3043 if ((lsa
= rn
->info
) == NULL
) {
3047 /* There is at least one neighbor from which we still
3049 * for that LSA, so we are not allowed to remove it from
3051 * as per RFC 2328 section 14 para 4 a) */
3052 if (lsa
->retransmit_counter
> 0) {
3057 /* TODO: maybe convert this function to a work-queue */
3058 if (thread_should_yield(thread
)) {
3059 OSPF_TIMER_ON(ospf
->t_maxage
,
3060 ospf_maxage_lsa_remover
, 0);
3062 rn
); /* route_top/route_next */
3066 /* Remove LSA from the LSDB */
3067 if (IS_LSA_SELF(lsa
))
3068 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3070 "LSA[Type%d:%pI4]: LSA 0x%lx is self-originated: ",
3073 (unsigned long)lsa
);
3075 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3077 "LSA[%s]: MaxAge LSA removed from list",
3080 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_PREMATURE_AGE
)) {
3081 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3083 "originating new lsa for lsa %p",
3085 ospf_lsa_refresh(ospf
, lsa
);
3088 /* Remove from lsdb. */
3090 old
= ospf_lsdb_lookup(lsa
->lsdb
, lsa
);
3091 /* The max age LSA here must be the same
3092 * as the LSA in LSDB
3095 flog_err(EC_OSPF_LSA_MISSING
,
3096 "%s: LSA[%s]: LSA not in LSDB",
3097 __func__
, dump_lsa_key(lsa
));
3101 ospf_discard_from_db(ospf
, lsa
->lsdb
, lsa
);
3102 ospf_lsdb_delete(lsa
->lsdb
, lsa
);
3104 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3106 "%s: LSA[%s]: No associated LSDB!",
3107 __func__
, dump_lsa_key(lsa
));
3111 /* A MaxAge LSA must be removed immediately from the router's link
3112 state database as soon as both a) it is no longer contained on any
3113 neighbor Link state retransmission lists and b) none of the
3115 neighbors are in states Exchange or Loading. */
3117 OSPF_TIMER_ON(ospf
->t_maxage
, ospf_maxage_lsa_remover
,
3118 ospf
->maxage_delay
);
3121 /* This function checks whether an LSA with initial sequence number should be
3122 * originated after a wrap in sequence number
3124 void ospf_check_and_gen_init_seq_lsa(struct ospf_interface
*oi
,
3125 struct ospf_lsa
*recv_lsa
)
3127 struct ospf_lsa
*lsa
= NULL
;
3128 struct ospf
*ospf
= oi
->ospf
;
3130 lsa
= ospf_lsa_lookup_by_header(oi
->area
, recv_lsa
->data
);
3132 if ((lsa
== NULL
) || (!CHECK_FLAG(lsa
->flags
, OSPF_LSA_PREMATURE_AGE
))
3133 || (lsa
->retransmit_counter
!= 0)) {
3134 if (IS_DEBUG_OSPF(lsa
, LSA
))
3136 "Do not generate LSA with initial seqence number.");
3140 ospf_lsa_maxage_delete(ospf
, lsa
);
3142 lsa
->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
3144 ospf_lsa_refresh(ospf
, lsa
);
3147 void ospf_lsa_maxage_delete(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3149 struct route_node
*rn
;
3150 struct prefix lsa_prefix
;
3152 memset(&lsa_prefix
, 0, sizeof(lsa_prefix
));
3153 lsa_prefix
.family
= AF_UNSPEC
;
3154 lsa_prefix
.prefixlen
= sizeof(lsa_prefix
.u
.ptr
) * CHAR_BIT
;
3155 lsa_prefix
.u
.ptr
= (uintptr_t)lsa
;
3157 if ((rn
= route_node_lookup(ospf
->maxage_lsa
, &lsa_prefix
))) {
3158 if (rn
->info
== lsa
) {
3159 UNSET_FLAG(lsa
->flags
, OSPF_LSA_IN_MAXAGE
);
3160 ospf_lsa_unlock(&lsa
); /* maxage_lsa */
3163 rn
); /* unlock node because lsa is deleted */
3165 route_unlock_node(rn
); /* route_node_lookup */
3167 if (IS_DEBUG_OSPF_EVENT
)
3168 zlog_debug("%s: lsa %s is not found in maxage db.",
3169 __func__
, dump_lsa_key(lsa
));
3173 /* Add LSA onto the MaxAge list, and schedule for removal.
3174 * This does *not* lead to the LSA being flooded, that must be taken
3175 * care of elsewhere, see, e.g., ospf_lsa_flush* (which are callers of this
3178 void ospf_lsa_maxage(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3180 struct prefix lsa_prefix
;
3181 struct route_node
*rn
;
3183 /* When we saw a MaxAge LSA flooded to us, we put it on the list
3184 and schedule the MaxAge LSA remover. */
3185 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_IN_MAXAGE
)) {
3186 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3188 "LSA[%s]: %p already exists on MaxAge LSA list",
3189 dump_lsa_key(lsa
), lsa
);
3193 memset(&lsa_prefix
, 0, sizeof(lsa_prefix
));
3194 lsa_prefix
.family
= AF_UNSPEC
;
3195 lsa_prefix
.prefixlen
= sizeof(lsa_prefix
.u
.ptr
) * CHAR_BIT
;
3196 lsa_prefix
.u
.ptr
= (uintptr_t)lsa
;
3198 rn
= route_node_get(ospf
->maxage_lsa
, &lsa_prefix
);
3199 if (rn
->info
!= NULL
) {
3200 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3202 "LSA[%s]: found LSA (%p) in table for LSA %p %d",
3203 dump_lsa_key(lsa
), rn
->info
,
3204 (void *)lsa
, lsa_prefix
.prefixlen
);
3205 route_unlock_node(rn
);
3207 rn
->info
= ospf_lsa_lock(lsa
);
3208 SET_FLAG(lsa
->flags
, OSPF_LSA_IN_MAXAGE
);
3211 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3212 zlog_debug("LSA[%s]: MaxAge LSA remover scheduled.",
3215 OSPF_TIMER_ON(ospf
->t_maxage
, ospf_maxage_lsa_remover
,
3216 ospf
->maxage_delay
);
3219 static int ospf_lsa_maxage_walker_remover(struct ospf
*ospf
,
3220 struct ospf_lsa
*lsa
)
3222 /* Stay away from any Local Translated Type-7 LSAs */
3223 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
))
3226 if (IS_LSA_MAXAGE(lsa
))
3227 /* Self-originated LSAs should NOT time-out instead,
3228 they're flushed and submitted to the max_age list explicitly.
3230 if (!ospf_lsa_is_self_originated(ospf
, lsa
)) {
3231 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
3232 zlog_debug("LSA[%s]: is MaxAge",
3235 switch (lsa
->data
->type
) {
3236 case OSPF_OPAQUE_LINK_LSA
:
3237 case OSPF_OPAQUE_AREA_LSA
:
3238 case OSPF_OPAQUE_AS_LSA
:
3240 * As a general rule, whenever network topology
3242 * (due to an LSA removal in this case), routing
3244 * should be triggered. However, this is not
3246 * LSAs. Even if an opaque LSA instance is going
3248 * from the routing domain, it does not mean a
3250 * topology, and thus, routing recalculation is
3254 case OSPF_AS_EXTERNAL_LSA
:
3255 case OSPF_AS_NSSA_LSA
:
3256 ospf_ase_incremental_update(ospf
, lsa
);
3259 ospf_spf_calculate_schedule(ospf
,
3263 ospf_lsa_maxage(ospf
, lsa
);
3266 if (IS_LSA_MAXAGE(lsa
) && !ospf_lsa_is_self_originated(ospf
, lsa
))
3267 if (LS_AGE(lsa
) > OSPF_LSA_MAXAGE
+ 30)
3268 printf("Eek! Shouldn't happen!\n");
3273 /* Periodical check of MaxAge LSA. */
3274 void ospf_lsa_maxage_walker(struct thread
*thread
)
3276 struct ospf
*ospf
= THREAD_ARG(thread
);
3277 struct route_node
*rn
;
3278 struct ospf_lsa
*lsa
;
3279 struct ospf_area
*area
;
3280 struct listnode
*node
, *nnode
;
3282 ospf
->t_maxage_walker
= NULL
;
3284 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
3285 LSDB_LOOP (ROUTER_LSDB(area
), rn
, lsa
)
3286 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3287 LSDB_LOOP (NETWORK_LSDB(area
), rn
, lsa
)
3288 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3289 LSDB_LOOP (SUMMARY_LSDB(area
), rn
, lsa
)
3290 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3291 LSDB_LOOP (ASBR_SUMMARY_LSDB(area
), rn
, lsa
)
3292 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3293 LSDB_LOOP (OPAQUE_AREA_LSDB(area
), rn
, lsa
)
3294 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3295 LSDB_LOOP (OPAQUE_LINK_LSDB(area
), rn
, lsa
)
3296 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3297 LSDB_LOOP (NSSA_LSDB(area
), rn
, lsa
)
3298 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3301 /* for AS-external-LSAs. */
3303 LSDB_LOOP (EXTERNAL_LSDB(ospf
), rn
, lsa
)
3304 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3305 LSDB_LOOP (OPAQUE_AS_LSDB(ospf
), rn
, lsa
)
3306 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3309 OSPF_TIMER_ON(ospf
->t_maxage_walker
, ospf_lsa_maxage_walker
,
3310 OSPF_LSA_MAXAGE_CHECK_INTERVAL
);
3313 struct ospf_lsa
*ospf_lsa_lookup_by_prefix(struct ospf_lsdb
*lsdb
, uint8_t type
,
3314 struct prefix_ipv4
*p
,
3315 struct in_addr router_id
)
3317 struct ospf_lsa
*lsa
;
3318 struct in_addr mask
, id
;
3319 struct lsa_header_mask
{
3320 struct lsa_header header
;
3321 struct in_addr mask
;
3324 lsa
= ospf_lsdb_lookup_by_id(lsdb
, type
, p
->prefix
, router_id
);
3328 masklen2ip(p
->prefixlen
, &mask
);
3330 hmask
= (struct lsa_header_mask
*)lsa
->data
;
3332 if (mask
.s_addr
!= hmask
->mask
.s_addr
) {
3333 id
.s_addr
= p
->prefix
.s_addr
| (~mask
.s_addr
);
3334 lsa
= ospf_lsdb_lookup_by_id(lsdb
, type
, id
, router_id
);
3342 struct ospf_lsa
*ospf_lsa_lookup(struct ospf
*ospf
, struct ospf_area
*area
,
3343 uint32_t type
, struct in_addr id
,
3344 struct in_addr adv_router
)
3350 case OSPF_ROUTER_LSA
:
3351 case OSPF_NETWORK_LSA
:
3352 case OSPF_SUMMARY_LSA
:
3353 case OSPF_ASBR_SUMMARY_LSA
:
3354 case OSPF_AS_NSSA_LSA
:
3355 case OSPF_OPAQUE_LINK_LSA
:
3356 case OSPF_OPAQUE_AREA_LSA
:
3357 return ospf_lsdb_lookup_by_id(area
->lsdb
, type
, id
, adv_router
);
3358 case OSPF_AS_EXTERNAL_LSA
:
3359 case OSPF_OPAQUE_AS_LSA
:
3360 return ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, id
, adv_router
);
3368 struct ospf_lsa
*ospf_lsa_lookup_by_id(struct ospf_area
*area
, uint32_t type
,
3371 struct ospf_lsa
*lsa
;
3372 struct route_node
*rn
;
3375 case OSPF_ROUTER_LSA
:
3376 return ospf_lsdb_lookup_by_id(area
->lsdb
, type
, id
, id
);
3377 case OSPF_NETWORK_LSA
:
3378 for (rn
= route_top(NETWORK_LSDB(area
)); rn
;
3379 rn
= route_next(rn
))
3380 if ((lsa
= rn
->info
))
3381 if (IPV4_ADDR_SAME(&lsa
->data
->id
, &id
)) {
3382 route_unlock_node(rn
);
3386 case OSPF_SUMMARY_LSA
:
3387 case OSPF_ASBR_SUMMARY_LSA
:
3388 /* Currently not used. */
3390 return ospf_lsdb_lookup_by_id(area
->lsdb
, type
, id
, id
);
3391 case OSPF_AS_EXTERNAL_LSA
:
3392 case OSPF_AS_NSSA_LSA
:
3393 case OSPF_OPAQUE_LINK_LSA
:
3394 case OSPF_OPAQUE_AREA_LSA
:
3395 case OSPF_OPAQUE_AS_LSA
:
3396 /* Currently not used. */
3405 struct ospf_lsa
*ospf_lsa_lookup_by_header(struct ospf_area
*area
,
3406 struct lsa_header
*lsah
)
3408 struct ospf_lsa
*match
;
3411 * Strictly speaking, the LSA-ID field for Opaque-LSAs (type-9/10/11)
3412 * is redefined to have two subfields; opaque-type and opaque-id.
3413 * However, it is harmless to treat the two sub fields together, as if
3414 * they two were forming a unique LSA-ID.
3417 match
= ospf_lsa_lookup(area
->ospf
, area
, lsah
->type
, lsah
->id
,
3421 if (IS_DEBUG_OSPF(lsa
, LSA
) == OSPF_DEBUG_LSA
)
3422 zlog_debug("LSA[Type%d:%pI4]: Lookup by header, NO MATCH",
3423 lsah
->type
, &lsah
->id
);
3428 /* return +n, l1 is more recent.
3429 return -n, l2 is more recent.
3430 return 0, l1 and l2 is identical. */
3431 int ospf_lsa_more_recent(struct ospf_lsa
*l1
, struct ospf_lsa
*l2
)
3436 if (l1
== NULL
&& l2
== NULL
)
3443 /* compare LS sequence number. */
3444 x
= (int)ntohl(l1
->data
->ls_seqnum
);
3445 y
= (int)ntohl(l2
->data
->ls_seqnum
);
3451 /* compare LS checksum. */
3452 r
= ntohs(l1
->data
->checksum
) - ntohs(l2
->data
->checksum
);
3456 /* compare LS age. */
3457 if (IS_LSA_MAXAGE(l1
) && !IS_LSA_MAXAGE(l2
))
3459 else if (!IS_LSA_MAXAGE(l1
) && IS_LSA_MAXAGE(l2
))
3462 /* compare LS age with MaxAgeDiff. */
3463 if (LS_AGE(l1
) - LS_AGE(l2
) > OSPF_LSA_MAXAGE_DIFF
)
3465 else if (LS_AGE(l2
) - LS_AGE(l1
) > OSPF_LSA_MAXAGE_DIFF
)
3468 /* LSAs are identical. */
3473 * Check if two LSAs are different.
3476 * The first LSA to compare.
3479 * The second LSA to compare.
3482 * When set to true, ignore whether the LSAs were received from the network
3483 * or not. This parameter should be set to true when checking for topology
3484 * changes as part of the Graceful Restart helper neighbor procedures.
3487 * true if the LSAs are different, false otherwise.
3489 int ospf_lsa_different(struct ospf_lsa
*l1
, struct ospf_lsa
*l2
,
3490 bool ignore_rcvd_flag
)
3498 if (l1
->data
->options
!= l2
->data
->options
)
3501 if (IS_LSA_MAXAGE(l1
) && !IS_LSA_MAXAGE(l2
))
3504 if (IS_LSA_MAXAGE(l2
) && !IS_LSA_MAXAGE(l1
))
3507 if (l1
->size
!= l2
->size
)
3513 if (!ignore_rcvd_flag
3514 && CHECK_FLAG((l1
->flags
^ l2
->flags
), OSPF_LSA_RECEIVED
))
3515 return 1; /* May be a stale LSA in the LSBD */
3517 assert(l1
->size
> OSPF_LSA_HEADER_SIZE
);
3519 p1
= (char *)l1
->data
;
3520 p2
= (char *)l2
->data
;
3522 if (memcmp(p1
+ OSPF_LSA_HEADER_SIZE
, p2
+ OSPF_LSA_HEADER_SIZE
,
3523 l1
->size
- OSPF_LSA_HEADER_SIZE
)
3530 int ospf_lsa_flush_schedule(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3532 if (lsa
== NULL
|| !IS_LSA_SELF(lsa
))
3535 if (IS_DEBUG_OSPF_EVENT
)
3537 "LSA[Type%d:%pI4]: Schedule self-originated LSA to FLUSH",
3538 lsa
->data
->type
, &lsa
->data
->id
);
3540 /* Force given lsa's age to MaxAge. */
3541 lsa
->data
->ls_age
= htons(OSPF_LSA_MAXAGE
);
3543 switch (lsa
->data
->type
) {
3544 /* Opaque wants to be notified of flushes */
3545 case OSPF_OPAQUE_LINK_LSA
:
3546 case OSPF_OPAQUE_AREA_LSA
:
3547 case OSPF_OPAQUE_AS_LSA
:
3548 ospf_opaque_lsa_refresh(lsa
);
3551 ospf_refresher_unregister_lsa(ospf
, lsa
);
3552 ospf_lsa_flush(ospf
, lsa
);
3559 void ospf_flush_self_originated_lsas_now(struct ospf
*ospf
)
3561 struct listnode
*node
, *nnode
;
3562 struct listnode
*node2
, *nnode2
;
3563 struct ospf_area
*area
;
3564 struct ospf_interface
*oi
;
3565 struct ospf_lsa
*lsa
;
3566 struct route_node
*rn
;
3567 int need_to_flush_ase
= 0;
3569 ospf
->inst_shutdown
= 1;
3571 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
3572 if ((lsa
= area
->router_lsa_self
) != NULL
) {
3573 if (IS_DEBUG_OSPF_EVENT
)
3575 "LSA[Type%d:%pI4]: Schedule self-originated LSA to FLUSH",
3579 ospf_refresher_unregister_lsa(ospf
, lsa
);
3580 ospf_lsa_flush_area(lsa
, area
);
3581 ospf_lsa_unlock(&area
->router_lsa_self
);
3582 area
->router_lsa_self
= NULL
;
3585 for (ALL_LIST_ELEMENTS(area
->oiflist
, node2
, nnode2
, oi
)) {
3586 if ((lsa
= oi
->network_lsa_self
) != NULL
3587 && oi
->state
== ISM_DR
&& oi
->full_nbrs
> 0) {
3588 if (IS_DEBUG_OSPF_EVENT
)
3590 "LSA[Type%d:%pI4]: Schedule self-originated LSA to FLUSH",
3594 ospf_refresher_unregister_lsa(
3595 ospf
, oi
->network_lsa_self
);
3596 ospf_lsa_flush_area(oi
->network_lsa_self
, area
);
3597 ospf_lsa_unlock(&oi
->network_lsa_self
);
3598 oi
->network_lsa_self
= NULL
;
3601 if (oi
->type
!= OSPF_IFTYPE_VIRTUALLINK
3602 && area
->external_routing
== OSPF_AREA_DEFAULT
)
3603 need_to_flush_ase
= 1;
3606 LSDB_LOOP (SUMMARY_LSDB(area
), rn
, lsa
)
3607 ospf_lsa_flush_schedule(ospf
, lsa
);
3608 LSDB_LOOP (ASBR_SUMMARY_LSDB(area
), rn
, lsa
)
3609 ospf_lsa_flush_schedule(ospf
, lsa
);
3610 LSDB_LOOP (OPAQUE_LINK_LSDB(area
), rn
, lsa
)
3611 ospf_lsa_flush_schedule(ospf
, lsa
);
3612 LSDB_LOOP (OPAQUE_AREA_LSDB(area
), rn
, lsa
)
3613 ospf_lsa_flush_schedule(ospf
, lsa
);
3616 if (need_to_flush_ase
) {
3617 LSDB_LOOP (EXTERNAL_LSDB(ospf
), rn
, lsa
)
3618 ospf_lsa_flush_schedule(ospf
, lsa
);
3619 LSDB_LOOP (OPAQUE_AS_LSDB(ospf
), rn
, lsa
)
3620 ospf_lsa_flush_schedule(ospf
, lsa
);
3624 * Make sure that the MaxAge LSA remover is executed immediately,
3625 * without conflicting to other threads.
3627 if (ospf
->t_maxage
!= NULL
) {
3628 OSPF_TIMER_OFF(ospf
->t_maxage
);
3629 thread_execute(master
, ospf_maxage_lsa_remover
, ospf
, 0);
3635 /* If there is self-originated LSA, then return 1, otherwise return 0. */
3636 /* An interface-independent version of ospf_lsa_is_self_originated */
3637 int ospf_lsa_is_self_originated(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3639 struct listnode
*node
;
3640 struct ospf_interface
*oi
;
3642 /* This LSA is already checked. */
3643 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_SELF_CHECKED
))
3644 return IS_LSA_SELF(lsa
);
3646 /* Make sure LSA is self-checked. */
3647 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF_CHECKED
);
3649 /* AdvRouter and Router ID is the same. */
3650 if (IPV4_ADDR_SAME(&lsa
->data
->adv_router
, &ospf
->router_id
))
3651 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF
);
3653 /* LSA is router-LSA. */
3654 else if (lsa
->data
->type
== OSPF_ROUTER_LSA
3655 && IPV4_ADDR_SAME(&lsa
->data
->id
, &ospf
->router_id
))
3656 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF
);
3658 /* LSA is network-LSA. Compare Link ID with all interfaces. */
3659 else if (lsa
->data
->type
== OSPF_NETWORK_LSA
)
3660 for (ALL_LIST_ELEMENTS_RO(ospf
->oiflist
, node
, oi
)) {
3661 /* Ignore virtual link. */
3662 if (oi
->type
!= OSPF_IFTYPE_VIRTUALLINK
)
3663 if (oi
->address
->family
== AF_INET
)
3666 &oi
->address
->u
.prefix4
)) {
3667 /* to make it easier later */
3668 SET_FLAG(lsa
->flags
,
3670 return IS_LSA_SELF(lsa
);
3674 return IS_LSA_SELF(lsa
);
3677 /* Get unique Link State ID. */
3678 enum lsid_status
ospf_lsa_unique_id(struct ospf
*ospf
, struct ospf_lsdb
*lsdb
,
3679 uint8_t type
, struct prefix_ipv4
*p
,
3682 struct ospf_lsa
*lsa
;
3683 struct in_addr mask
;
3687 /* Check existence of LSA instance. */
3688 lsa
= ospf_lsdb_lookup_by_id(lsdb
, type
, *id
, ospf
->router_id
);
3690 struct as_external_lsa
*al
=
3691 (struct as_external_lsa
*)lsa
->data
;
3692 /* Ref rfc2328,Appendex E.1
3693 * If router already originated the external lsa with lsid
3694 * as the current prefix, and the masklens are same then
3695 * terminate the LSID algorithem.
3697 if (ip_masklen(al
->mask
) == p
->prefixlen
) {
3698 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
3700 "%s: Can't get Link State ID for %pFX",
3702 /* id.s_addr = 0; */
3703 id
->s_addr
= 0xffffffff;
3704 return LSID_NOT_AVAILABLE
;
3705 } else if (ip_masklen(al
->mask
) < p
->prefixlen
) {
3706 /* Ref rfc2328,Appendex E.2
3707 * the current prefix masklen is greater than the
3708 * existing LSA, then generate the Link state ID,
3709 * by setting all host bits in prefix addressa and
3712 * Eg: 1st Route : 10.0.0.0/16 - LSID:10.0.0.0
3713 * 2nd Route : 10.0.0.0/24 - LSID:10.0.0.255
3715 masklen2ip(p
->prefixlen
, &mask
);
3717 id
->s_addr
= p
->prefix
.s_addr
| (~mask
.s_addr
);
3718 lsa
= ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, *id
,
3721 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
3723 "%s: Can't get Link State ID for %pFX",
3725 id
->s_addr
= 0xffffffff;
3726 return LSID_NOT_AVAILABLE
;
3729 /* Ref rfc2328,Appendex E.3
3730 * the current prefix masklen is lesser than the
3731 * existing LSA,then the originated LSA has to be
3732 * refreshed by modifying masklen, cost and tag.
3733 * Originate the old route info with new LSID by
3734 * setting the host bits in prefix address.
3736 * Eg: 1st Route : 10.0.0.0/24 - LSID:10.0.0.0
3737 * 2nd Route : 10.0.0.0/16 - ?
3738 * Since 2nd route mask len is less than firstone
3739 * LSID has to be changed.
3740 * 1st route LSID:10.0.0.255
3741 * 2nd route LSID:10.0.0.0
3743 id
->s_addr
= lsa
->data
->id
.s_addr
| (~al
->mask
.s_addr
);
3744 lsa
= ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, *id
,
3746 if (lsa
&& (ip_masklen(al
->mask
) != IPV4_MAX_BITLEN
)) {
3747 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
3749 "%s: Can't get Link State ID for %pFX",
3751 id
->s_addr
= 0xffffffff;
3752 return LSID_NOT_AVAILABLE
;
3758 return LSID_AVAILABLE
;
3762 #define LSA_ACTION_FLOOD_AREA 1
3763 #define LSA_ACTION_FLUSH_AREA 2
3767 struct ospf_area
*area
;
3768 struct ospf_lsa
*lsa
;
3771 static void ospf_lsa_action(struct thread
*t
)
3773 struct lsa_action
*data
;
3775 data
= THREAD_ARG(t
);
3777 if (IS_DEBUG_OSPF(lsa
, LSA
) == OSPF_DEBUG_LSA
)
3778 zlog_debug("LSA[Action]: Performing scheduled LSA action: %d",
3781 switch (data
->action
) {
3782 case LSA_ACTION_FLOOD_AREA
:
3783 ospf_flood_through_area(data
->area
, NULL
, data
->lsa
);
3785 case LSA_ACTION_FLUSH_AREA
:
3786 ospf_lsa_flush_area(data
->lsa
, data
->area
);
3790 ospf_lsa_unlock(&data
->lsa
); /* Message */
3791 XFREE(MTYPE_OSPF_MESSAGE
, data
);
3794 void ospf_schedule_lsa_flood_area(struct ospf_area
*area
, struct ospf_lsa
*lsa
)
3796 struct lsa_action
*data
;
3798 data
= XCALLOC(MTYPE_OSPF_MESSAGE
, sizeof(struct lsa_action
));
3799 data
->action
= LSA_ACTION_FLOOD_AREA
;
3801 data
->lsa
= ospf_lsa_lock(lsa
); /* Message / Flood area */
3803 thread_add_event(master
, ospf_lsa_action
, data
, 0, NULL
);
3806 void ospf_schedule_lsa_flush_area(struct ospf_area
*area
, struct ospf_lsa
*lsa
)
3808 struct lsa_action
*data
;
3810 data
= XCALLOC(MTYPE_OSPF_MESSAGE
, sizeof(struct lsa_action
));
3811 data
->action
= LSA_ACTION_FLUSH_AREA
;
3813 data
->lsa
= ospf_lsa_lock(lsa
); /* Message / Flush area */
3815 thread_add_event(master
, ospf_lsa_action
, data
, 0, NULL
);
3819 /* LSA Refreshment functions. */
3820 struct ospf_lsa
*ospf_lsa_refresh(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3822 struct external_info
*ei
;
3823 struct ospf_external_aggr_rt
*aggr
;
3824 struct ospf_lsa
*new = NULL
;
3825 struct as_external_lsa
*al
;
3826 struct prefix_ipv4 p
;
3828 assert(CHECK_FLAG(lsa
->flags
, OSPF_LSA_SELF
));
3829 assert(IS_LSA_SELF(lsa
));
3830 assert(lsa
->lock
> 0);
3832 switch (lsa
->data
->type
) {
3833 /* Router and Network LSAs are processed differently. */
3834 case OSPF_ROUTER_LSA
:
3835 new = ospf_router_lsa_refresh(lsa
);
3837 case OSPF_NETWORK_LSA
:
3838 new = ospf_network_lsa_refresh(lsa
);
3840 case OSPF_SUMMARY_LSA
:
3841 new = ospf_summary_lsa_refresh(ospf
, lsa
);
3843 case OSPF_ASBR_SUMMARY_LSA
:
3844 new = ospf_summary_asbr_lsa_refresh(ospf
, lsa
);
3846 case OSPF_AS_EXTERNAL_LSA
:
3847 /* Translated from NSSA Type-5s are refreshed when
3848 * from refresh of Type-7 - do not refresh these directly.
3851 al
= (struct as_external_lsa
*)lsa
->data
;
3853 p
.prefixlen
= ip_masklen(al
->mask
);
3854 p
.prefix
= lsa
->data
->id
;
3856 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
))
3858 ei
= ospf_external_info_check(ospf
, lsa
);
3860 new = ospf_external_lsa_refresh(
3861 ospf
, lsa
, ei
, LSA_REFRESH_FORCE
, false);
3863 aggr
= (struct ospf_external_aggr_rt
*)
3864 ospf_extrenal_aggregator_lookup(ospf
, &p
);
3866 struct external_info ei_aggr
;
3868 memset(&ei_aggr
, 0, sizeof(ei_aggr
));
3869 ei_aggr
.p
= aggr
->p
;
3870 ei_aggr
.tag
= aggr
->tag
;
3871 ei_aggr
.instance
= ospf
->instance
;
3872 ei_aggr
.route_map_set
.metric
= -1;
3873 ei_aggr
.route_map_set
.metric_type
= -1;
3875 ospf_external_lsa_refresh(ospf
, lsa
, &ei_aggr
,
3876 LSA_REFRESH_FORCE
, true);
3877 SET_FLAG(aggr
->flags
,
3878 OSPF_EXTERNAL_AGGRT_ORIGINATED
);
3880 ospf_lsa_flush_as(ospf
, lsa
);
3883 case OSPF_OPAQUE_LINK_LSA
:
3884 case OSPF_OPAQUE_AREA_LSA
:
3885 case OSPF_OPAQUE_AS_LSA
:
3886 new = ospf_opaque_lsa_refresh(lsa
);
3894 void ospf_refresher_register_lsa(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3896 uint16_t index
, current_index
;
3898 assert(lsa
->lock
> 0);
3899 assert(IS_LSA_SELF(lsa
));
3901 if (lsa
->refresh_list
< 0) {
3904 OSPF_LS_REFRESH_TIME
- (2 * OSPF_LS_REFRESH_JITTER
);
3905 int max_delay
= OSPF_LS_REFRESH_TIME
- OSPF_LS_REFRESH_JITTER
;
3907 /* We want to refresh the LSA within OSPF_LS_REFRESH_TIME which
3909 * 1800s. Use jitter so that we send the LSA sometime between
3913 delay
= (frr_weak_random() % (max_delay
- min_delay
))
3916 current_index
= ospf
->lsa_refresh_queue
.index
3917 + (monotime(NULL
) - ospf
->lsa_refresher_started
)
3918 / OSPF_LSA_REFRESHER_GRANULARITY
;
3920 index
= (current_index
+ delay
/ OSPF_LSA_REFRESHER_GRANULARITY
)
3921 % (OSPF_LSA_REFRESHER_SLOTS
);
3923 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3925 "LSA[Refresh:Type%d:%pI4]: age %d, added to index %d",
3926 lsa
->data
->type
, &lsa
->data
->id
,
3927 LS_AGE(lsa
), index
);
3929 if (!ospf
->lsa_refresh_queue
.qs
[index
])
3930 ospf
->lsa_refresh_queue
.qs
[index
] = list_new();
3932 listnode_add(ospf
->lsa_refresh_queue
.qs
[index
],
3933 ospf_lsa_lock(lsa
)); /* lsa_refresh_queue */
3934 lsa
->refresh_list
= index
;
3936 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3938 "LSA[Refresh:Type%d:%pI4]: ospf_refresher_register_lsa(): setting refresh_list on lsa %p (slod %d)",
3939 lsa
->data
->type
, &lsa
->data
->id
,
3940 (void *)lsa
, index
);
3944 void ospf_refresher_unregister_lsa(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3946 assert(lsa
->lock
> 0);
3947 assert(IS_LSA_SELF(lsa
));
3948 if (lsa
->refresh_list
>= 0) {
3949 struct list
*refresh_list
=
3950 ospf
->lsa_refresh_queue
.qs
[lsa
->refresh_list
];
3951 listnode_delete(refresh_list
, lsa
);
3952 if (!listcount(refresh_list
)) {
3953 list_delete(&refresh_list
);
3954 ospf
->lsa_refresh_queue
.qs
[lsa
->refresh_list
] = NULL
;
3956 lsa
->refresh_list
= -1;
3957 ospf_lsa_unlock(&lsa
); /* lsa_refresh_queue */
3961 void ospf_lsa_refresh_walker(struct thread
*t
)
3963 struct list
*refresh_list
;
3964 struct listnode
*node
, *nnode
;
3965 struct ospf
*ospf
= THREAD_ARG(t
);
3966 struct ospf_lsa
*lsa
;
3968 struct list
*lsa_to_refresh
= list_new();
3970 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3971 zlog_debug("LSA[Refresh]: ospf_lsa_refresh_walker(): start");
3974 i
= ospf
->lsa_refresh_queue
.index
;
3976 /* Note: if clock has jumped backwards, then time change could be
3978 so we are careful to cast the expression to unsigned before taking
3980 ospf
->lsa_refresh_queue
.index
=
3981 ((unsigned long)(ospf
->lsa_refresh_queue
.index
3983 - ospf
->lsa_refresher_started
)
3984 / OSPF_LSA_REFRESHER_GRANULARITY
))
3985 % OSPF_LSA_REFRESHER_SLOTS
;
3987 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3989 "LSA[Refresh]: ospf_lsa_refresh_walker(): next index %d",
3990 ospf
->lsa_refresh_queue
.index
);
3992 for (; i
!= ospf
->lsa_refresh_queue
.index
;
3993 i
= (i
+ 1) % OSPF_LSA_REFRESHER_SLOTS
) {
3994 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3996 "LSA[Refresh]: ospf_lsa_refresh_walker(): refresh index %d",
3999 refresh_list
= ospf
->lsa_refresh_queue
.qs
[i
];
4003 ospf
->lsa_refresh_queue
.qs
[i
] = NULL
;
4006 for (ALL_LIST_ELEMENTS(refresh_list
, node
, nnode
,
4008 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
4010 "LSA[Refresh:Type%d:%pI4]: ospf_lsa_refresh_walker(): refresh lsa %p (slot %d)",
4015 assert(lsa
->lock
> 0);
4016 list_delete_node(refresh_list
, node
);
4017 lsa
->refresh_list
= -1;
4018 listnode_add(lsa_to_refresh
, lsa
);
4020 list_delete(&refresh_list
);
4024 ospf
->t_lsa_refresher
= NULL
;
4025 thread_add_timer(master
, ospf_lsa_refresh_walker
, ospf
,
4026 ospf
->lsa_refresh_interval
, &ospf
->t_lsa_refresher
);
4027 ospf
->lsa_refresher_started
= monotime(NULL
);
4029 for (ALL_LIST_ELEMENTS(lsa_to_refresh
, node
, nnode
, lsa
)) {
4030 ospf_lsa_refresh(ospf
, lsa
);
4031 assert(lsa
->lock
> 0);
4033 &lsa
); /* lsa_refresh_queue & temp for lsa_to_refresh*/
4036 list_delete(&lsa_to_refresh
);
4038 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
4039 zlog_debug("LSA[Refresh]: ospf_lsa_refresh_walker(): end");
4042 /* Flush the LSAs for the specific area */
4043 void ospf_flush_lsa_from_area(struct ospf
*ospf
, struct in_addr area_id
,
4046 struct ospf_area
*area
;
4047 struct route_node
*rn
;
4048 struct ospf_lsa
*lsa
;
4050 area
= ospf_area_get(ospf
, area_id
);
4053 case OSPF_AS_EXTERNAL_LSA
:
4054 if ((area
->external_routing
== OSPF_AREA_NSSA
) ||
4055 (area
->external_routing
== OSPF_AREA_STUB
)) {
4056 LSDB_LOOP (EXTERNAL_LSDB(ospf
), rn
, lsa
)
4057 if (IS_LSA_SELF(lsa
) &&
4058 !(CHECK_FLAG(lsa
->flags
,
4059 OSPF_LSA_LOCAL_XLT
)))
4060 ospf_lsa_flush_area(lsa
, area
);
4063 case OSPF_AS_NSSA_LSA
:
4064 LSDB_LOOP (NSSA_LSDB(area
), rn
, lsa
)
4065 if (IS_LSA_SELF(lsa
))
4066 ospf_lsa_flush_area(lsa
, area
);