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() */
37 #include "ospfd/ospfd.h"
38 #include "ospfd/ospf_interface.h"
39 #include "ospfd/ospf_ism.h"
40 #include "ospfd/ospf_asbr.h"
41 #include "ospfd/ospf_lsa.h"
42 #include "ospfd/ospf_lsdb.h"
43 #include "ospfd/ospf_neighbor.h"
44 #include "ospfd/ospf_nsm.h"
45 #include "ospfd/ospf_flood.h"
46 #include "ospfd/ospf_packet.h"
47 #include "ospfd/ospf_spf.h"
48 #include "ospfd/ospf_dump.h"
49 #include "ospfd/ospf_route.h"
50 #include "ospfd/ospf_ase.h"
51 #include "ospfd/ospf_zebra.h"
52 #include "ospfd/ospf_abr.h"
55 uint32_t get_metric(uint8_t *metric
)
59 m
= (m
<< 8) + metric
[1];
60 m
= (m
<< 8) + metric
[2];
65 struct timeval
int2tv(int a
)
75 struct timeval
msec2tv(int a
)
79 ret
.tv_sec
= a
/ 1000;
80 ret
.tv_usec
= (a
% 1000) * 1000;
85 int ospf_lsa_refresh_delay(struct ospf_lsa
*lsa
)
90 if (monotime_since(&lsa
->tv_orig
, &delta
)
91 < OSPF_MIN_LS_INTERVAL
* 1000LL) {
92 struct timeval minv
= msec2tv(OSPF_MIN_LS_INTERVAL
);
93 timersub(&minv
, &delta
, &minv
);
95 /* TBD: remove padding to full sec, return timeval instead */
96 delay
= minv
.tv_sec
+ !!minv
.tv_usec
;
98 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
100 "LSA[Type%d:%s]: Refresh timer delay %d seconds",
101 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
),
111 int get_age(struct ospf_lsa
*lsa
)
115 monotime_since(&lsa
->tv_recv
, &rel
);
116 return ntohs(lsa
->data
->ls_age
) + rel
.tv_sec
;
120 /* Fletcher Checksum -- Refer to RFC1008. */
122 /* All the offsets are zero-based. The offsets in the RFC1008 are
124 uint16_t ospf_lsa_checksum(struct lsa_header
*lsa
)
126 uint8_t *buffer
= (uint8_t *)&lsa
->options
;
127 int options_offset
= buffer
- (uint8_t *)&lsa
->ls_age
; /* should be 2 */
129 /* Skip the AGE field */
130 uint16_t len
= ntohs(lsa
->length
) - options_offset
;
132 /* Checksum offset starts from "options" field, not the beginning of the
133 lsa_header struct. The offset is 14, rather than 16. */
134 int checksum_offset
= (uint8_t *)&lsa
->checksum
- buffer
;
136 return fletcher_checksum(buffer
, len
, checksum_offset
);
139 int ospf_lsa_checksum_valid(struct lsa_header
*lsa
)
141 uint8_t *buffer
= (uint8_t *)&lsa
->options
;
142 int options_offset
= buffer
- (uint8_t *)&lsa
->ls_age
; /* should be 2 */
144 /* Skip the AGE field */
145 uint16_t len
= ntohs(lsa
->length
) - options_offset
;
147 return (fletcher_checksum(buffer
, len
, FLETCHER_CHECKSUM_VALIDATE
)
152 /* Create OSPF LSA. */
153 struct ospf_lsa
*ospf_lsa_new()
155 struct ospf_lsa
*new;
157 new = XCALLOC(MTYPE_OSPF_LSA
, sizeof(struct ospf_lsa
));
161 new->retransmit_counter
= 0;
162 monotime(&new->tv_recv
);
163 new->tv_orig
= new->tv_recv
;
164 new->refresh_list
= -1;
165 new->vrf_id
= VRF_DEFAULT
;
170 struct ospf_lsa
*ospf_lsa_new_and_data(size_t size
)
172 struct ospf_lsa
*new;
174 new = ospf_lsa_new();
175 new->data
= ospf_lsa_data_new(size
);
180 /* Duplicate OSPF LSA. */
181 struct ospf_lsa
*ospf_lsa_dup(struct ospf_lsa
*lsa
)
183 struct ospf_lsa
*new;
188 new = XCALLOC(MTYPE_OSPF_LSA
, sizeof(struct ospf_lsa
));
190 memcpy(new, lsa
, sizeof(struct ospf_lsa
));
191 UNSET_FLAG(new->flags
, OSPF_LSA_DISCARD
);
193 new->retransmit_counter
= 0;
194 new->data
= ospf_lsa_data_dup(lsa
->data
);
196 /* kevinm: Clear the refresh_list, otherwise there are going
197 to be problems when we try to remove the LSA from the
198 queue (which it's not a member of.)
199 XXX: Should we add the LSA to the refresh_list queue? */
200 new->refresh_list
= -1;
202 if (IS_DEBUG_OSPF(lsa
, LSA
))
203 zlog_debug("LSA: duplicated %p (new: %p)", (void *)lsa
,
210 void ospf_lsa_free(struct ospf_lsa
*lsa
)
212 assert(lsa
->lock
== 0);
214 if (IS_DEBUG_OSPF(lsa
, LSA
))
215 zlog_debug("LSA: freed %p", (void *)lsa
);
217 /* Delete LSA data. */
218 if (lsa
->data
!= NULL
)
219 ospf_lsa_data_free(lsa
->data
);
221 assert(lsa
->refresh_list
< 0);
223 memset(lsa
, 0, sizeof(struct ospf_lsa
));
224 XFREE(MTYPE_OSPF_LSA
, lsa
);
228 struct ospf_lsa
*ospf_lsa_lock(struct ospf_lsa
*lsa
)
235 void ospf_lsa_unlock(struct ospf_lsa
**lsa
)
237 /* This is sanity check. */
243 assert((*lsa
)->lock
>= 0);
245 if ((*lsa
)->lock
== 0) {
246 assert(CHECK_FLAG((*lsa
)->flags
, OSPF_LSA_DISCARD
));
252 /* Check discard flag. */
253 void ospf_lsa_discard(struct ospf_lsa
*lsa
)
255 if (!CHECK_FLAG(lsa
->flags
, OSPF_LSA_DISCARD
)) {
256 SET_FLAG(lsa
->flags
, OSPF_LSA_DISCARD
);
257 ospf_lsa_unlock(&lsa
);
261 /* Create LSA data. */
262 struct lsa_header
*ospf_lsa_data_new(size_t size
)
264 return XCALLOC(MTYPE_OSPF_LSA_DATA
, size
);
267 /* Duplicate LSA data. */
268 struct lsa_header
*ospf_lsa_data_dup(struct lsa_header
*lsah
)
270 struct lsa_header
*new;
272 new = ospf_lsa_data_new(ntohs(lsah
->length
));
273 memcpy(new, lsah
, ntohs(lsah
->length
));
279 void ospf_lsa_data_free(struct lsa_header
*lsah
)
281 if (IS_DEBUG_OSPF(lsa
, LSA
))
282 zlog_debug("LSA[Type%d:%s]: data freed %p", lsah
->type
,
283 inet_ntoa(lsah
->id
), (void *)lsah
);
285 XFREE(MTYPE_OSPF_LSA_DATA
, lsah
);
289 /* LSA general functions. */
291 const char *dump_lsa_key(struct ospf_lsa
*lsa
)
293 static char buf
[] = {"Type255,id(255.255.255.255),ar(255.255.255.255)"};
294 struct lsa_header
*lsah
;
296 if (lsa
!= NULL
&& (lsah
= lsa
->data
) != NULL
) {
297 char id
[INET_ADDRSTRLEN
], ar
[INET_ADDRSTRLEN
];
298 strlcpy(id
, inet_ntoa(lsah
->id
), sizeof(id
));
299 strlcpy(ar
, inet_ntoa(lsah
->adv_router
), sizeof(ar
));
301 sprintf(buf
, "Type%d,id(%s),ar(%s)", lsah
->type
, id
, ar
);
303 strlcpy(buf
, "NULL", sizeof(buf
));
308 uint32_t lsa_seqnum_increment(struct ospf_lsa
*lsa
)
312 seqnum
= ntohl(lsa
->data
->ls_seqnum
) + 1;
314 return htonl(seqnum
);
317 void lsa_header_set(struct stream
*s
, uint8_t options
, uint8_t type
,
318 struct in_addr id
, struct in_addr router_id
)
320 struct lsa_header
*lsah
;
322 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
324 lsah
->ls_age
= htons(OSPF_LSA_INITIAL_AGE
);
325 lsah
->options
= options
;
328 lsah
->adv_router
= router_id
;
329 lsah
->ls_seqnum
= htonl(OSPF_INITIAL_SEQUENCE_NUMBER
);
331 stream_forward_endp(s
, OSPF_LSA_HEADER_SIZE
);
335 /* router-LSA related functions. */
336 /* Get router-LSA flags. */
337 static uint8_t router_lsa_flags(struct ospf_area
*area
)
341 flags
= area
->ospf
->flags
;
343 /* Set virtual link flag. */
344 if (ospf_full_virtual_nbrs(area
))
345 SET_FLAG(flags
, ROUTER_LSA_VIRTUAL
);
347 /* Just sanity check */
348 UNSET_FLAG(flags
, ROUTER_LSA_VIRTUAL
);
350 /* Set Shortcut ABR behabiour flag. */
351 UNSET_FLAG(flags
, ROUTER_LSA_SHORTCUT
);
352 if (area
->ospf
->abr_type
== OSPF_ABR_SHORTCUT
)
353 if (!OSPF_IS_AREA_BACKBONE(area
))
354 if ((area
->shortcut_configured
== OSPF_SHORTCUT_DEFAULT
355 && area
->ospf
->backbone
== NULL
)
356 || area
->shortcut_configured
357 == OSPF_SHORTCUT_ENABLE
)
358 SET_FLAG(flags
, ROUTER_LSA_SHORTCUT
);
360 /* ASBR can't exit in stub area. */
361 if (area
->external_routing
== OSPF_AREA_STUB
)
362 UNSET_FLAG(flags
, ROUTER_LSA_EXTERNAL
);
363 /* If ASBR set External flag */
364 else if (IS_OSPF_ASBR(area
->ospf
))
365 SET_FLAG(flags
, ROUTER_LSA_EXTERNAL
);
367 /* Set ABR dependent flags */
368 if (IS_OSPF_ABR(area
->ospf
)) {
369 SET_FLAG(flags
, ROUTER_LSA_BORDER
);
370 /* If Area is NSSA and we are both ABR and unconditional
372 * set Nt bit to inform other routers.
374 if ((area
->external_routing
== OSPF_AREA_NSSA
)
375 && (area
->NSSATranslatorRole
== OSPF_NSSA_ROLE_ALWAYS
))
376 SET_FLAG(flags
, ROUTER_LSA_NT
);
381 /* Lookup neighbor other than myself.
382 And check neighbor count,
383 Point-to-Point link must have only 1 neighbor. */
384 struct ospf_neighbor
*ospf_nbr_lookup_ptop(struct ospf_interface
*oi
)
386 struct ospf_neighbor
*nbr
= NULL
;
387 struct route_node
*rn
;
389 /* Search neighbor, there must be one of two nbrs. */
390 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
391 if ((nbr
= rn
->info
))
392 if (!IPV4_ADDR_SAME(&nbr
->router_id
,
393 &oi
->ospf
->router_id
))
394 if (nbr
->state
== NSM_Full
) {
395 route_unlock_node(rn
);
399 /* PtoP link must have only 1 neighbor. */
400 if (ospf_nbr_count(oi
, 0) > 1)
401 zlog_warn("Point-to-Point link has more than 1 neighobrs.");
406 /* Determine cost of link, taking RFC3137 stub-router support into
409 static uint16_t ospf_link_cost(struct ospf_interface
*oi
)
411 /* RFC3137 stub router support */
412 if (!CHECK_FLAG(oi
->area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
))
413 return oi
->output_cost
;
415 return OSPF_OUTPUT_COST_INFINITE
;
418 /* Set a link information. */
419 static char link_info_set(struct stream
*s
, struct in_addr id
,
420 struct in_addr data
, uint8_t type
, uint8_t tos
,
423 /* LSA stream is initially allocated to OSPF_MAX_LSA_SIZE, suits
424 * vast majority of cases. Some rare routers with lots of links need
426 * we try accomodate those here.
428 if (STREAM_WRITEABLE(s
) < OSPF_ROUTER_LSA_LINK_SIZE
) {
429 size_t ret
= OSPF_MAX_LSA_SIZE
;
431 /* Can we enlarge the stream still? */
432 if (STREAM_SIZE(s
) == OSPF_MAX_LSA_SIZE
) {
433 /* we futz the size here for simplicity, really we need
436 * IP Header - (sizeof (struct ip))
437 * OSPF Header - OSPF_HEADER_SIZE
438 * LSA Header - OSPF_LSA_HEADER_SIZE
439 * MD5 auth data, if MD5 is configured -
440 * OSPF_AUTH_MD5_SIZE.
442 * Simpler just to subtract OSPF_MAX_LSA_SIZE though.
445 s
, OSPF_MAX_PACKET_SIZE
- OSPF_MAX_LSA_SIZE
);
448 if (ret
== OSPF_MAX_LSA_SIZE
) {
450 "%s: Out of space in LSA stream, left %zd, size %zd",
451 __func__
, STREAM_WRITEABLE(s
), STREAM_SIZE(s
));
456 /* TOS based routing is not supported. */
457 stream_put_ipv4(s
, id
.s_addr
); /* Link ID. */
458 stream_put_ipv4(s
, data
.s_addr
); /* Link Data. */
459 stream_putc(s
, type
); /* Link Type. */
460 stream_putc(s
, tos
); /* TOS = 0. */
461 stream_putw(s
, cost
); /* Link Cost. */
466 /* Describe Point-to-Point link (Section 12.4.1.1). */
467 static int lsa_link_ptop_set(struct stream
*s
, struct ospf_interface
*oi
)
470 struct ospf_neighbor
*nbr
;
471 struct in_addr id
, mask
, data
;
472 uint16_t cost
= ospf_link_cost(oi
);
474 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
475 zlog_debug("LSA[Type1]: Set link Point-to-Point");
477 if ((nbr
= ospf_nbr_lookup_ptop(oi
)))
478 if (nbr
->state
== NSM_Full
) {
479 if (CHECK_FLAG(oi
->connected
->flags
,
480 ZEBRA_IFA_UNNUMBERED
)) {
481 /* For unnumbered point-to-point networks, the
483 should specify the interface's MIB-II ifIndex
485 data
.s_addr
= htonl(oi
->ifp
->ifindex
);
486 links
+= link_info_set(
487 s
, nbr
->router_id
, data
,
488 LSA_LINK_TYPE_POINTOPOINT
, 0, cost
);
490 links
+= link_info_set(
492 oi
->address
->u
.prefix4
,
493 LSA_LINK_TYPE_POINTOPOINT
, 0, cost
);
497 /* no need for a stub link for unnumbered interfaces */
498 if (!CHECK_FLAG(oi
->connected
->flags
, ZEBRA_IFA_UNNUMBERED
)) {
499 /* Regardless of the state of the neighboring router, we must
500 add a Type 3 link (stub network).
501 N.B. Options 1 & 2 share basically the same logic. */
502 masklen2ip(oi
->address
->prefixlen
, &mask
);
503 id
.s_addr
= CONNECTED_PREFIX(oi
->connected
)->u
.prefix4
.s_addr
505 links
+= link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0,
512 /* Describe Broadcast Link. */
513 static int lsa_link_broadcast_set(struct stream
*s
, struct ospf_interface
*oi
)
515 struct ospf_neighbor
*dr
;
516 struct in_addr id
, mask
;
517 uint16_t cost
= ospf_link_cost(oi
);
519 /* Describe Type 3 Link. */
520 if (oi
->state
== ISM_Waiting
) {
521 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
523 "LSA[Type1]: Interface %s is in state Waiting. "
524 "Adding stub interface",
526 masklen2ip(oi
->address
->prefixlen
, &mask
);
527 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
& mask
.s_addr
;
528 return link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0,
532 dr
= ospf_nbr_lookup_by_addr(oi
->nbrs
, &DR(oi
));
533 /* Describe Type 2 link. */
534 if (dr
&& (dr
->state
== NSM_Full
535 || IPV4_ADDR_SAME(&oi
->address
->u
.prefix4
, &DR(oi
)))
536 && ospf_nbr_count(oi
, NSM_Full
) > 0) {
537 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
539 "LSA[Type1]: Interface %s has a DR. "
540 "Adding transit interface",
542 return link_info_set(s
, DR(oi
), oi
->address
->u
.prefix4
,
543 LSA_LINK_TYPE_TRANSIT
, 0, cost
);
545 /* Describe type 3 link. */
547 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
549 "LSA[Type1]: Interface %s has no DR. "
550 "Adding stub interface",
552 masklen2ip(oi
->address
->prefixlen
, &mask
);
553 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
& mask
.s_addr
;
554 return link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0,
559 static int lsa_link_loopback_set(struct stream
*s
, struct ospf_interface
*oi
)
561 struct in_addr id
, mask
;
563 /* Describe Type 3 Link. */
564 if (oi
->state
!= ISM_Loopback
)
567 mask
.s_addr
= 0xffffffff;
568 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
;
569 return link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0, 0);
572 /* Describe Virtual Link. */
573 static int lsa_link_virtuallink_set(struct stream
*s
, struct ospf_interface
*oi
)
575 struct ospf_neighbor
*nbr
;
576 uint16_t cost
= ospf_link_cost(oi
);
578 if (oi
->state
== ISM_PointToPoint
)
579 if ((nbr
= ospf_nbr_lookup_ptop(oi
)))
580 if (nbr
->state
== NSM_Full
) {
581 return link_info_set(s
, nbr
->router_id
,
582 oi
->address
->u
.prefix4
,
583 LSA_LINK_TYPE_VIRTUALLINK
,
590 #define lsa_link_nbma_set(S,O) lsa_link_broadcast_set (S, O)
592 /* this function add for support point-to-multipoint ,see rfc2328
594 /* from "edward rrr" <edward_rrr@hotmail.com>
595 http://marc.theaimsgroup.com/?l=zebra&m=100739222210507&w=2 */
596 static int lsa_link_ptomp_set(struct stream
*s
, struct ospf_interface
*oi
)
599 struct route_node
*rn
;
600 struct ospf_neighbor
*nbr
= NULL
;
601 struct in_addr id
, mask
;
602 uint16_t cost
= ospf_link_cost(oi
);
604 mask
.s_addr
= 0xffffffff;
605 id
.s_addr
= oi
->address
->u
.prefix4
.s_addr
;
606 links
+= link_info_set(s
, id
, mask
, LSA_LINK_TYPE_STUB
, 0, 0);
608 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
609 zlog_debug("PointToMultipoint: running ptomultip_set");
611 /* Search neighbor, */
612 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
613 if ((nbr
= rn
->info
) != NULL
)
615 if (!IPV4_ADDR_SAME(&nbr
->router_id
,
616 &oi
->ospf
->router_id
))
617 if (nbr
->state
== NSM_Full
)
620 links
+= link_info_set(
622 oi
->address
->u
.prefix4
,
623 LSA_LINK_TYPE_POINTOPOINT
, 0,
625 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
627 "PointToMultipoint: set link to %s",
636 /* Set router-LSA link information. */
637 static int router_lsa_link_set(struct stream
*s
, struct ospf_area
*area
)
639 struct listnode
*node
;
640 struct ospf_interface
*oi
;
643 for (ALL_LIST_ELEMENTS_RO(area
->oiflist
, node
, oi
)) {
644 struct interface
*ifp
= oi
->ifp
;
646 /* Check interface is up, OSPF is enable. */
647 if (if_is_operative(ifp
)) {
648 if (oi
->state
!= ISM_Down
) {
649 oi
->lsa_pos_beg
= links
;
650 /* Describe each link. */
652 case OSPF_IFTYPE_POINTOPOINT
:
653 links
+= lsa_link_ptop_set(s
, oi
);
655 case OSPF_IFTYPE_BROADCAST
:
656 links
+= lsa_link_broadcast_set(s
, oi
);
658 case OSPF_IFTYPE_NBMA
:
659 links
+= lsa_link_nbma_set(s
, oi
);
661 case OSPF_IFTYPE_POINTOMULTIPOINT
:
662 links
+= lsa_link_ptomp_set(s
, oi
);
664 case OSPF_IFTYPE_VIRTUALLINK
:
666 lsa_link_virtuallink_set(s
, oi
);
668 case OSPF_IFTYPE_LOOPBACK
:
669 links
+= lsa_link_loopback_set(s
, oi
);
671 oi
->lsa_pos_end
= links
;
679 /* Set router-LSA body. */
680 static void ospf_router_lsa_body_set(struct stream
*s
, struct ospf_area
*area
)
686 stream_putc(s
, router_lsa_flags(area
));
688 /* Set Zero fields. */
691 /* Keep pointer to # links. */
692 putp
= stream_get_endp(s
);
697 /* Set all link information. */
698 cnt
= router_lsa_link_set(s
, area
);
700 /* Set # of links here. */
701 stream_putw_at(s
, putp
, cnt
);
704 static int ospf_stub_router_timer(struct thread
*t
)
706 struct ospf_area
*area
= THREAD_ARG(t
);
708 area
->t_stub_router
= NULL
;
710 SET_FLAG(area
->stub_router_state
, OSPF_AREA_WAS_START_STUB_ROUTED
);
712 /* clear stub route state and generate router-lsa refresh, don't
713 * clobber an administratively set stub-router state though.
715 if (CHECK_FLAG(area
->stub_router_state
, OSPF_AREA_ADMIN_STUB_ROUTED
))
718 UNSET_FLAG(area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
);
720 ospf_router_lsa_update_area(area
);
725 static void ospf_stub_router_check(struct ospf_area
*area
)
727 /* area must either be administratively configured to be stub
728 * or startup-time stub-router must be configured and we must in a
732 if (CHECK_FLAG(area
->stub_router_state
, OSPF_AREA_ADMIN_STUB_ROUTED
)) {
733 SET_FLAG(area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
);
737 /* not admin-stubbed, check whether startup stubbing is configured and
738 * whether it's not been done yet
740 if (CHECK_FLAG(area
->stub_router_state
,
741 OSPF_AREA_WAS_START_STUB_ROUTED
))
744 if (area
->ospf
->stub_router_startup_time
745 == OSPF_STUB_ROUTER_UNCONFIGURED
) {
746 /* stub-router is hence done forever for this area, even if
748 * tries configure it (take effect next restart).
750 SET_FLAG(area
->stub_router_state
,
751 OSPF_AREA_WAS_START_STUB_ROUTED
);
755 /* startup stub-router configured and not yet done */
756 SET_FLAG(area
->stub_router_state
, OSPF_AREA_IS_STUB_ROUTED
);
758 OSPF_AREA_TIMER_ON(area
->t_stub_router
, ospf_stub_router_timer
,
759 area
->ospf
->stub_router_startup_time
);
762 /* Create new router-LSA. */
763 static struct ospf_lsa
*ospf_router_lsa_new(struct ospf_area
*area
)
765 struct ospf
*ospf
= area
->ospf
;
767 struct lsa_header
*lsah
;
768 struct ospf_lsa
*new;
771 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
772 zlog_debug("LSA[Type1]: Create router-LSA instance");
774 /* check whether stub-router is desired, and if this is the first
777 ospf_stub_router_check(area
);
779 /* Create a stream for LSA. */
780 s
= stream_new(OSPF_MAX_LSA_SIZE
);
781 /* Set LSA common header fields. */
782 lsa_header_set(s
, LSA_OPTIONS_GET(area
) | LSA_OPTIONS_NSSA_GET(area
),
783 OSPF_ROUTER_LSA
, ospf
->router_id
, ospf
->router_id
);
785 /* Set router-LSA body fields. */
786 ospf_router_lsa_body_set(s
, area
);
789 length
= stream_get_endp(s
);
790 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
791 lsah
->length
= htons(length
);
793 /* Now, create OSPF LSA instance. */
794 new = ospf_lsa_new_and_data(length
);
797 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
798 new->vrf_id
= area
->ospf
->vrf_id
;
800 /* Copy LSA data to store, discard stream. */
801 memcpy(new->data
, lsah
, length
);
807 /* Originate Router-LSA. */
808 static struct ospf_lsa
*ospf_router_lsa_originate(struct ospf_area
*area
)
810 struct ospf_lsa
*new;
812 /* Create new router-LSA instance. */
813 if ((new = ospf_router_lsa_new(area
)) == NULL
) {
814 zlog_err("%s: ospf_router_lsa_new returned NULL", __func__
);
819 if (new->data
->adv_router
.s_addr
== 0) {
820 if (IS_DEBUG_OSPF_EVENT
)
821 zlog_debug("LSA[Type1]: AdvRouter is 0, discard");
822 ospf_lsa_discard(new);
826 /* Install LSA to LSDB. */
827 new = ospf_lsa_install(area
->ospf
, NULL
, new);
829 /* Update LSA origination count. */
830 area
->ospf
->lsa_originate_count
++;
832 /* Flooding new LSA through area. */
833 ospf_flood_through_area(area
, NULL
, new);
835 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
836 zlog_debug("LSA[Type%d:%s]: Originate router-LSA %p",
837 new->data
->type
, inet_ntoa(new->data
->id
),
839 ospf_lsa_header_dump(new->data
);
845 /* Refresh router-LSA. */
846 static struct ospf_lsa
*ospf_router_lsa_refresh(struct ospf_lsa
*lsa
)
848 struct ospf_area
*area
= lsa
->area
;
849 struct ospf_lsa
*new;
854 /* Delete LSA from neighbor retransmit-list. */
855 ospf_ls_retransmit_delete_nbr_area(area
, lsa
);
857 /* Unregister LSA from refresh-list */
858 ospf_refresher_unregister_lsa(area
->ospf
, lsa
);
860 /* Create new router-LSA instance. */
861 if ((new = ospf_router_lsa_new(area
)) == NULL
) {
862 zlog_err("%s: ospf_router_lsa_new returned NULL", __func__
);
866 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
868 ospf_lsa_install(area
->ospf
, NULL
, new);
870 /* Flood LSA through area. */
871 ospf_flood_through_area(area
, NULL
, new);
874 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
875 zlog_debug("LSA[Type%d:%s]: router-LSA refresh",
876 new->data
->type
, inet_ntoa(new->data
->id
));
877 ospf_lsa_header_dump(new->data
);
883 int ospf_router_lsa_update_area(struct ospf_area
*area
)
885 if (IS_DEBUG_OSPF_EVENT
)
886 zlog_debug("[router-LSA]: (router-LSA area update)");
888 /* Now refresh router-LSA. */
889 if (area
->router_lsa_self
)
890 ospf_lsa_refresh(area
->ospf
, area
->router_lsa_self
);
891 /* Newly originate router-LSA. */
893 ospf_router_lsa_originate(area
);
898 int ospf_router_lsa_update(struct ospf
*ospf
)
900 struct listnode
*node
, *nnode
;
901 struct ospf_area
*area
;
903 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
904 zlog_debug("Timer[router-LSA Update]: (timer expire)");
906 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
907 struct ospf_lsa
*lsa
= area
->router_lsa_self
;
908 struct router_lsa
*rl
;
909 const char *area_str
;
911 /* Keep Area ID string. */
912 area_str
= AREA_NAME(area
);
914 /* If LSA not exist in this Area, originate new. */
916 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
918 "LSA[Type1]: Create router-LSA for Area %s",
921 ospf_router_lsa_originate(area
);
923 /* If router-ID is changed, Link ID must change.
924 First flush old LSA, then originate new. */
925 else if (!IPV4_ADDR_SAME(&lsa
->data
->id
, &ospf
->router_id
)) {
926 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
928 "LSA[Type%d:%s]: Refresh router-LSA for Area %s",
930 inet_ntoa(lsa
->data
->id
), area_str
);
931 ospf_refresher_unregister_lsa(ospf
, lsa
);
932 ospf_lsa_flush_area(lsa
, area
);
933 ospf_lsa_unlock(&area
->router_lsa_self
);
934 area
->router_lsa_self
= NULL
;
936 /* Refresh router-LSA, (not install) and flood through
938 ospf_router_lsa_update_area(area
);
940 rl
= (struct router_lsa
*)lsa
->data
;
941 /* Refresh router-LSA, (not install) and flood through
943 if (rl
->flags
!= ospf
->flags
)
944 ospf_router_lsa_update_area(area
);
952 /* network-LSA related functions. */
953 /* Originate Network-LSA. */
954 static void ospf_network_lsa_body_set(struct stream
*s
,
955 struct ospf_interface
*oi
)
958 struct route_node
*rn
;
959 struct ospf_neighbor
*nbr
;
961 masklen2ip(oi
->address
->prefixlen
, &mask
);
962 stream_put_ipv4(s
, mask
.s_addr
);
964 /* The network-LSA lists those routers that are fully adjacent to
965 the Designated Router; each fully adjacent router is identified by
966 its OSPF Router ID. The Designated Router includes itself in this
967 list. RFC2328, Section 12.4.2 */
969 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
970 if ((nbr
= rn
->info
) != NULL
)
971 if (nbr
->state
== NSM_Full
|| nbr
== oi
->nbr_self
)
972 stream_put_ipv4(s
, nbr
->router_id
.s_addr
);
975 static struct ospf_lsa
*ospf_network_lsa_new(struct ospf_interface
*oi
)
978 struct ospf_lsa
*new;
979 struct lsa_header
*lsah
;
980 struct ospf_if_params
*oip
;
983 /* If there are no neighbours on this network (the net is stub),
984 the router does not originate network-LSA (see RFC 12.4.2) */
985 if (oi
->full_nbrs
== 0)
988 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
989 zlog_debug("LSA[Type2]: Create network-LSA instance");
991 /* Create new stream for LSA. */
992 s
= stream_new(OSPF_MAX_LSA_SIZE
);
993 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
995 lsa_header_set(s
, (OPTIONS(oi
) | LSA_OPTIONS_GET(oi
->area
)),
996 OSPF_NETWORK_LSA
, DR(oi
), oi
->ospf
->router_id
);
998 /* Set network-LSA body fields. */
999 ospf_network_lsa_body_set(s
, oi
);
1002 length
= stream_get_endp(s
);
1003 lsah
->length
= htons(length
);
1005 /* Create OSPF LSA instance. */
1006 new = ospf_lsa_new_and_data(length
);
1008 new->area
= oi
->area
;
1009 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
1010 new->vrf_id
= oi
->ospf
->vrf_id
;
1012 /* Copy LSA to store. */
1013 memcpy(new->data
, lsah
, length
);
1016 /* Remember prior network LSA sequence numbers, even if we stop
1017 * originating one for this oi, to try avoid re-originating LSAs with a
1018 * prior sequence number, and thus speed up adjency forming &
1021 if ((oip
= ospf_lookup_if_params(oi
->ifp
, oi
->address
->u
.prefix4
))) {
1022 new->data
->ls_seqnum
= oip
->network_lsa_seqnum
;
1023 new->data
->ls_seqnum
= lsa_seqnum_increment(new);
1025 oip
= ospf_get_if_params(oi
->ifp
, oi
->address
->u
.prefix4
);
1026 ospf_if_update_params(oi
->ifp
, oi
->address
->u
.prefix4
);
1028 oip
->network_lsa_seqnum
= new->data
->ls_seqnum
;
1033 /* Originate network-LSA. */
1034 void ospf_network_lsa_update(struct ospf_interface
*oi
)
1036 struct ospf_lsa
*new;
1038 if (oi
->network_lsa_self
!= NULL
) {
1039 ospf_lsa_refresh(oi
->ospf
, oi
->network_lsa_self
);
1043 /* Create new network-LSA instance. */
1044 new = ospf_network_lsa_new(oi
);
1048 /* Install LSA to LSDB. */
1049 new = ospf_lsa_install(oi
->ospf
, oi
, new);
1051 /* Update LSA origination count. */
1052 oi
->ospf
->lsa_originate_count
++;
1054 /* Flooding new LSA through area. */
1055 ospf_flood_through_area(oi
->area
, NULL
, new);
1057 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1058 zlog_debug("LSA[Type%d:%s]: Originate network-LSA %p",
1059 new->data
->type
, inet_ntoa(new->data
->id
),
1061 ospf_lsa_header_dump(new->data
);
1067 static struct ospf_lsa
*ospf_network_lsa_refresh(struct ospf_lsa
*lsa
)
1069 struct ospf_area
*area
= lsa
->area
;
1070 struct ospf_lsa
*new, *new2
;
1071 struct ospf_if_params
*oip
;
1072 struct ospf_interface
*oi
;
1076 /* Retrieve the oi for the network LSA */
1077 oi
= ospf_if_lookup_by_local_addr(area
->ospf
, NULL
, lsa
->data
->id
);
1079 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1081 "LSA[Type%d:%s]: network-LSA refresh: "
1082 "no oi found, ick, ignoring.",
1083 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
));
1084 ospf_lsa_header_dump(lsa
->data
);
1088 /* Delete LSA from neighbor retransmit-list. */
1089 ospf_ls_retransmit_delete_nbr_area(area
, lsa
);
1091 /* Unregister LSA from refresh-list */
1092 ospf_refresher_unregister_lsa(area
->ospf
, lsa
);
1094 /* Create new network-LSA instance. */
1095 new = ospf_network_lsa_new(oi
);
1099 oip
= ospf_lookup_if_params(oi
->ifp
, oi
->address
->u
.prefix4
);
1100 assert(oip
!= NULL
);
1101 oip
->network_lsa_seqnum
= new->data
->ls_seqnum
=
1102 lsa_seqnum_increment(lsa
);
1104 new2
= ospf_lsa_install(area
->ospf
, oi
, new);
1106 assert(new2
== new);
1108 /* Flood LSA through aera. */
1109 ospf_flood_through_area(area
, NULL
, new);
1111 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1112 zlog_debug("LSA[Type%d:%s]: network-LSA refresh",
1113 new->data
->type
, inet_ntoa(new->data
->id
));
1114 ospf_lsa_header_dump(new->data
);
1120 static void stream_put_ospf_metric(struct stream
*s
, uint32_t metric_value
)
1125 /* Put 0 metric. TOS metric is not supported. */
1126 metric
= htonl(metric_value
);
1127 mp
= (char *)&metric
;
1129 stream_put(s
, mp
, 3);
1132 /* summary-LSA related functions. */
1133 static void ospf_summary_lsa_body_set(struct stream
*s
, struct prefix
*p
,
1136 struct in_addr mask
;
1138 masklen2ip(p
->prefixlen
, &mask
);
1140 /* Put Network Mask. */
1141 stream_put_ipv4(s
, mask
.s_addr
);
1144 stream_putc(s
, (uint8_t)0);
1147 stream_put_ospf_metric(s
, metric
);
1150 static struct ospf_lsa
*ospf_summary_lsa_new(struct ospf_area
*area
,
1151 struct prefix
*p
, uint32_t metric
,
1155 struct ospf_lsa
*new;
1156 struct lsa_header
*lsah
;
1159 if (id
.s_addr
== 0xffffffff) {
1160 /* Maybe Link State ID not available. */
1161 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1163 "LSA[Type%d]: Link ID not available, can't originate",
1168 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1169 zlog_debug("LSA[Type3]: Create summary-LSA instance");
1171 /* Create new stream for LSA. */
1172 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1173 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1175 lsa_header_set(s
, LSA_OPTIONS_GET(area
), OSPF_SUMMARY_LSA
, id
,
1176 area
->ospf
->router_id
);
1178 /* Set summary-LSA body fields. */
1179 ospf_summary_lsa_body_set(s
, p
, metric
);
1182 length
= stream_get_endp(s
);
1183 lsah
->length
= htons(length
);
1185 /* Create OSPF LSA instance. */
1186 new = ospf_lsa_new_and_data(length
);
1188 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
1189 new->vrf_id
= area
->ospf
->vrf_id
;
1191 /* Copy LSA to store. */
1192 memcpy(new->data
, lsah
, length
);
1198 /* Originate Summary-LSA. */
1199 struct ospf_lsa
*ospf_summary_lsa_originate(struct prefix_ipv4
*p
,
1201 struct ospf_area
*area
)
1203 struct ospf_lsa
*new;
1206 id
= ospf_lsa_unique_id(area
->ospf
, area
->lsdb
, OSPF_SUMMARY_LSA
, p
);
1208 if (id
.s_addr
== 0xffffffff) {
1209 /* Maybe Link State ID not available. */
1210 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1212 "LSA[Type%d]: Link ID not available, can't originate",
1217 /* Create new summary-LSA instance. */
1218 if (!(new = ospf_summary_lsa_new(area
, (struct prefix
*)p
, metric
, id
)))
1221 /* Instlal LSA to LSDB. */
1222 new = ospf_lsa_install(area
->ospf
, NULL
, new);
1224 /* Update LSA origination count. */
1225 area
->ospf
->lsa_originate_count
++;
1227 /* Flooding new LSA through area. */
1228 ospf_flood_through_area(area
, NULL
, new);
1230 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1231 zlog_debug("LSA[Type%d:%s]: Originate summary-LSA %p",
1232 new->data
->type
, inet_ntoa(new->data
->id
),
1234 ospf_lsa_header_dump(new->data
);
1240 static struct ospf_lsa
*ospf_summary_lsa_refresh(struct ospf
*ospf
,
1241 struct ospf_lsa
*lsa
)
1243 struct ospf_lsa
*new;
1244 struct summary_lsa
*sl
;
1250 sl
= (struct summary_lsa
*)lsa
->data
;
1251 p
.prefixlen
= ip_masklen(sl
->mask
);
1252 new = ospf_summary_lsa_new(lsa
->area
, &p
, GET_METRIC(sl
->metric
),
1258 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
1260 ospf_lsa_install(ospf
, NULL
, new);
1262 /* Flood LSA through AS. */
1263 ospf_flood_through_area(new->area
, NULL
, new);
1265 /* Debug logging. */
1266 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1267 zlog_debug("LSA[Type%d:%s]: summary-LSA refresh",
1268 new->data
->type
, inet_ntoa(new->data
->id
));
1269 ospf_lsa_header_dump(new->data
);
1276 /* summary-ASBR-LSA related functions. */
1277 static void ospf_summary_asbr_lsa_body_set(struct stream
*s
, struct prefix
*p
,
1280 /* Put Network Mask. */
1281 stream_put_ipv4(s
, (uint32_t)0);
1284 stream_putc(s
, (uint8_t)0);
1287 stream_put_ospf_metric(s
, metric
);
1290 static struct ospf_lsa
*ospf_summary_asbr_lsa_new(struct ospf_area
*area
,
1296 struct ospf_lsa
*new;
1297 struct lsa_header
*lsah
;
1300 if (id
.s_addr
== 0xffffffff) {
1301 /* Maybe Link State ID not available. */
1302 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1304 "LSA[Type%d]: Link ID not available, can't originate",
1305 OSPF_ASBR_SUMMARY_LSA
);
1309 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1310 zlog_debug("LSA[Type3]: Create summary-LSA instance");
1312 /* Create new stream for LSA. */
1313 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1314 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1316 lsa_header_set(s
, LSA_OPTIONS_GET(area
), OSPF_ASBR_SUMMARY_LSA
, id
,
1317 area
->ospf
->router_id
);
1319 /* Set summary-LSA body fields. */
1320 ospf_summary_asbr_lsa_body_set(s
, p
, metric
);
1323 length
= stream_get_endp(s
);
1324 lsah
->length
= htons(length
);
1326 /* Create OSPF LSA instance. */
1327 new = ospf_lsa_new_and_data(length
);
1329 SET_FLAG(new->flags
, OSPF_LSA_SELF
| OSPF_LSA_SELF_CHECKED
);
1330 new->vrf_id
= area
->ospf
->vrf_id
;
1332 /* Copy LSA to store. */
1333 memcpy(new->data
, lsah
, length
);
1339 /* Originate summary-ASBR-LSA. */
1340 struct ospf_lsa
*ospf_summary_asbr_lsa_originate(struct prefix_ipv4
*p
,
1342 struct ospf_area
*area
)
1344 struct ospf_lsa
*new;
1347 id
= ospf_lsa_unique_id(area
->ospf
, area
->lsdb
, OSPF_ASBR_SUMMARY_LSA
,
1350 if (id
.s_addr
== 0xffffffff) {
1351 /* Maybe Link State ID not available. */
1352 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1354 "LSA[Type%d]: Link ID not available, can't originate",
1355 OSPF_ASBR_SUMMARY_LSA
);
1359 /* Create new summary-LSA instance. */
1360 new = ospf_summary_asbr_lsa_new(area
, (struct prefix
*)p
, metric
, id
);
1364 /* Install LSA to LSDB. */
1365 new = ospf_lsa_install(area
->ospf
, NULL
, new);
1367 /* Update LSA origination count. */
1368 area
->ospf
->lsa_originate_count
++;
1370 /* Flooding new LSA through area. */
1371 ospf_flood_through_area(area
, NULL
, new);
1373 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1374 zlog_debug("LSA[Type%d:%s]: Originate summary-ASBR-LSA %p",
1375 new->data
->type
, inet_ntoa(new->data
->id
),
1377 ospf_lsa_header_dump(new->data
);
1383 static struct ospf_lsa
*ospf_summary_asbr_lsa_refresh(struct ospf
*ospf
,
1384 struct ospf_lsa
*lsa
)
1386 struct ospf_lsa
*new;
1387 struct summary_lsa
*sl
;
1393 sl
= (struct summary_lsa
*)lsa
->data
;
1394 p
.prefixlen
= ip_masklen(sl
->mask
);
1395 new = ospf_summary_asbr_lsa_new(lsa
->area
, &p
, GET_METRIC(sl
->metric
),
1400 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
1402 ospf_lsa_install(ospf
, NULL
, new);
1404 /* Flood LSA through area. */
1405 ospf_flood_through_area(new->area
, NULL
, new);
1407 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1408 zlog_debug("LSA[Type%d:%s]: summary-ASBR-LSA refresh",
1409 new->data
->type
, inet_ntoa(new->data
->id
));
1410 ospf_lsa_header_dump(new->data
);
1416 /* AS-external-LSA related functions. */
1418 /* Get nexthop for AS-external-LSAs. Return nexthop if its interface
1419 is connected, else 0*/
1420 static struct in_addr
ospf_external_lsa_nexthop_get(struct ospf
*ospf
,
1421 struct in_addr nexthop
)
1425 struct listnode
*node
;
1426 struct ospf_interface
*oi
;
1430 if (!nexthop
.s_addr
)
1433 /* Check whether nexthop is covered by OSPF network. */
1434 nh
.family
= AF_INET
;
1435 nh
.u
.prefix4
= nexthop
;
1436 nh
.prefixlen
= IPV4_MAX_BITLEN
;
1438 /* XXX/SCALE: If there were a lot of oi's on an ifp, then it'd be
1439 * better to make use of the per-ifp table of ois.
1441 for (ALL_LIST_ELEMENTS_RO(ospf
->oiflist
, node
, oi
))
1442 if (if_is_operative(oi
->ifp
))
1443 if (oi
->address
->family
== AF_INET
)
1444 if (prefix_match(oi
->address
, &nh
))
1450 /* NSSA-external-LSA related functions. */
1452 /* Get 1st IP connection for Forward Addr */
1454 struct in_addr
ospf_get_ip_from_ifp(struct ospf_interface
*oi
)
1460 if (if_is_operative(oi
->ifp
))
1461 return oi
->address
->u
.prefix4
;
1466 /* Get 1st IP connection for Forward Addr */
1467 struct in_addr
ospf_get_nssa_ip(struct ospf_area
*area
)
1470 struct in_addr best_default
;
1471 struct listnode
*node
;
1472 struct ospf_interface
*oi
;
1475 best_default
.s_addr
= 0;
1477 for (ALL_LIST_ELEMENTS_RO(area
->ospf
->oiflist
, node
, oi
)) {
1478 if (if_is_operative(oi
->ifp
))
1479 if (oi
->area
->external_routing
== OSPF_AREA_NSSA
)
1481 && oi
->address
->family
== AF_INET
) {
1482 if (best_default
.s_addr
== 0)
1484 oi
->address
->u
.prefix4
;
1485 if (oi
->area
== area
)
1486 return oi
->address
->u
.prefix4
;
1489 if (best_default
.s_addr
!= 0)
1490 return best_default
;
1492 if (best_default
.s_addr
!= 0)
1493 return best_default
;
1498 #define DEFAULT_DEFAULT_METRIC 20
1499 #define DEFAULT_DEFAULT_ORIGINATE_METRIC 10
1500 #define DEFAULT_DEFAULT_ALWAYS_METRIC 1
1502 #define DEFAULT_METRIC_TYPE EXTERNAL_METRIC_TYPE_2
1504 int metric_type(struct ospf
*ospf
, uint8_t src
, unsigned short instance
)
1506 struct ospf_redist
*red
;
1508 red
= ospf_redist_lookup(ospf
, src
, instance
);
1510 return ((!red
|| red
->dmetric
.type
< 0) ? DEFAULT_METRIC_TYPE
1511 : red
->dmetric
.type
);
1514 int metric_value(struct ospf
*ospf
, uint8_t src
, unsigned short instance
)
1516 struct ospf_redist
*red
;
1518 red
= ospf_redist_lookup(ospf
, src
, instance
);
1519 if (!red
|| red
->dmetric
.value
< 0) {
1520 if (src
== DEFAULT_ROUTE
) {
1521 if (ospf
->default_originate
== DEFAULT_ORIGINATE_ZEBRA
)
1522 return DEFAULT_DEFAULT_ORIGINATE_METRIC
;
1524 return DEFAULT_DEFAULT_ALWAYS_METRIC
;
1525 } else if (ospf
->default_metric
< 0)
1526 return DEFAULT_DEFAULT_METRIC
;
1528 return ospf
->default_metric
;
1531 return red
->dmetric
.value
;
1534 /* Set AS-external-LSA body. */
1535 static void ospf_external_lsa_body_set(struct stream
*s
,
1536 struct external_info
*ei
,
1539 struct prefix_ipv4
*p
= &ei
->p
;
1540 struct in_addr mask
, fwd_addr
;
1544 unsigned short instance
;
1546 /* Put Network Mask. */
1547 masklen2ip(p
->prefixlen
, &mask
);
1548 stream_put_ipv4(s
, mask
.s_addr
);
1550 /* If prefix is default, specify DEFAULT_ROUTE. */
1551 type
= is_prefix_default(&ei
->p
) ? DEFAULT_ROUTE
: ei
->type
;
1552 instance
= is_prefix_default(&ei
->p
) ? 0 : ei
->instance
;
1554 mtype
= (ROUTEMAP_METRIC_TYPE(ei
) != -1)
1555 ? ROUTEMAP_METRIC_TYPE(ei
)
1556 : metric_type(ospf
, type
, instance
);
1558 mvalue
= (ROUTEMAP_METRIC(ei
) != -1)
1559 ? ROUTEMAP_METRIC(ei
)
1560 : metric_value(ospf
, type
, instance
);
1562 /* Put type of external metric. */
1563 stream_putc(s
, (mtype
== EXTERNAL_METRIC_TYPE_2
? 0x80 : 0));
1565 /* Put 0 metric. TOS metric is not supported. */
1566 stream_put_ospf_metric(s
, mvalue
);
1568 /* Get forwarding address to nexthop if on the Connection List, else 0.
1570 fwd_addr
= ospf_external_lsa_nexthop_get(ospf
, ei
->nexthop
);
1572 /* Put forwarding address. */
1573 stream_put_ipv4(s
, fwd_addr
.s_addr
);
1576 stream_putl(s
, ei
->tag
);
1579 /* Create new external-LSA. */
1580 static struct ospf_lsa
*ospf_external_lsa_new(struct ospf
*ospf
,
1581 struct external_info
*ei
,
1582 struct in_addr
*old_id
)
1585 struct lsa_header
*lsah
;
1586 struct ospf_lsa
*new;
1591 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1593 "LSA[Type5]: External info is NULL, can't originate");
1597 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1598 zlog_debug("LSA[Type5]: Originate AS-external-LSA instance");
1600 /* If old Link State ID is specified, refresh LSA with same ID. */
1603 /* Get Link State with unique ID. */
1605 id
= ospf_lsa_unique_id(ospf
, ospf
->lsdb
, OSPF_AS_EXTERNAL_LSA
,
1607 if (id
.s_addr
== 0xffffffff) {
1608 /* Maybe Link State ID not available. */
1609 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1611 "LSA[Type5]: Link ID not available, can't originate");
1616 /* Create new stream for LSA. */
1617 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1618 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1620 /* Set LSA common header fields. */
1621 lsa_header_set(s
, OSPF_OPTION_E
, OSPF_AS_EXTERNAL_LSA
, id
,
1624 /* Set AS-external-LSA body fields. */
1625 ospf_external_lsa_body_set(s
, ei
, ospf
);
1628 length
= stream_get_endp(s
);
1629 lsah
->length
= htons(length
);
1631 /* Now, create OSPF LSA instance. */
1632 new = ospf_lsa_new_and_data(length
);
1634 SET_FLAG(new->flags
,
1635 OSPF_LSA_SELF
| OSPF_LSA_APPROVED
| OSPF_LSA_SELF_CHECKED
);
1636 new->vrf_id
= ospf
->vrf_id
;
1638 /* Copy LSA data to store, discard stream. */
1639 memcpy(new->data
, lsah
, length
);
1646 static void ospf_install_flood_nssa(struct ospf
*ospf
, struct ospf_lsa
*lsa
,
1647 struct external_info
*ei
)
1649 struct ospf_lsa
*new;
1650 struct as_external_lsa
*extlsa
;
1651 struct ospf_area
*area
;
1652 struct listnode
*node
, *nnode
;
1654 /* LSA may be a Type-5 originated via translation of a Type-7 LSA
1655 * which originated from an NSSA area. In which case it should not be
1656 * flooded back to NSSA areas.
1658 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
))
1661 /* NSSA Originate or Refresh (If anyNSSA)
1663 LSA is self-originated. And just installed as Type-5.
1664 Additionally, install as Type-7 LSDB for every attached NSSA.
1666 P-Bit controls which ABR performs translation to outside world; If
1667 we are an ABR....do not set the P-bit, because we send the Type-5,
1668 not as the ABR Translator, but as the ASBR owner within the AS!
1670 If we are NOT ABR, Flood through NSSA as Type-7 w/P-bit set. The
1671 elected ABR Translator will see the P-bit, Translate, and re-flood.
1673 Later, ABR_TASK and P-bit will scan Type-7 LSDB and translate to
1674 Type-5's to non-NSSA Areas. (it will also attempt a re-install) */
1676 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
1677 /* Don't install Type-7 LSA's into nonNSSA area */
1678 if (area
->external_routing
!= OSPF_AREA_NSSA
)
1681 /* make lsa duplicate, lock=1 */
1682 new = ospf_lsa_dup(lsa
);
1684 new->data
->type
= OSPF_AS_NSSA_LSA
;
1686 /* set P-bit if not ABR */
1687 if (!IS_OSPF_ABR(ospf
)) {
1688 SET_FLAG(new->data
->options
, OSPF_OPTION_NP
);
1690 /* set non-zero FWD ADDR
1692 draft-ietf-ospf-nssa-update-09.txt
1694 if the network between the NSSA AS boundary router and
1696 adjacent AS is advertised into OSPF as an internal OSPF
1698 the forwarding address should be the next op address as
1700 currently done with type-5 LSAs. If the intervening
1702 not adversited into OSPF as an internal OSPF route and
1704 type-7 LSA's P-bit is set a forwarding address should be
1705 selected from one of the router's active OSPF interface
1707 which belong to the NSSA. If no such addresses exist,
1709 no type-7 LSA's with the P-bit set should originate from
1713 /* kevinm: not updating lsa anymore, just new */
1714 extlsa
= (struct as_external_lsa
*)(new->data
);
1716 if (extlsa
->e
[0].fwd_addr
.s_addr
== 0)
1717 extlsa
->e
[0].fwd_addr
= ospf_get_nssa_ip(
1718 area
); /* this NSSA area in ifp */
1720 if (extlsa
->e
[0].fwd_addr
.s_addr
== 0) {
1721 if (IS_DEBUG_OSPF_NSSA
)
1723 "LSA[Type-7]: Could not build FWD-ADDR");
1724 ospf_lsa_discard(new);
1729 /* install also as Type-7 */
1730 ospf_lsa_install(ospf
, NULL
,
1731 new); /* Remove Old, Lock New = 2 */
1733 /* will send each copy, lock=2+n */
1734 ospf_flood_through_as(
1735 ospf
, NULL
, new); /* all attached NSSA's, no AS/STUBs */
1739 static struct ospf_lsa
*ospf_lsa_translated_nssa_new(struct ospf
*ospf
,
1740 struct ospf_lsa
*type7
)
1743 struct ospf_lsa
*new;
1744 struct as_external_lsa
*ext
, *extnew
;
1745 struct external_info ei
;
1747 ext
= (struct as_external_lsa
*)(type7
->data
);
1749 /* need external_info struct, fill in bare minimum */
1750 ei
.p
.family
= AF_INET
;
1751 ei
.p
.prefix
= type7
->data
->id
;
1752 ei
.p
.prefixlen
= ip_masklen(ext
->mask
);
1753 ei
.type
= ZEBRA_ROUTE_OSPF
;
1754 ei
.nexthop
= ext
->header
.adv_router
;
1755 ei
.route_map_set
.metric
= -1;
1756 ei
.route_map_set
.metric_type
= -1;
1760 if ((new = ospf_external_lsa_new(ospf
, &ei
, &type7
->data
->id
))
1762 if (IS_DEBUG_OSPF_NSSA
)
1764 "ospf_nssa_translate_originate(): Could not originate "
1765 "Translated Type-5 for %s",
1766 inet_ntoa(ei
.p
.prefix
));
1770 extnew
= (struct as_external_lsa
*)(new->data
);
1772 /* copy over Type-7 data to new */
1773 extnew
->e
[0].tos
= ext
->e
[0].tos
;
1774 extnew
->e
[0].route_tag
= ext
->e
[0].route_tag
;
1775 extnew
->e
[0].fwd_addr
.s_addr
= ext
->e
[0].fwd_addr
.s_addr
;
1776 new->data
->ls_seqnum
= type7
->data
->ls_seqnum
;
1778 /* add translated flag, checksum and lock new lsa */
1779 SET_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
); /* Translated from 7 */
1780 new = ospf_lsa_lock(new);
1785 /* Originate Translated Type-5 for supplied Type-7 NSSA LSA */
1786 struct ospf_lsa
*ospf_translated_nssa_originate(struct ospf
*ospf
,
1787 struct ospf_lsa
*type7
)
1789 struct ospf_lsa
*new;
1790 struct as_external_lsa
*extnew
;
1792 /* we cant use ospf_external_lsa_originate() as we need to set
1793 * the OSPF_LSA_LOCAL_XLT flag, must originate by hand
1796 if ((new = ospf_lsa_translated_nssa_new(ospf
, type7
)) == NULL
) {
1797 if (IS_DEBUG_OSPF_NSSA
)
1799 "ospf_translated_nssa_originate(): Could not translate "
1800 "Type-7, Id %s, to Type-5",
1801 inet_ntoa(type7
->data
->id
));
1805 extnew
= (struct as_external_lsa
*)new;
1807 if (IS_DEBUG_OSPF_NSSA
) {
1809 "ospf_translated_nssa_originate(): "
1810 "translated Type 7, installed:");
1811 ospf_lsa_header_dump(new->data
);
1812 zlog_debug(" Network mask: %d", ip_masklen(extnew
->mask
));
1813 zlog_debug(" Forward addr: %s",
1814 inet_ntoa(extnew
->e
[0].fwd_addr
));
1817 if ((new = ospf_lsa_install(ospf
, NULL
, new)) == NULL
) {
1818 if (IS_DEBUG_OSPF_NSSA
)
1820 "ospf_lsa_translated_nssa_originate(): "
1821 "Could not install LSA "
1823 inet_ntoa(type7
->data
->id
));
1827 ospf
->lsa_originate_count
++;
1828 ospf_flood_through_as(ospf
, NULL
, new);
1833 /* Refresh Translated from NSSA AS-external-LSA. */
1834 struct ospf_lsa
*ospf_translated_nssa_refresh(struct ospf
*ospf
,
1835 struct ospf_lsa
*type7
,
1836 struct ospf_lsa
*type5
)
1838 struct ospf_lsa
*new = NULL
;
1840 /* Sanity checks. */
1841 assert(type7
|| type5
);
1842 if (!(type7
|| type5
))
1845 assert(type7
->data
);
1847 assert(type5
->data
);
1848 assert(ospf
->anyNSSA
);
1850 /* get required data according to what has been given */
1851 if (type7
&& type5
== NULL
) {
1852 /* find the translated Type-5 for this Type-7 */
1853 struct as_external_lsa
*ext
=
1854 (struct as_external_lsa
*)(type7
->data
);
1855 struct prefix_ipv4 p
= {
1856 .prefix
= type7
->data
->id
,
1857 .prefixlen
= ip_masklen(ext
->mask
),
1861 type5
= ospf_external_info_find_lsa(ospf
, &p
);
1862 } else if (type5
&& type7
== NULL
) {
1863 /* find the type-7 from which supplied type-5 was translated,
1864 * ie find first type-7 with same LSA Id.
1866 struct listnode
*ln
, *lnn
;
1867 struct route_node
*rn
;
1868 struct ospf_lsa
*lsa
;
1869 struct ospf_area
*area
;
1871 for (ALL_LIST_ELEMENTS(ospf
->areas
, ln
, lnn
, area
)) {
1872 if (area
->external_routing
!= OSPF_AREA_NSSA
&& !type7
)
1875 LSDB_LOOP (NSSA_LSDB(area
), rn
, lsa
) {
1876 if (lsa
->data
->id
.s_addr
1877 == type5
->data
->id
.s_addr
) {
1885 /* do we have type7? */
1887 if (IS_DEBUG_OSPF_NSSA
)
1889 "ospf_translated_nssa_refresh(): no Type-7 found for "
1891 type5
? inet_ntoa(type5
->data
->id
) : "(null)");
1895 /* do we have valid translated type5? */
1896 if (type5
== NULL
|| !CHECK_FLAG(type5
->flags
, OSPF_LSA_LOCAL_XLT
)) {
1897 if (IS_DEBUG_OSPF_NSSA
)
1899 "ospf_translated_nssa_refresh(): No translated Type-5 "
1900 "found for Type-7 with Id %s",
1901 type7
? inet_ntoa(type7
->data
->id
) : "(null)");
1905 /* Delete LSA from neighbor retransmit-list. */
1906 ospf_ls_retransmit_delete_nbr_as(ospf
, type5
);
1908 /* create new translated LSA */
1909 if ((new = ospf_lsa_translated_nssa_new(ospf
, type7
)) == NULL
) {
1910 if (IS_DEBUG_OSPF_NSSA
)
1912 "ospf_translated_nssa_refresh(): Could not translate "
1913 "Type-7 for %s to Type-5",
1914 type7
? inet_ntoa(type7
->data
->id
) : "(null)");
1918 if (!(new = ospf_lsa_install(ospf
, NULL
, new))) {
1919 if (IS_DEBUG_OSPF_NSSA
)
1921 "ospf_translated_nssa_refresh(): Could not install "
1922 "translated LSA, Id %s",
1923 inet_ntoa(type7
->data
->id
));
1927 /* Flood LSA through area. */
1928 ospf_flood_through_as(ospf
, NULL
, new);
1933 int is_prefix_default(struct prefix_ipv4
*p
)
1935 struct prefix_ipv4 q
;
1938 q
.prefix
.s_addr
= 0;
1941 return prefix_same((struct prefix
*)p
, (struct prefix
*)&q
);
1944 /* Originate an AS-external-LSA, install and flood. */
1945 struct ospf_lsa
*ospf_external_lsa_originate(struct ospf
*ospf
,
1946 struct external_info
*ei
)
1948 struct ospf_lsa
*new;
1950 /* Added for NSSA project....
1952 External LSAs are originated in ASBRs as usual, but for NSSA
1954 there is the global Type-5 LSDB and a Type-7 LSDB installed for
1955 every area. The Type-7's are flooded to every IR and every ABR; We
1956 install the Type-5 LSDB so that the normal "refresh" code operates
1957 as usual, and flag them as not used during ASE calculations. The
1958 Type-7 LSDB is used for calculations. Each Type-7 has a Forwarding
1959 Address of non-zero.
1961 If an ABR is the elected NSSA translator, following SPF and during
1962 the ABR task it will translate all the scanned Type-7's, with P-bit
1963 ON and not-self generated, and translate to Type-5's throughout the
1966 A difference in operation depends whether this ASBR is an ABR
1967 or not. If not an ABR, the P-bit is ON, to indicate that any
1968 elected NSSA-ABR can perform its translation.
1970 If an ABR, the P-bit is OFF; No ABR will perform translation and
1971 this ASBR will flood the Type-5 LSA as usual.
1973 For the case where this ASBR is not an ABR, the ASE calculations
1974 are based on the Type-5 LSDB; The Type-7 LSDB exists just to
1975 demonstrate to the user that there are LSA's that belong to any
1978 Finally, it just so happens that when the ABR is translating every
1979 Type-7 into Type-5, it installs it into the Type-5 LSDB as an
1980 approved Type-5 (translated from Type-7); at the end of translation
1981 if any Translated Type-5's remain unapproved, then they must be
1982 flushed from the AS.
1986 /* Check the AS-external-LSA should be originated. */
1987 if (!ospf_redistribute_check(ospf
, ei
, NULL
))
1990 /* Create new AS-external-LSA instance. */
1991 if ((new = ospf_external_lsa_new(ospf
, ei
, NULL
)) == NULL
) {
1992 if (IS_DEBUG_OSPF_EVENT
)
1994 "LSA[Type5:%s]: Could not originate AS-external-LSA",
1995 inet_ntoa(ei
->p
.prefix
));
1999 /* Install newly created LSA into Type-5 LSDB, lock = 1. */
2000 ospf_lsa_install(ospf
, NULL
, new);
2002 /* Update LSA origination count. */
2003 ospf
->lsa_originate_count
++;
2005 /* Flooding new LSA. only to AS (non-NSSA/STUB) */
2006 ospf_flood_through_as(ospf
, NULL
, new);
2008 /* If there is any attached NSSA, do special handling */
2009 if (ospf
->anyNSSA
&&
2010 /* stay away from translated LSAs! */
2011 !(CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
)))
2012 ospf_install_flood_nssa(
2013 ospf
, new, ei
); /* Install/Flood Type-7 to all NSSAs */
2015 /* Debug logging. */
2016 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
2017 zlog_debug("LSA[Type%d:%s]: Originate AS-external-LSA %p",
2018 new->data
->type
, inet_ntoa(new->data
->id
),
2020 ospf_lsa_header_dump(new->data
);
2026 /* Originate AS-external-LSA from external info with initial flag. */
2027 int ospf_external_lsa_originate_timer(struct thread
*thread
)
2029 struct ospf
*ospf
= THREAD_ARG(thread
);
2030 struct route_node
*rn
;
2031 struct external_info
*ei
;
2032 struct route_table
*rt
;
2033 int type
= THREAD_VAL(thread
);
2034 struct list
*ext_list
;
2035 struct listnode
*node
;
2036 struct ospf_external
*ext
;
2038 ospf
->t_external_lsa
= NULL
;
2040 ext_list
= ospf
->external
[type
];
2044 for (ALL_LIST_ELEMENTS_RO(ext_list
, node
, ext
))
2045 /* Originate As-external-LSA from all type of distribute source.
2047 if ((rt
= ext
->external_info
))
2048 for (rn
= route_top(rt
); rn
; rn
= route_next(rn
))
2049 if ((ei
= rn
->info
) != NULL
)
2050 if (!is_prefix_default(
2051 (struct prefix_ipv4
*)&ei
2053 if (!ospf_external_lsa_originate(
2056 "LSA: AS-external-LSA was not originated.");
2061 static struct external_info
*ospf_default_external_info(struct ospf
*ospf
)
2064 struct route_node
*rn
;
2065 struct prefix_ipv4 p
;
2068 p
.prefix
.s_addr
= 0;
2071 /* First, lookup redistributed default route. */
2072 for (type
= 0; type
<= ZEBRA_ROUTE_MAX
; type
++) {
2073 struct list
*ext_list
;
2074 struct listnode
*node
;
2075 struct ospf_external
*ext
;
2077 if (type
== ZEBRA_ROUTE_OSPF
)
2080 ext_list
= ospf
->external
[type
];
2084 for (ALL_LIST_ELEMENTS_RO(ext_list
, node
, ext
)) {
2085 rn
= route_node_lookup(ext
->external_info
,
2086 (struct prefix
*)&p
);
2088 route_unlock_node(rn
);
2090 if (ospf_redistribute_check(ospf
, rn
->info
,
2100 int ospf_default_originate_timer(struct thread
*thread
)
2102 struct prefix_ipv4 p
;
2103 struct in_addr nexthop
;
2104 struct external_info
*ei
;
2107 ospf
= THREAD_ARG(thread
);
2110 p
.prefix
.s_addr
= 0;
2113 if (ospf
->default_originate
== DEFAULT_ORIGINATE_ALWAYS
) {
2114 /* If there is no default route via redistribute,
2115 then originate AS-external-LSA with nexthop 0 (self). */
2117 ospf_external_info_add(ospf
, DEFAULT_ROUTE
, 0, p
, 0, nexthop
,
2121 if ((ei
= ospf_default_external_info(ospf
)))
2122 ospf_external_lsa_originate(ospf
, ei
);
2127 /* Flush any NSSA LSAs for given prefix */
2128 void ospf_nssa_lsa_flush(struct ospf
*ospf
, struct prefix_ipv4
*p
)
2130 struct listnode
*node
, *nnode
;
2131 struct ospf_lsa
*lsa
= NULL
;
2132 struct ospf_area
*area
;
2134 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
2135 if (area
->external_routing
== OSPF_AREA_NSSA
) {
2136 lsa
= ospf_lsa_lookup(ospf
, area
, OSPF_AS_NSSA_LSA
,
2137 p
->prefix
, ospf
->router_id
);
2139 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2141 "LSA: There is no such AS-NSSA-LSA %s/%d in LSDB",
2142 inet_ntoa(p
->prefix
),
2146 ospf_ls_retransmit_delete_nbr_area(area
, lsa
);
2147 if (!IS_LSA_MAXAGE(lsa
)) {
2148 ospf_refresher_unregister_lsa(ospf
, lsa
);
2149 ospf_lsa_flush_area(lsa
, area
);
2155 /* Flush an AS-external-LSA from LSDB and routing domain. */
2156 void ospf_external_lsa_flush(struct ospf
*ospf
, uint8_t type
,
2157 struct prefix_ipv4
*p
,
2158 ifindex_t ifindex
/*, struct in_addr nexthop */)
2160 struct ospf_lsa
*lsa
;
2162 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2163 zlog_debug("LSA: Flushing AS-external-LSA %s/%d",
2164 inet_ntoa(p
->prefix
), p
->prefixlen
);
2166 /* First lookup LSA from LSDB. */
2167 if (!(lsa
= ospf_external_info_find_lsa(ospf
, p
))) {
2168 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2170 "LSA: There is no such AS-external-LSA %s/%d in LSDB",
2171 inet_ntoa(p
->prefix
), p
->prefixlen
);
2175 /* If LSA is selforiginated, not a translated LSA, and there is
2176 * NSSA area, flush Type-7 LSA's at first.
2178 if (IS_LSA_SELF(lsa
) && (ospf
->anyNSSA
)
2179 && !(CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
)))
2180 ospf_nssa_lsa_flush(ospf
, p
);
2182 /* Sweep LSA from Link State Retransmit List. */
2183 ospf_ls_retransmit_delete_nbr_as(ospf
, lsa
);
2185 /* There must be no self-originated LSA in rtrs_external. */
2187 /* Remove External route from Zebra. */
2188 ospf_zebra_delete ((struct prefix_ipv4
*) p
, &nexthop
);
2191 if (!IS_LSA_MAXAGE(lsa
)) {
2192 /* Unregister LSA from Refresh queue. */
2193 ospf_refresher_unregister_lsa(ospf
, lsa
);
2195 /* Flush AS-external-LSA through AS. */
2196 ospf_lsa_flush_as(ospf
, lsa
);
2199 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2200 zlog_debug("ospf_external_lsa_flush(): stop");
2203 void ospf_external_lsa_refresh_default(struct ospf
*ospf
)
2205 struct prefix_ipv4 p
;
2206 struct external_info
*ei
;
2207 struct ospf_lsa
*lsa
;
2211 p
.prefix
.s_addr
= 0;
2213 ei
= ospf_default_external_info(ospf
);
2214 lsa
= ospf_external_info_find_lsa(ospf
, &p
);
2218 if (IS_DEBUG_OSPF_EVENT
)
2220 "LSA[Type5:0.0.0.0]: Refresh AS-external-LSA %p",
2222 ospf_external_lsa_refresh(ospf
, lsa
, ei
,
2225 if (IS_DEBUG_OSPF_EVENT
)
2227 "LSA[Type5:0.0.0.0]: Originate AS-external-LSA");
2228 ospf_external_lsa_originate(ospf
, ei
);
2232 if (IS_DEBUG_OSPF_EVENT
)
2234 "LSA[Type5:0.0.0.0]: Flush AS-external-LSA");
2235 ospf_refresher_unregister_lsa(ospf
, lsa
);
2236 ospf_lsa_flush_as(ospf
, lsa
);
2241 void ospf_external_lsa_refresh_type(struct ospf
*ospf
, uint8_t type
,
2242 unsigned short instance
, int force
)
2244 struct route_node
*rn
;
2245 struct external_info
*ei
;
2246 struct ospf_external
*ext
;
2248 if (type
== DEFAULT_ROUTE
)
2251 ext
= ospf_external_lookup(ospf
, type
, instance
);
2253 if (ext
&& EXTERNAL_INFO(ext
)) {
2254 /* Refresh each redistributed AS-external-LSAs. */
2255 for (rn
= route_top(EXTERNAL_INFO(ext
)); rn
;
2256 rn
= route_next(rn
)) {
2259 if (!is_prefix_default(&ei
->p
)) {
2260 struct ospf_lsa
*lsa
;
2262 lsa
= ospf_external_info_find_lsa(
2265 ospf_external_lsa_refresh(
2266 ospf
, lsa
, ei
, force
);
2268 ospf_external_lsa_originate(
2276 /* Refresh AS-external-LSA. */
2277 struct ospf_lsa
*ospf_external_lsa_refresh(struct ospf
*ospf
,
2278 struct ospf_lsa
*lsa
,
2279 struct external_info
*ei
, int force
)
2281 struct ospf_lsa
*new;
2284 /* Check the AS-external-LSA should be originated. */
2285 if (!ospf_redistribute_check(ospf
, ei
, &changed
)) {
2286 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2288 "LSA[Type%d:%s]: Could not be refreshed, "
2289 "redist check fail",
2290 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
));
2291 ospf_external_lsa_flush(ospf
, ei
->type
, &ei
->p
,
2292 ei
->ifindex
/*, ei->nexthop */);
2296 if (!changed
&& !force
) {
2297 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2299 "LSA[Type%d:%s]: Not refreshed, not changed/forced",
2300 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
));
2304 /* Delete LSA from neighbor retransmit-list. */
2305 ospf_ls_retransmit_delete_nbr_as(ospf
, lsa
);
2307 /* Unregister AS-external-LSA from refresh-list. */
2308 ospf_refresher_unregister_lsa(ospf
, lsa
);
2310 new = ospf_external_lsa_new(ospf
, ei
, &lsa
->data
->id
);
2313 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
2314 zlog_debug("LSA[Type%d:%s]: Could not be refreshed",
2315 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
));
2319 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
2321 ospf_lsa_install(ospf
, NULL
, new); /* As type-5. */
2323 /* Flood LSA through AS. */
2324 ospf_flood_through_as(ospf
, NULL
, new);
2326 /* If any attached NSSA, install as Type-7, flood to all NSSA Areas */
2327 if (ospf
->anyNSSA
&& !(CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
)))
2328 ospf_install_flood_nssa(ospf
, new,
2329 ei
); /* Install/Flood per new rules */
2331 /* Register self-originated LSA to refresh queue.
2332 * Translated LSAs should not be registered, but refreshed upon
2333 * refresh of the Type-7
2335 if (!CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
))
2336 ospf_refresher_register_lsa(ospf
, new);
2338 /* Debug logging. */
2339 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
2340 zlog_debug("LSA[Type%d:%s]: AS-external-LSA refresh",
2341 new->data
->type
, inet_ntoa(new->data
->id
));
2342 ospf_lsa_header_dump(new->data
);
2349 /* LSA installation functions. */
2351 /* Install router-LSA to an area. */
2352 static struct ospf_lsa
*
2353 ospf_router_lsa_install(struct ospf
*ospf
, struct ospf_lsa
*new, int rt_recalc
)
2355 struct ospf_area
*area
= new->area
;
2357 /* RFC 2328 Section 13.2 Router-LSAs and network-LSAs
2358 The entire routing table must be recalculated, starting with
2359 the shortest path calculations for each area (not just the
2360 area whose link-state database has changed).
2363 if (IS_LSA_SELF(new)) {
2365 /* Only install LSA if it is originated/refreshed by us.
2366 * If LSA was received by flooding, the RECEIVED flag is set so
2368 * not link the LSA */
2369 if (CHECK_FLAG(new->flags
, OSPF_LSA_RECEIVED
))
2370 return new; /* ignore stale LSA */
2372 /* Set self-originated router-LSA. */
2373 ospf_lsa_unlock(&area
->router_lsa_self
);
2374 area
->router_lsa_self
= ospf_lsa_lock(new);
2376 ospf_refresher_register_lsa(ospf
, new);
2379 ospf_spf_calculate_schedule(ospf
, SPF_FLAG_ROUTER_LSA_INSTALL
);
2383 #define OSPF_INTERFACE_TIMER_ON(T, F, V) \
2385 (T) = thread_add_timer(master, (F), oi, (V))
2387 /* Install network-LSA to an area. */
2388 static struct ospf_lsa
*ospf_network_lsa_install(struct ospf
*ospf
,
2389 struct ospf_interface
*oi
,
2390 struct ospf_lsa
*new,
2394 /* RFC 2328 Section 13.2 Router-LSAs and network-LSAs
2395 The entire routing table must be recalculated, starting with
2396 the shortest path calculations for each area (not just the
2397 area whose link-state database has changed).
2399 if (IS_LSA_SELF(new)) {
2400 /* We supposed that when LSA is originated by us, we pass the
2402 for which it was originated. If LSA was received by flooding,
2403 the RECEIVED flag is set, so we do not link the LSA to the
2405 if (CHECK_FLAG(new->flags
, OSPF_LSA_RECEIVED
))
2406 return new; /* ignore stale LSA */
2408 ospf_lsa_unlock(&oi
->network_lsa_self
);
2409 oi
->network_lsa_self
= ospf_lsa_lock(new);
2410 ospf_refresher_register_lsa(ospf
, new);
2413 ospf_spf_calculate_schedule(ospf
, SPF_FLAG_NETWORK_LSA_INSTALL
);
2418 /* Install summary-LSA to an area. */
2419 static struct ospf_lsa
*
2420 ospf_summary_lsa_install(struct ospf
*ospf
, struct ospf_lsa
*new, int rt_recalc
)
2422 if (rt_recalc
&& !IS_LSA_SELF(new)) {
2423 /* RFC 2328 Section 13.2 Summary-LSAs
2424 The best route to the destination described by the summary-
2425 LSA must be recalculated (see Section 16.5). If this
2426 destination is an AS boundary router, it may also be
2427 necessary to re-examine all the AS-external-LSAs.
2431 /* This doesn't exist yet... */
2432 ospf_summary_incremental_update(new); */
2434 ospf_spf_calculate_schedule(ospf
, SPF_FLAG_SUMMARY_LSA_INSTALL
);
2438 if (IS_LSA_SELF(new))
2439 ospf_refresher_register_lsa(ospf
, new);
2444 /* Install ASBR-summary-LSA to an area. */
2445 static struct ospf_lsa
*ospf_summary_asbr_lsa_install(struct ospf
*ospf
,
2446 struct ospf_lsa
*new,
2449 if (rt_recalc
&& !IS_LSA_SELF(new)) {
2450 /* RFC 2328 Section 13.2 Summary-LSAs
2451 The best route to the destination described by the summary-
2452 LSA must be recalculated (see Section 16.5). If this
2453 destination is an AS boundary router, it may also be
2454 necessary to re-examine all the AS-external-LSAs.
2457 /* These don't exist yet... */
2458 ospf_summary_incremental_update(new);
2459 /* Isn't this done by the above call?
2460 - RFC 2328 Section 16.5 implies it should be */
2461 /* ospf_ase_calculate_schedule(); */
2463 ospf_spf_calculate_schedule(ospf
,
2464 SPF_FLAG_ASBR_SUMMARY_LSA_INSTALL
);
2468 /* register LSA to refresh-list. */
2469 if (IS_LSA_SELF(new))
2470 ospf_refresher_register_lsa(ospf
, new);
2475 /* Install AS-external-LSA. */
2476 static struct ospf_lsa
*ospf_external_lsa_install(struct ospf
*ospf
,
2477 struct ospf_lsa
*new,
2480 ospf_ase_register_external_lsa(new, ospf
);
2481 /* If LSA is not self-originated, calculate an external route. */
2483 /* RFC 2328 Section 13.2 AS-external-LSAs
2484 The best route to the destination described by the AS-
2485 external-LSA must be recalculated (see Section 16.6).
2488 if (!IS_LSA_SELF(new))
2489 ospf_ase_incremental_update(ospf
, new);
2492 if (new->data
->type
== OSPF_AS_NSSA_LSA
) {
2493 /* There is no point to register selforiginate Type-7 LSA for
2494 * refreshing. We rely on refreshing Type-5 LSA's
2496 if (IS_LSA_SELF(new))
2499 /* Try refresh type-5 translated LSA for this LSA, if
2501 * New translations will be taken care of by the
2504 ospf_translated_nssa_refresh(ospf
, new, NULL
);
2505 ospf_schedule_abr_task(ospf
);
2509 /* Register self-originated LSA to refresh queue.
2510 * Leave Translated LSAs alone if NSSA is enabled
2512 if (IS_LSA_SELF(new) && !CHECK_FLAG(new->flags
, OSPF_LSA_LOCAL_XLT
))
2513 ospf_refresher_register_lsa(ospf
, new);
2518 void ospf_discard_from_db(struct ospf
*ospf
, struct ospf_lsdb
*lsdb
,
2519 struct ospf_lsa
*lsa
)
2521 struct ospf_lsa
*old
;
2524 zlog_warn("%s: Called with NULL lsdb!", __func__
);
2526 zlog_warn("%s: and NULL LSA!", __func__
);
2528 zlog_warn("LSA[Type%d:%s]: not associated with LSDB!",
2529 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
));
2533 old
= ospf_lsdb_lookup(lsdb
, lsa
);
2538 if (old
->refresh_list
>= 0)
2539 ospf_refresher_unregister_lsa(ospf
, old
);
2541 switch (old
->data
->type
) {
2542 case OSPF_AS_EXTERNAL_LSA
:
2543 ospf_ase_unregister_external_lsa(old
, ospf
);
2544 ospf_ls_retransmit_delete_nbr_as(ospf
, old
);
2546 case OSPF_OPAQUE_AS_LSA
:
2547 ospf_ls_retransmit_delete_nbr_as(ospf
, old
);
2549 case OSPF_AS_NSSA_LSA
:
2550 ospf_ls_retransmit_delete_nbr_area(old
->area
, old
);
2551 ospf_ase_unregister_external_lsa(old
, ospf
);
2554 ospf_ls_retransmit_delete_nbr_area(old
->area
, old
);
2558 ospf_lsa_maxage_delete(ospf
, old
);
2559 ospf_lsa_discard(old
);
2562 struct ospf_lsa
*ospf_lsa_install(struct ospf
*ospf
, struct ospf_interface
*oi
,
2563 struct ospf_lsa
*lsa
)
2565 struct ospf_lsa
*new = NULL
;
2566 struct ospf_lsa
*old
= NULL
;
2567 struct ospf_lsdb
*lsdb
= NULL
;
2571 switch (lsa
->data
->type
) {
2573 case OSPF_AS_NSSA_LSA
:
2575 lsdb
= lsa
->area
->lsdb
;
2579 case OSPF_AS_EXTERNAL_LSA
:
2580 case OSPF_OPAQUE_AS_LSA
:
2585 lsdb
= lsa
->area
->lsdb
;
2591 /* RFC 2328 13.2. Installing LSAs in the database
2593 Installing a new LSA in the database, either as the result of
2594 flooding or a newly self-originated LSA, may cause the OSPF
2595 routing table structure to be recalculated. The contents of the
2596 new LSA should be compared to the old instance, if present. If
2597 there is no difference, there is no need to recalculate the
2598 routing table. When comparing an LSA to its previous instance,
2599 the following are all considered to be differences in contents:
2601 o The LSA's Options field has changed.
2603 o One of the LSA instances has LS age set to MaxAge, and
2606 o The length field in the LSA header has changed.
2608 o The body of the LSA (i.e., anything outside the 20-byte
2609 LSA header) has changed. Note that this excludes changes
2610 in LS Sequence Number and LS Checksum.
2613 /* Look up old LSA and determine if any SPF calculation or incremental
2615 old
= ospf_lsdb_lookup(lsdb
, lsa
);
2617 /* Do comparision and record if recalc needed. */
2619 if (old
== NULL
|| ospf_lsa_different(old
, lsa
))
2623 Sequence number check (Section 14.1 of rfc 2328)
2624 "Premature aging is used when it is time for a self-originated
2625 LSA's sequence number field to wrap. At this point, the current
2626 LSA instance (having LS sequence number MaxSequenceNumber) must
2627 be prematurely aged and flushed from the routing domain before a
2628 new instance with sequence number equal to InitialSequenceNumber
2629 can be originated. "
2632 if (ntohl(lsa
->data
->ls_seqnum
) - 1 == OSPF_MAX_SEQUENCE_NUMBER
) {
2633 if (ospf_lsa_is_self_originated(ospf
, lsa
)) {
2634 lsa
->data
->ls_seqnum
= htonl(OSPF_MAX_SEQUENCE_NUMBER
);
2636 if (!IS_LSA_MAXAGE(lsa
))
2637 lsa
->flags
|= OSPF_LSA_PREMATURE_AGE
;
2638 lsa
->data
->ls_age
= htons(OSPF_LSA_MAXAGE
);
2640 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
)) {
2642 "ospf_lsa_install() Premature Aging "
2643 "lsa 0x%p, seqnum 0x%x",
2645 ntohl(lsa
->data
->ls_seqnum
));
2646 ospf_lsa_header_dump(lsa
->data
);
2649 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
2651 "ospf_lsa_install() got an lsa with seq 0x80000000 "
2652 "that was not self originated. Ignoring\n");
2653 ospf_lsa_header_dump(lsa
->data
);
2659 /* discard old LSA from LSDB */
2661 ospf_discard_from_db(ospf
, lsdb
, lsa
);
2663 /* Calculate Checksum if self-originated?. */
2664 if (IS_LSA_SELF(lsa
))
2665 ospf_lsa_checksum(lsa
->data
);
2667 /* Insert LSA to LSDB. */
2668 ospf_lsdb_add(lsdb
, lsa
);
2671 /* Do LSA specific installation process. */
2672 switch (lsa
->data
->type
) {
2673 case OSPF_ROUTER_LSA
:
2674 new = ospf_router_lsa_install(ospf
, lsa
, rt_recalc
);
2676 case OSPF_NETWORK_LSA
:
2678 new = ospf_network_lsa_install(ospf
, oi
, lsa
, rt_recalc
);
2680 case OSPF_SUMMARY_LSA
:
2681 new = ospf_summary_lsa_install(ospf
, lsa
, rt_recalc
);
2683 case OSPF_ASBR_SUMMARY_LSA
:
2684 new = ospf_summary_asbr_lsa_install(ospf
, lsa
, rt_recalc
);
2686 case OSPF_AS_EXTERNAL_LSA
:
2687 new = ospf_external_lsa_install(ospf
, lsa
, rt_recalc
);
2689 case OSPF_OPAQUE_LINK_LSA
:
2690 if (IS_LSA_SELF(lsa
))
2691 lsa
->oi
= oi
; /* Specify outgoing ospf-interface for
2694 /* Incoming "oi" for this LSA has set at LSUpd
2698 case OSPF_OPAQUE_AREA_LSA
:
2699 case OSPF_OPAQUE_AS_LSA
:
2700 new = ospf_opaque_lsa_install(lsa
, rt_recalc
);
2702 case OSPF_AS_NSSA_LSA
:
2703 new = ospf_external_lsa_install(ospf
, lsa
, rt_recalc
);
2704 default: /* type-6,8,9....nothing special */
2709 return new; /* Installation failed, cannot proceed further --
2713 if (IS_DEBUG_OSPF(lsa
, LSA_INSTALL
)) {
2714 char area_str
[INET_ADDRSTRLEN
];
2716 switch (lsa
->data
->type
) {
2717 case OSPF_AS_EXTERNAL_LSA
:
2718 case OSPF_OPAQUE_AS_LSA
:
2719 case OSPF_AS_NSSA_LSA
:
2720 zlog_debug("LSA[%s]: Install %s", dump_lsa_key(new),
2721 lookup_msg(ospf_lsa_type_msg
,
2722 new->data
->type
, NULL
));
2725 strlcpy(area_str
, inet_ntoa(new->area
->area_id
),
2727 zlog_debug("LSA[%s]: Install %s to Area %s",
2729 lookup_msg(ospf_lsa_type_msg
,
2730 new->data
->type
, NULL
),
2737 If received LSA' ls_age is MaxAge, or lsa is being prematurely aged
2738 (it's getting flushed out of the area), set LSA on MaxAge LSA list.
2740 if (IS_LSA_MAXAGE(new)) {
2741 if (IS_DEBUG_OSPF(lsa
, LSA_INSTALL
))
2742 zlog_debug("LSA[Type%d:%s]: Install LSA 0x%p, MaxAge",
2743 new->data
->type
, inet_ntoa(new->data
->id
),
2745 ospf_lsa_maxage(ospf
, lsa
);
2752 int ospf_check_nbr_status(struct ospf
*ospf
)
2754 struct listnode
*node
, *nnode
;
2755 struct ospf_interface
*oi
;
2757 for (ALL_LIST_ELEMENTS(ospf
->oiflist
, node
, nnode
, oi
)) {
2758 struct route_node
*rn
;
2759 struct ospf_neighbor
*nbr
;
2761 if (ospf_if_is_enable(oi
))
2762 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
2763 if ((nbr
= rn
->info
) != NULL
)
2764 if (nbr
->state
== NSM_Exchange
2765 || nbr
->state
== NSM_Loading
) {
2766 route_unlock_node(rn
);
2775 static int ospf_maxage_lsa_remover(struct thread
*thread
)
2777 struct ospf
*ospf
= THREAD_ARG(thread
);
2778 struct ospf_lsa
*lsa
;
2779 struct route_node
*rn
;
2782 ospf
->t_maxage
= NULL
;
2784 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2785 zlog_debug("LSA[MaxAge]: remover Start");
2787 reschedule
= !ospf_check_nbr_status(ospf
);
2790 for (rn
= route_top(ospf
->maxage_lsa
); rn
;
2791 rn
= route_next(rn
)) {
2792 if ((lsa
= rn
->info
) == NULL
) {
2796 /* There is at least one neighbor from which we still
2798 * for that LSA, so we are not allowed to remove it from
2800 * as per RFC 2328 section 14 para 4 a) */
2801 if (lsa
->retransmit_counter
> 0) {
2806 /* TODO: maybe convert this function to a work-queue */
2807 if (thread_should_yield(thread
)) {
2808 OSPF_TIMER_ON(ospf
->t_maxage
,
2809 ospf_maxage_lsa_remover
, 0);
2811 rn
); /* route_top/route_next */
2815 /* Remove LSA from the LSDB */
2816 if (IS_LSA_SELF(lsa
))
2817 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2819 "LSA[Type%d:%s]: LSA 0x%lx is self-originated: ",
2821 inet_ntoa(lsa
->data
->id
),
2822 (unsigned long)lsa
);
2824 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2826 "LSA[Type%d:%s]: MaxAge LSA removed from list",
2828 inet_ntoa(lsa
->data
->id
));
2830 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_PREMATURE_AGE
)) {
2831 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2833 "originating new lsa for lsa 0x%p\n",
2835 ospf_lsa_refresh(ospf
, lsa
);
2838 /* Remove from lsdb. */
2840 ospf_discard_from_db(ospf
, lsa
->lsdb
, lsa
);
2841 ospf_lsdb_delete(lsa
->lsdb
, lsa
);
2844 "%s: LSA[Type%d:%s]: No associated LSDB!",
2845 __func__
, lsa
->data
->type
,
2846 inet_ntoa(lsa
->data
->id
));
2849 /* A MaxAge LSA must be removed immediately from the router's link
2850 state database as soon as both a) it is no longer contained on any
2851 neighbor Link state retransmission lists and b) none of the
2853 neighbors are in states Exchange or Loading. */
2855 OSPF_TIMER_ON(ospf
->t_maxage
, ospf_maxage_lsa_remover
,
2856 ospf
->maxage_delay
);
2861 void ospf_lsa_maxage_delete(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
2863 struct route_node
*rn
;
2864 struct prefix lsa_prefix
;
2866 memset(&lsa_prefix
, 0, sizeof(struct prefix
));
2867 lsa_prefix
.family
= 0;
2868 lsa_prefix
.prefixlen
= sizeof(lsa_prefix
.u
.ptr
) * CHAR_BIT
;
2869 lsa_prefix
.u
.ptr
= (uintptr_t)lsa
;
2871 if ((rn
= route_node_lookup(ospf
->maxage_lsa
,
2872 (struct prefix
*)&lsa_prefix
))) {
2873 if (rn
->info
== lsa
) {
2874 UNSET_FLAG(lsa
->flags
, OSPF_LSA_IN_MAXAGE
);
2875 ospf_lsa_unlock(&lsa
); /* maxage_lsa */
2878 rn
); /* unlock node because lsa is deleted */
2880 route_unlock_node(rn
); /* route_node_lookup */
2882 if (IS_DEBUG_OSPF_EVENT
)
2883 zlog_debug("%s: lsa %s is not found in maxage db.",
2884 __PRETTY_FUNCTION__
, dump_lsa_key(lsa
));
2888 /* Add LSA onto the MaxAge list, and schedule for removal.
2889 * This does *not* lead to the LSA being flooded, that must be taken
2890 * care of elsewhere, see, e.g., ospf_lsa_flush* (which are callers of this
2893 void ospf_lsa_maxage(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
2895 struct prefix lsa_prefix
;
2896 struct route_node
*rn
;
2898 /* When we saw a MaxAge LSA flooded to us, we put it on the list
2899 and schedule the MaxAge LSA remover. */
2900 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_IN_MAXAGE
)) {
2901 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2903 "LSA[Type%d:%s]: %p already exists on MaxAge LSA list",
2904 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
),
2909 memset(&lsa_prefix
, 0, sizeof(struct prefix
));
2910 lsa_prefix
.family
= 0;
2911 lsa_prefix
.prefixlen
= sizeof(lsa_prefix
.u
.ptr
) * CHAR_BIT
;
2912 lsa_prefix
.u
.ptr
= (uintptr_t)lsa
;
2914 rn
= route_node_get(ospf
->maxage_lsa
, (struct prefix
*)&lsa_prefix
);
2915 if (rn
->info
!= NULL
) {
2916 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2918 "LSA[%s]: found LSA (%p) in table for LSA %p %d",
2919 dump_lsa_key(lsa
), rn
->info
,
2920 (void *)lsa
, lsa_prefix
.prefixlen
);
2921 route_unlock_node(rn
);
2923 rn
->info
= ospf_lsa_lock(lsa
);
2924 SET_FLAG(lsa
->flags
, OSPF_LSA_IN_MAXAGE
);
2927 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2928 zlog_debug("LSA[%s]: MaxAge LSA remover scheduled.",
2931 OSPF_TIMER_ON(ospf
->t_maxage
, ospf_maxage_lsa_remover
,
2932 ospf
->maxage_delay
);
2935 static int ospf_lsa_maxage_walker_remover(struct ospf
*ospf
,
2936 struct ospf_lsa
*lsa
)
2938 /* Stay away from any Local Translated Type-7 LSAs */
2939 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
))
2942 if (IS_LSA_MAXAGE(lsa
))
2943 /* Self-originated LSAs should NOT time-out instead,
2944 they're flushed and submitted to the max_age list explicitly.
2946 if (!ospf_lsa_is_self_originated(ospf
, lsa
)) {
2947 if (IS_DEBUG_OSPF(lsa
, LSA_FLOODING
))
2948 zlog_debug("LSA[%s]: is MaxAge",
2951 switch (lsa
->data
->type
) {
2952 case OSPF_OPAQUE_LINK_LSA
:
2953 case OSPF_OPAQUE_AREA_LSA
:
2954 case OSPF_OPAQUE_AS_LSA
:
2956 * As a general rule, whenever network topology
2958 * (due to an LSA removal in this case), routing
2960 * should be triggered. However, this is not
2962 * LSAs. Even if an opaque LSA instance is going
2964 * from the routing domain, it does not mean a
2966 * topology, and thus, routing recalculation is
2970 case OSPF_AS_EXTERNAL_LSA
:
2971 case OSPF_AS_NSSA_LSA
:
2972 ospf_ase_incremental_update(ospf
, lsa
);
2975 ospf_spf_calculate_schedule(ospf
,
2979 ospf_lsa_maxage(ospf
, lsa
);
2982 if (IS_LSA_MAXAGE(lsa
) && !ospf_lsa_is_self_originated(ospf
, lsa
))
2983 if (LS_AGE(lsa
) > OSPF_LSA_MAXAGE
+ 30)
2984 printf("Eek! Shouldn't happen!\n");
2989 /* Periodical check of MaxAge LSA. */
2990 int ospf_lsa_maxage_walker(struct thread
*thread
)
2992 struct ospf
*ospf
= THREAD_ARG(thread
);
2993 struct route_node
*rn
;
2994 struct ospf_lsa
*lsa
;
2995 struct ospf_area
*area
;
2996 struct listnode
*node
, *nnode
;
2998 ospf
->t_maxage_walker
= NULL
;
3000 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
3001 LSDB_LOOP (ROUTER_LSDB(area
), rn
, lsa
)
3002 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3003 LSDB_LOOP (NETWORK_LSDB(area
), rn
, lsa
)
3004 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3005 LSDB_LOOP (SUMMARY_LSDB(area
), rn
, lsa
)
3006 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3007 LSDB_LOOP (ASBR_SUMMARY_LSDB(area
), rn
, lsa
)
3008 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3009 LSDB_LOOP (OPAQUE_AREA_LSDB(area
), rn
, lsa
)
3010 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3011 LSDB_LOOP (OPAQUE_LINK_LSDB(area
), rn
, lsa
)
3012 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3013 LSDB_LOOP (NSSA_LSDB(area
), rn
, lsa
)
3014 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3017 /* for AS-external-LSAs. */
3019 LSDB_LOOP (EXTERNAL_LSDB(ospf
), rn
, lsa
)
3020 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3021 LSDB_LOOP (OPAQUE_AS_LSDB(ospf
), rn
, lsa
)
3022 ospf_lsa_maxage_walker_remover(ospf
, lsa
);
3025 OSPF_TIMER_ON(ospf
->t_maxage_walker
, ospf_lsa_maxage_walker
,
3026 OSPF_LSA_MAXAGE_CHECK_INTERVAL
);
3030 struct ospf_lsa
*ospf_lsa_lookup_by_prefix(struct ospf_lsdb
*lsdb
, uint8_t type
,
3031 struct prefix_ipv4
*p
,
3032 struct in_addr router_id
)
3034 struct ospf_lsa
*lsa
;
3035 struct in_addr mask
, id
;
3036 struct lsa_header_mask
{
3037 struct lsa_header header
;
3038 struct in_addr mask
;
3041 lsa
= ospf_lsdb_lookup_by_id(lsdb
, type
, p
->prefix
, router_id
);
3045 masklen2ip(p
->prefixlen
, &mask
);
3047 hmask
= (struct lsa_header_mask
*)lsa
->data
;
3049 if (mask
.s_addr
!= hmask
->mask
.s_addr
) {
3050 id
.s_addr
= p
->prefix
.s_addr
| (~mask
.s_addr
);
3051 lsa
= ospf_lsdb_lookup_by_id(lsdb
, type
, id
, router_id
);
3059 struct ospf_lsa
*ospf_lsa_lookup(struct ospf
*ospf
, struct ospf_area
*area
,
3060 uint32_t type
, struct in_addr id
,
3061 struct in_addr adv_router
)
3067 case OSPF_ROUTER_LSA
:
3068 case OSPF_NETWORK_LSA
:
3069 case OSPF_SUMMARY_LSA
:
3070 case OSPF_ASBR_SUMMARY_LSA
:
3071 case OSPF_AS_NSSA_LSA
:
3072 case OSPF_OPAQUE_LINK_LSA
:
3073 case OSPF_OPAQUE_AREA_LSA
:
3074 return ospf_lsdb_lookup_by_id(area
->lsdb
, type
, id
, adv_router
);
3075 case OSPF_AS_EXTERNAL_LSA
:
3076 case OSPF_OPAQUE_AS_LSA
:
3077 return ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, id
, adv_router
);
3085 struct ospf_lsa
*ospf_lsa_lookup_by_id(struct ospf_area
*area
, uint32_t type
,
3088 struct ospf_lsa
*lsa
;
3089 struct route_node
*rn
;
3092 case OSPF_ROUTER_LSA
:
3093 return ospf_lsdb_lookup_by_id(area
->lsdb
, type
, id
, id
);
3094 case OSPF_NETWORK_LSA
:
3095 for (rn
= route_top(NETWORK_LSDB(area
)); rn
;
3096 rn
= route_next(rn
))
3097 if ((lsa
= rn
->info
))
3098 if (IPV4_ADDR_SAME(&lsa
->data
->id
, &id
)) {
3099 route_unlock_node(rn
);
3103 case OSPF_SUMMARY_LSA
:
3104 case OSPF_ASBR_SUMMARY_LSA
:
3105 /* Currently not used. */
3107 return ospf_lsdb_lookup_by_id(area
->lsdb
, type
, id
, id
);
3108 case OSPF_AS_EXTERNAL_LSA
:
3109 case OSPF_AS_NSSA_LSA
:
3110 case OSPF_OPAQUE_LINK_LSA
:
3111 case OSPF_OPAQUE_AREA_LSA
:
3112 case OSPF_OPAQUE_AS_LSA
:
3113 /* Currently not used. */
3122 struct ospf_lsa
*ospf_lsa_lookup_by_header(struct ospf_area
*area
,
3123 struct lsa_header
*lsah
)
3125 struct ospf_lsa
*match
;
3128 * Strictly speaking, the LSA-ID field for Opaque-LSAs (type-9/10/11)
3129 * is redefined to have two subfields; opaque-type and opaque-id.
3130 * However, it is harmless to treat the two sub fields together, as if
3131 * they two were forming a unique LSA-ID.
3134 match
= ospf_lsa_lookup(area
->ospf
, area
, lsah
->type
, lsah
->id
,
3138 if (IS_DEBUG_OSPF(lsa
, LSA
) == OSPF_DEBUG_LSA
)
3139 zlog_debug("LSA[Type%d:%s]: Lookup by header, NO MATCH",
3140 lsah
->type
, inet_ntoa(lsah
->id
));
3145 /* return +n, l1 is more recent.
3146 return -n, l2 is more recent.
3147 return 0, l1 and l2 is identical. */
3148 int ospf_lsa_more_recent(struct ospf_lsa
*l1
, struct ospf_lsa
*l2
)
3153 if (l1
== NULL
&& l2
== NULL
)
3160 /* compare LS sequence number. */
3161 x
= (int)ntohl(l1
->data
->ls_seqnum
);
3162 y
= (int)ntohl(l2
->data
->ls_seqnum
);
3168 /* compare LS checksum. */
3169 r
= ntohs(l1
->data
->checksum
) - ntohs(l2
->data
->checksum
);
3173 /* compare LS age. */
3174 if (IS_LSA_MAXAGE(l1
) && !IS_LSA_MAXAGE(l2
))
3176 else if (!IS_LSA_MAXAGE(l1
) && IS_LSA_MAXAGE(l2
))
3179 /* compare LS age with MaxAgeDiff. */
3180 if (LS_AGE(l1
) - LS_AGE(l2
) > OSPF_LSA_MAXAGE_DIFF
)
3182 else if (LS_AGE(l2
) - LS_AGE(l1
) > OSPF_LSA_MAXAGE_DIFF
)
3185 /* LSAs are identical. */
3189 /* If two LSAs are different, return 1, otherwise return 0. */
3190 int ospf_lsa_different(struct ospf_lsa
*l1
, struct ospf_lsa
*l2
)
3198 if (l1
->data
->options
!= l2
->data
->options
)
3201 if (IS_LSA_MAXAGE(l1
) && !IS_LSA_MAXAGE(l2
))
3204 if (IS_LSA_MAXAGE(l2
) && !IS_LSA_MAXAGE(l1
))
3207 if (l1
->data
->length
!= l2
->data
->length
)
3210 if (l1
->data
->length
== 0)
3213 if (CHECK_FLAG((l1
->flags
^ l2
->flags
), OSPF_LSA_RECEIVED
))
3214 return 1; /* May be a stale LSA in the LSBD */
3216 assert(ntohs(l1
->data
->length
) > OSPF_LSA_HEADER_SIZE
);
3218 p1
= (char *)l1
->data
;
3219 p2
= (char *)l2
->data
;
3221 if (memcmp(p1
+ OSPF_LSA_HEADER_SIZE
, p2
+ OSPF_LSA_HEADER_SIZE
,
3222 ntohs(l1
->data
->length
) - OSPF_LSA_HEADER_SIZE
)
3229 #ifdef ORIGINAL_CODING
3230 void ospf_lsa_flush_self_originated(struct ospf_neighbor
*nbr
,
3231 struct ospf_lsa
*self
, struct ospf_lsa
*new)
3235 /* Adjust LS Sequence Number. */
3236 seqnum
= ntohl(new->data
->ls_seqnum
) + 1;
3237 self
->data
->ls_seqnum
= htonl(seqnum
);
3239 /* Recalculate LSA checksum. */
3240 ospf_lsa_checksum(self
->data
);
3242 /* Reflooding LSA. */
3243 /* RFC2328 Section 13.3
3244 On non-broadcast networks, separate Link State Update
3245 packets must be sent, as unicasts, to each adjacent neighbor
3246 (i.e., those in state Exchange or greater). The destination
3247 IP addresses for these packets are the neighbors' IP
3249 if (nbr
->oi
->type
== OSPF_IFTYPE_NBMA
) {
3250 struct route_node
*rn
;
3251 struct ospf_neighbor
*onbr
;
3253 for (rn
= route_top(nbr
->oi
->nbrs
); rn
; rn
= route_next(rn
))
3254 if ((onbr
= rn
->info
) != NULL
)
3255 if (onbr
!= nbr
->oi
->nbr_self
3256 && onbr
->status
>= NSM_Exchange
)
3257 ospf_ls_upd_send_lsa(
3259 OSPF_SEND_PACKET_DIRECT
);
3261 ospf_ls_upd_send_lsa(nbr
, self
, OSPF_SEND_PACKET_INDIRECT
);
3263 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
3264 zlog_debug("LSA[Type%d:%s]: Flush self-originated LSA",
3265 self
->data
->type
, inet_ntoa(self
->data
->id
));
3267 #else /* ORIGINAL_CODING */
3268 int ospf_lsa_flush_schedule(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3270 if (lsa
== NULL
|| !IS_LSA_SELF(lsa
))
3273 if (IS_DEBUG_OSPF_EVENT
)
3275 "LSA[Type%d:%s]: Schedule self-originated LSA to FLUSH",
3276 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
));
3278 /* Force given lsa's age to MaxAge. */
3279 lsa
->data
->ls_age
= htons(OSPF_LSA_MAXAGE
);
3281 switch (lsa
->data
->type
) {
3282 /* Opaque wants to be notified of flushes */
3283 case OSPF_OPAQUE_LINK_LSA
:
3284 case OSPF_OPAQUE_AREA_LSA
:
3285 case OSPF_OPAQUE_AS_LSA
:
3286 ospf_opaque_lsa_refresh(lsa
);
3289 ospf_refresher_unregister_lsa(ospf
, lsa
);
3290 ospf_lsa_flush(ospf
, lsa
);
3297 void ospf_flush_self_originated_lsas_now(struct ospf
*ospf
)
3299 struct listnode
*node
, *nnode
;
3300 struct listnode
*node2
, *nnode2
;
3301 struct ospf_area
*area
;
3302 struct ospf_interface
*oi
;
3303 struct ospf_lsa
*lsa
;
3304 struct route_node
*rn
;
3305 int need_to_flush_ase
= 0;
3307 ospf
->inst_shutdown
= 1;
3309 for (ALL_LIST_ELEMENTS(ospf
->areas
, node
, nnode
, area
)) {
3310 if ((lsa
= area
->router_lsa_self
) != NULL
) {
3311 if (IS_DEBUG_OSPF_EVENT
)
3313 "LSA[Type%d:%s]: Schedule self-originated LSA to FLUSH",
3315 inet_ntoa(lsa
->data
->id
));
3317 ospf_refresher_unregister_lsa(ospf
, lsa
);
3318 ospf_lsa_flush_area(lsa
, area
);
3319 ospf_lsa_unlock(&area
->router_lsa_self
);
3320 area
->router_lsa_self
= NULL
;
3323 for (ALL_LIST_ELEMENTS(area
->oiflist
, node2
, nnode2
, oi
)) {
3324 if ((lsa
= oi
->network_lsa_self
) != NULL
3325 && oi
->state
== ISM_DR
&& oi
->full_nbrs
> 0) {
3326 if (IS_DEBUG_OSPF_EVENT
)
3328 "LSA[Type%d:%s]: Schedule self-originated LSA to FLUSH",
3330 inet_ntoa(lsa
->data
->id
));
3332 ospf_refresher_unregister_lsa(
3333 ospf
, oi
->network_lsa_self
);
3334 ospf_lsa_flush_area(oi
->network_lsa_self
, area
);
3335 ospf_lsa_unlock(&oi
->network_lsa_self
);
3336 oi
->network_lsa_self
= NULL
;
3339 if (oi
->type
!= OSPF_IFTYPE_VIRTUALLINK
3340 && area
->external_routing
== OSPF_AREA_DEFAULT
)
3341 need_to_flush_ase
= 1;
3344 LSDB_LOOP (SUMMARY_LSDB(area
), rn
, lsa
)
3345 ospf_lsa_flush_schedule(ospf
, lsa
);
3346 LSDB_LOOP (ASBR_SUMMARY_LSDB(area
), rn
, lsa
)
3347 ospf_lsa_flush_schedule(ospf
, lsa
);
3348 LSDB_LOOP (OPAQUE_LINK_LSDB(area
), rn
, lsa
)
3349 ospf_lsa_flush_schedule(ospf
, lsa
);
3350 LSDB_LOOP (OPAQUE_AREA_LSDB(area
), rn
, lsa
)
3351 ospf_lsa_flush_schedule(ospf
, lsa
);
3354 if (need_to_flush_ase
) {
3355 LSDB_LOOP (EXTERNAL_LSDB(ospf
), rn
, lsa
)
3356 ospf_lsa_flush_schedule(ospf
, lsa
);
3357 LSDB_LOOP (OPAQUE_AS_LSDB(ospf
), rn
, lsa
)
3358 ospf_lsa_flush_schedule(ospf
, lsa
);
3362 * Make sure that the MaxAge LSA remover is executed immediately,
3363 * without conflicting to other threads.
3365 if (ospf
->t_maxage
!= NULL
) {
3366 OSPF_TIMER_OFF(ospf
->t_maxage
);
3367 thread_execute(master
, ospf_maxage_lsa_remover
, ospf
, 0);
3372 #endif /* ORIGINAL_CODING */
3374 /* If there is self-originated LSA, then return 1, otherwise return 0. */
3375 /* An interface-independent version of ospf_lsa_is_self_originated */
3376 int ospf_lsa_is_self_originated(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3378 struct listnode
*node
;
3379 struct ospf_interface
*oi
;
3381 /* This LSA is already checked. */
3382 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_SELF_CHECKED
))
3383 return IS_LSA_SELF(lsa
);
3385 /* Make sure LSA is self-checked. */
3386 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF_CHECKED
);
3388 /* AdvRouter and Router ID is the same. */
3389 if (IPV4_ADDR_SAME(&lsa
->data
->adv_router
, &ospf
->router_id
))
3390 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF
);
3392 /* LSA is router-LSA. */
3393 else if (lsa
->data
->type
== OSPF_ROUTER_LSA
3394 && IPV4_ADDR_SAME(&lsa
->data
->id
, &ospf
->router_id
))
3395 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF
);
3397 /* LSA is network-LSA. Compare Link ID with all interfaces. */
3398 else if (lsa
->data
->type
== OSPF_NETWORK_LSA
)
3399 for (ALL_LIST_ELEMENTS_RO(ospf
->oiflist
, node
, oi
)) {
3400 /* Ignore virtual link. */
3401 if (oi
->type
!= OSPF_IFTYPE_VIRTUALLINK
)
3402 if (oi
->address
->family
== AF_INET
)
3405 &oi
->address
->u
.prefix4
)) {
3406 /* to make it easier later */
3407 SET_FLAG(lsa
->flags
,
3409 return IS_LSA_SELF(lsa
);
3413 return IS_LSA_SELF(lsa
);
3416 /* Get unique Link State ID. */
3417 struct in_addr
ospf_lsa_unique_id(struct ospf
*ospf
, struct ospf_lsdb
*lsdb
,
3418 uint8_t type
, struct prefix_ipv4
*p
)
3420 struct ospf_lsa
*lsa
;
3421 struct in_addr mask
, id
;
3425 /* Check existence of LSA instance. */
3426 lsa
= ospf_lsdb_lookup_by_id(lsdb
, type
, id
, ospf
->router_id
);
3428 struct as_external_lsa
*al
=
3429 (struct as_external_lsa
*)lsa
->data
;
3430 if (ip_masklen(al
->mask
) == p
->prefixlen
) {
3431 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
3433 "ospf_lsa_unique_id(): "
3434 "Can't get Link State ID for %s/%d",
3435 inet_ntoa(p
->prefix
), p
->prefixlen
);
3436 /* id.s_addr = 0; */
3437 id
.s_addr
= 0xffffffff;
3440 /* Masklen differs, then apply wildcard mask to Link State ID.
3443 masklen2ip(p
->prefixlen
, &mask
);
3445 id
.s_addr
= p
->prefix
.s_addr
| (~mask
.s_addr
);
3446 lsa
= ospf_lsdb_lookup_by_id(ospf
->lsdb
, type
, id
,
3449 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
3451 "ospf_lsa_unique_id(): "
3452 "Can't get Link State ID for %s/%d",
3453 inet_ntoa(p
->prefix
),
3455 /* id.s_addr = 0; */
3456 id
.s_addr
= 0xffffffff;
3466 #define LSA_ACTION_FLOOD_AREA 1
3467 #define LSA_ACTION_FLUSH_AREA 2
3471 struct ospf_area
*area
;
3472 struct ospf_lsa
*lsa
;
3475 static int ospf_lsa_action(struct thread
*t
)
3477 struct lsa_action
*data
;
3479 data
= THREAD_ARG(t
);
3481 if (IS_DEBUG_OSPF(lsa
, LSA
) == OSPF_DEBUG_LSA
)
3482 zlog_debug("LSA[Action]: Performing scheduled LSA action: %d",
3485 switch (data
->action
) {
3486 case LSA_ACTION_FLOOD_AREA
:
3487 ospf_flood_through_area(data
->area
, NULL
, data
->lsa
);
3489 case LSA_ACTION_FLUSH_AREA
:
3490 ospf_lsa_flush_area(data
->lsa
, data
->area
);
3494 ospf_lsa_unlock(&data
->lsa
); /* Message */
3495 XFREE(MTYPE_OSPF_MESSAGE
, data
);
3499 void ospf_schedule_lsa_flood_area(struct ospf_area
*area
, struct ospf_lsa
*lsa
)
3501 struct lsa_action
*data
;
3503 data
= XCALLOC(MTYPE_OSPF_MESSAGE
, sizeof(struct lsa_action
));
3504 data
->action
= LSA_ACTION_FLOOD_AREA
;
3506 data
->lsa
= ospf_lsa_lock(lsa
); /* Message / Flood area */
3508 thread_add_event(master
, ospf_lsa_action
, data
, 0, NULL
);
3511 void ospf_schedule_lsa_flush_area(struct ospf_area
*area
, struct ospf_lsa
*lsa
)
3513 struct lsa_action
*data
;
3515 data
= XCALLOC(MTYPE_OSPF_MESSAGE
, sizeof(struct lsa_action
));
3516 data
->action
= LSA_ACTION_FLUSH_AREA
;
3518 data
->lsa
= ospf_lsa_lock(lsa
); /* Message / Flush area */
3520 thread_add_event(master
, ospf_lsa_action
, data
, 0, NULL
);
3524 /* LSA Refreshment functions. */
3525 struct ospf_lsa
*ospf_lsa_refresh(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3527 struct external_info
*ei
;
3528 struct ospf_lsa
*new = NULL
;
3529 assert(CHECK_FLAG(lsa
->flags
, OSPF_LSA_SELF
));
3530 assert(IS_LSA_SELF(lsa
));
3531 assert(lsa
->lock
> 0);
3533 switch (lsa
->data
->type
) {
3534 /* Router and Network LSAs are processed differently. */
3535 case OSPF_ROUTER_LSA
:
3536 new = ospf_router_lsa_refresh(lsa
);
3538 case OSPF_NETWORK_LSA
:
3539 new = ospf_network_lsa_refresh(lsa
);
3541 case OSPF_SUMMARY_LSA
:
3542 new = ospf_summary_lsa_refresh(ospf
, lsa
);
3544 case OSPF_ASBR_SUMMARY_LSA
:
3545 new = ospf_summary_asbr_lsa_refresh(ospf
, lsa
);
3547 case OSPF_AS_EXTERNAL_LSA
:
3548 /* Translated from NSSA Type-5s are refreshed when
3549 * from refresh of Type-7 - do not refresh these directly.
3551 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
))
3553 ei
= ospf_external_info_check(ospf
, lsa
);
3555 new = ospf_external_lsa_refresh(ospf
, lsa
, ei
,
3558 ospf_lsa_flush_as(ospf
, lsa
);
3560 case OSPF_OPAQUE_LINK_LSA
:
3561 case OSPF_OPAQUE_AREA_LSA
:
3562 case OSPF_OPAQUE_AS_LSA
:
3563 new = ospf_opaque_lsa_refresh(lsa
);
3571 void ospf_refresher_register_lsa(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3573 uint16_t index
, current_index
;
3575 assert(lsa
->lock
> 0);
3576 assert(IS_LSA_SELF(lsa
));
3578 if (lsa
->refresh_list
< 0) {
3581 OSPF_LS_REFRESH_TIME
- (2 * OSPF_LS_REFRESH_JITTER
);
3582 int max_delay
= OSPF_LS_REFRESH_TIME
- OSPF_LS_REFRESH_JITTER
;
3584 /* We want to refresh the LSA within OSPF_LS_REFRESH_TIME which
3586 * 1800s. Use jitter so that we send the LSA sometime between
3590 delay
= (random() % (max_delay
- min_delay
)) + min_delay
;
3592 current_index
= ospf
->lsa_refresh_queue
.index
3593 + (monotime(NULL
) - ospf
->lsa_refresher_started
)
3594 / OSPF_LSA_REFRESHER_GRANULARITY
;
3596 index
= (current_index
+ delay
/ OSPF_LSA_REFRESHER_GRANULARITY
)
3597 % (OSPF_LSA_REFRESHER_SLOTS
);
3599 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3601 "LSA[Refresh:Type%d:%s]: age %d, added to index %d",
3602 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
),
3603 LS_AGE(lsa
), index
);
3605 if (!ospf
->lsa_refresh_queue
.qs
[index
])
3606 ospf
->lsa_refresh_queue
.qs
[index
] = list_new();
3608 listnode_add(ospf
->lsa_refresh_queue
.qs
[index
],
3609 ospf_lsa_lock(lsa
)); /* lsa_refresh_queue */
3610 lsa
->refresh_list
= index
;
3612 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3614 "LSA[Refresh:Type%d:%s]: ospf_refresher_register_lsa(): "
3615 "setting refresh_list on lsa %p (slod %d)",
3616 lsa
->data
->type
, inet_ntoa(lsa
->data
->id
),
3617 (void *)lsa
, index
);
3621 void ospf_refresher_unregister_lsa(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
3623 assert(lsa
->lock
> 0);
3624 assert(IS_LSA_SELF(lsa
));
3625 if (lsa
->refresh_list
>= 0) {
3626 struct list
*refresh_list
=
3627 ospf
->lsa_refresh_queue
.qs
[lsa
->refresh_list
];
3628 listnode_delete(refresh_list
, lsa
);
3629 if (!listcount(refresh_list
)) {
3630 list_delete_and_null(&refresh_list
);
3631 ospf
->lsa_refresh_queue
.qs
[lsa
->refresh_list
] = NULL
;
3633 ospf_lsa_unlock(&lsa
); /* lsa_refresh_queue */
3634 lsa
->refresh_list
= -1;
3638 int ospf_lsa_refresh_walker(struct thread
*t
)
3640 struct list
*refresh_list
;
3641 struct listnode
*node
, *nnode
;
3642 struct ospf
*ospf
= THREAD_ARG(t
);
3643 struct ospf_lsa
*lsa
;
3645 struct list
*lsa_to_refresh
= list_new();
3647 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3648 zlog_debug("LSA[Refresh]: ospf_lsa_refresh_walker(): start");
3651 i
= ospf
->lsa_refresh_queue
.index
;
3653 /* Note: if clock has jumped backwards, then time change could be
3655 so we are careful to cast the expression to unsigned before taking
3657 ospf
->lsa_refresh_queue
.index
=
3658 ((unsigned long)(ospf
->lsa_refresh_queue
.index
3660 - ospf
->lsa_refresher_started
)
3661 / OSPF_LSA_REFRESHER_GRANULARITY
))
3662 % OSPF_LSA_REFRESHER_SLOTS
;
3664 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3666 "LSA[Refresh]: ospf_lsa_refresh_walker(): next index %d",
3667 ospf
->lsa_refresh_queue
.index
);
3669 for (; i
!= ospf
->lsa_refresh_queue
.index
;
3670 i
= (i
+ 1) % OSPF_LSA_REFRESHER_SLOTS
) {
3671 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3673 "LSA[Refresh]: ospf_lsa_refresh_walker(): "
3677 refresh_list
= ospf
->lsa_refresh_queue
.qs
[i
];
3681 ospf
->lsa_refresh_queue
.qs
[i
] = NULL
;
3684 for (ALL_LIST_ELEMENTS(refresh_list
, node
, nnode
,
3686 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3688 "LSA[Refresh:Type%d:%s]: ospf_lsa_refresh_walker(): "
3689 "refresh lsa %p (slot %d)",
3691 inet_ntoa(lsa
->data
->id
),
3694 assert(lsa
->lock
> 0);
3695 list_delete_node(refresh_list
, node
);
3696 lsa
->refresh_list
= -1;
3697 listnode_add(lsa_to_refresh
, lsa
);
3699 list_delete_and_null(&refresh_list
);
3703 ospf
->t_lsa_refresher
= NULL
;
3704 thread_add_timer(master
, ospf_lsa_refresh_walker
, ospf
,
3705 ospf
->lsa_refresh_interval
, &ospf
->t_lsa_refresher
);
3706 ospf
->lsa_refresher_started
= monotime(NULL
);
3708 for (ALL_LIST_ELEMENTS(lsa_to_refresh
, node
, nnode
, lsa
)) {
3709 ospf_lsa_refresh(ospf
, lsa
);
3710 assert(lsa
->lock
> 0);
3712 &lsa
); /* lsa_refresh_queue & temp for lsa_to_refresh*/
3715 list_delete_and_null(&lsa_to_refresh
);
3717 if (IS_DEBUG_OSPF(lsa
, LSA_REFRESH
))
3718 zlog_debug("LSA[Refresh]: ospf_lsa_refresh_walker(): end");