1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * This is an implementation of Segment Routing
4 * as per RFC 8665 - OSPF Extensions for Segment Routing
5 * and RFC 8476 - Signaling Maximum SID Depth (MSD) Using OSPF
7 * Module name: Segment Routing
9 * Author: Olivier Dugeon <olivier.dugeon@orange.com>
10 * Author: Anselme Sawadogo <anselmesawadogo@gmail.com>
12 * Copyright (C) 2016 - 2020 Orange Labs http://www.orange.com
30 #include "libospf.h" /* for ospf interface types */
37 #include "sockunion.h" /* for inet_aton() */
45 #include "ospf_errors.h"
47 #include "ospfd/ospfd.h"
48 #include "ospfd/ospf_interface.h"
49 #include "ospfd/ospf_ism.h"
50 #include "ospfd/ospf_asbr.h"
51 #include "ospfd/ospf_lsa.h"
52 #include "ospfd/ospf_lsdb.h"
53 #include "ospfd/ospf_neighbor.h"
54 #include "ospfd/ospf_nsm.h"
55 #include "ospfd/ospf_flood.h"
56 #include "ospfd/ospf_packet.h"
57 #include "ospfd/ospf_spf.h"
58 #include "ospfd/ospf_dump.h"
59 #include "ospfd/ospf_route.h"
60 #include "ospfd/ospf_ase.h"
61 #include "ospfd/ospf_sr.h"
62 #include "ospfd/ospf_ri.h"
63 #include "ospfd/ospf_ext.h"
64 #include "ospfd/ospf_zebra.h"
67 * Global variable to manage Segment Routing on this node.
68 * Note that all parameter values are stored in network byte order.
70 static struct ospf_sr_db OspfSR
;
71 static void ospf_sr_register_vty(void);
72 static inline void del_adj_sid(struct sr_nhlfe nhlfe
);
73 static int ospf_sr_start(struct ospf
*ospf
);
76 * Segment Routing Data Base functions
79 /* Hash function for Segment Routing entry */
80 static unsigned int sr_hash(const void *p
)
82 const struct in_addr
*rid
= p
;
84 return jhash_1word(rid
->s_addr
, 0);
87 /* Compare 2 Router ID hash entries based on SR Node */
88 static bool sr_cmp(const void *p1
, const void *p2
)
90 const struct sr_node
*srn
= p1
;
91 const struct in_addr
*rid
= p2
;
93 return IPV4_ADDR_SAME(&srn
->adv_router
, rid
);
96 /* Functions to remove an SR Link */
97 static void del_sr_link(void *val
)
99 struct sr_link
*srl
= (struct sr_link
*)val
;
101 del_adj_sid(srl
->nhlfe
[0]);
102 del_adj_sid(srl
->nhlfe
[1]);
103 XFREE(MTYPE_OSPF_SR_PARAMS
, val
);
106 /* Functions to remove an SR Prefix */
107 static void del_sr_pref(void *val
)
109 struct sr_prefix
*srp
= (struct sr_prefix
*)val
;
111 ospf_zebra_delete_prefix_sid(srp
);
112 XFREE(MTYPE_OSPF_SR_PARAMS
, val
);
115 /* Allocate new Segment Routine node */
116 static struct sr_node
*sr_node_new(struct in_addr
*rid
)
124 /* Allocate Segment Routing node memory */
125 new = XCALLOC(MTYPE_OSPF_SR_PARAMS
, sizeof(struct sr_node
));
127 /* Default Algorithm, SRGB and MSD */
128 for (int i
= 0; i
< ALGORITHM_COUNT
; i
++)
129 new->algo
[i
] = SR_ALGORITHM_UNSET
;
131 new->srgb
.range_size
= 0;
132 new->srgb
.lower_bound
= 0;
135 /* Create Link, Prefix and Range TLVs list */
136 new->ext_link
= list_new();
137 new->ext_prefix
= list_new();
138 new->ext_link
->del
= del_sr_link
;
139 new->ext_prefix
->del
= del_sr_pref
;
141 IPV4_ADDR_COPY(&new->adv_router
, rid
);
142 new->neighbor
= NULL
;
145 osr_debug(" |- Created new SR node for %pI4", &new->adv_router
);
149 /* Supposed to be used for testing */
150 struct sr_node
*ospf_sr_node_create(struct in_addr
*rid
)
154 srn
= hash_get(OspfSR
.neighbors
, (void *)rid
, (void *)sr_node_new
);
159 /* Delete Segment Routing node */
160 static void sr_node_del(struct sr_node
*srn
)
166 osr_debug(" |- Delete SR node for %pI4", &srn
->adv_router
);
168 /* Clean Extended Link */
169 list_delete(&srn
->ext_link
);
171 /* Clean Prefix List */
172 list_delete(&srn
->ext_prefix
);
174 XFREE(MTYPE_OSPF_SR_PARAMS
, srn
);
177 /* Get SR Node for a given nexthop */
178 static struct sr_node
*get_sr_node_by_nexthop(struct ospf
*ospf
,
179 struct in_addr nexthop
)
181 struct ospf_interface
*oi
= NULL
;
182 struct ospf_neighbor
*nbr
= NULL
;
183 struct listnode
*node
;
184 struct route_node
*rn
;
189 if (OspfSR
.neighbors
== NULL
)
192 osr_debug(" |- Search SR-Node for nexthop %pI4", &nexthop
);
194 /* First, search neighbor Router ID for this nexthop */
196 for (ALL_LIST_ELEMENTS_RO(ospf
->oiflist
, node
, oi
)) {
197 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
)) {
199 if ((nbr
) && (IPV4_ADDR_SAME(&nexthop
, &nbr
->src
))) {
211 osr_debug(" |- Found nexthop Router ID %pI4", &nbr
->router_id
);
213 /* Then, search SR Node */
214 srn
= (struct sr_node
*)hash_lookup(OspfSR
.neighbors
, &nbr
->router_id
);
220 * Segment Routing Local Block management functions
224 * It is necessary to known which label is already allocated to manage the range
225 * of SRLB. This is particular useful when an interface flap (goes up / down
226 * frequently). Here, SR will release and then allocate label for the Adjacency
227 * for each concerned interface. If we don't care, there is a risk to run out of
230 * For that purpose, a similar principle as already provided to manage chunk of
231 * label is proposed. But, here, the label chunk has not a fix range of 64
232 * labels that could be easily manage with a single variable of 64 bits size.
233 * So, used_mark is used as a bit wise to mark label reserved (bit set) or not
234 * (bit unset). Its size is equal to the number of label of the SRLB range round
237 * - sr__local_block_init() computes the number of 64 bits variables that are
238 * needed to manage the SRLB range and allocates this number.
239 * - ospf_sr_local_block_request_label() pick up the first available label and
240 * set corresponding bit
241 * - ospf_sr_local_block_release_label() release label by reseting the
242 * corresponding bit and set the next label to the first free position
246 * Initialize Segment Routing Local Block from SRDB configuration and reserve
247 * block of bits to manage label allocation.
249 * @param lower_bound The lower bound of the SRLB range
250 * @param upper_bound The upper bound of the SRLB range
252 * @return 0 on success, -1 otherwise
254 static int sr_local_block_init(uint32_t lower_bound
, uint32_t upper_bound
)
256 struct sr_local_block
*srlb
= &OspfSR
.srlb
;
259 /* Check if SRLB is not already configured */
264 * Request SRLB to the label manager. If the allocation fails, return
265 * an error to disable SR until a new SRLB is successfully allocated.
267 size
= upper_bound
- lower_bound
+ 1;
268 if (ospf_zebra_request_label_range(lower_bound
, size
)) {
269 zlog_err("SR: Error reserving SRLB [%u/%u] %u labels",
270 lower_bound
, upper_bound
, size
);
274 osr_debug("SR: Got new SRLB [%u/%u], %u labels", lower_bound
,
277 /* Initialize the SRLB */
278 srlb
->start
= lower_bound
;
279 srlb
->end
= upper_bound
;
282 /* Compute the needed Used Mark number and allocate them */
283 srlb
->max_block
= size
/ SRLB_BLOCK_SIZE
;
284 if ((size
% SRLB_BLOCK_SIZE
) != 0)
286 srlb
->used_mark
= XCALLOC(MTYPE_OSPF_SR_PARAMS
,
287 srlb
->max_block
* SRLB_BLOCK_SIZE
);
288 srlb
->reserved
= true;
293 static int sr_global_block_init(uint32_t start
, uint32_t size
)
295 struct sr_global_block
*srgb
= &OspfSR
.srgb
;
297 /* Check if already configured */
302 uint32_t end
= start
+ size
- 1;
303 if (ospf_zebra_request_label_range(start
, size
) < 0) {
304 zlog_err("SR: Error reserving SRGB [%u/%u], %u labels", start
,
309 osr_debug("SR: Got new SRGB [%u/%u], %u labels", start
, end
, size
);
314 srgb
->reserved
= true;
319 * Remove Segment Routing Local Block.
322 static void sr_local_block_delete(void)
324 struct sr_local_block
*srlb
= &OspfSR
.srlb
;
326 /* Check if SRLB is not already delete */
330 osr_debug("SR (%s): Remove SRLB [%u/%u]", __func__
, srlb
->start
,
333 /* First release the label block */
334 ospf_zebra_release_label_range(srlb
->start
, srlb
->end
);
336 /* Then reset SRLB structure */
337 if (srlb
->used_mark
!= NULL
)
338 XFREE(MTYPE_OSPF_SR_PARAMS
, srlb
->used_mark
);
340 srlb
->reserved
= false;
344 * Remove Segment Routing Global block
346 static void sr_global_block_delete(void)
348 struct sr_global_block
*srgb
= &OspfSR
.srgb
;
353 osr_debug("SR (%s): Remove SRGB [%u/%u]", __func__
, srgb
->start
,
354 srgb
->start
+ srgb
->size
- 1);
356 ospf_zebra_release_label_range(srgb
->start
,
357 srgb
->start
+ srgb
->size
- 1);
359 srgb
->reserved
= false;
364 * Request a label from the Segment Routing Local Block.
366 * @return First available label on success or MPLS_INVALID_LABEL if the
367 * block of labels is full
369 mpls_label_t
ospf_sr_local_block_request_label(void)
371 struct sr_local_block
*srlb
= &OspfSR
.srlb
;
375 uint32_t size
= srlb
->end
- srlb
->start
+ 1;
377 /* Check if we ran out of available labels */
378 if (srlb
->current
>= size
)
379 return MPLS_INVALID_LABEL
;
381 /* Get first available label and mark it used */
382 label
= srlb
->current
+ srlb
->start
;
383 index
= srlb
->current
/ SRLB_BLOCK_SIZE
;
384 pos
= 1ULL << (srlb
->current
% SRLB_BLOCK_SIZE
);
385 srlb
->used_mark
[index
] |= pos
;
387 /* Jump to the next free position */
389 pos
= srlb
->current
% SRLB_BLOCK_SIZE
;
390 while (srlb
->current
< size
) {
393 if (!((1ULL << pos
) & srlb
->used_mark
[index
]))
397 pos
= srlb
->current
% SRLB_BLOCK_SIZE
;
401 if (srlb
->current
== size
)
403 "SR: Warning, SRLB is depleted and next label request will fail");
409 * Release label in the Segment Routing Local Block.
411 * @param label Label to be release
413 * @return 0 on success or -1 if label falls outside SRLB
415 int ospf_sr_local_block_release_label(mpls_label_t label
)
417 struct sr_local_block
*srlb
= &OspfSR
.srlb
;
421 /* Check that label falls inside the SRLB */
422 if ((label
< srlb
->start
) || (label
> srlb
->end
)) {
423 flog_warn(EC_OSPF_SR_SID_OVERFLOW
,
424 "%s: Returning label %u is outside SRLB [%u/%u]",
425 __func__
, label
, srlb
->start
, srlb
->end
);
429 index
= (label
- srlb
->start
) / SRLB_BLOCK_SIZE
;
430 pos
= 1ULL << ((label
- srlb
->start
) % SRLB_BLOCK_SIZE
);
431 srlb
->used_mark
[index
] &= ~pos
;
432 /* Reset current to the first available position */
433 for (index
= 0; index
< srlb
->max_block
; index
++) {
434 if (srlb
->used_mark
[index
] != 0xFFFFFFFFFFFFFFFF) {
435 for (pos
= 0; pos
< SRLB_BLOCK_SIZE
; pos
++)
436 if (!((1ULL << pos
) & srlb
->used_mark
[index
])) {
438 index
* SRLB_BLOCK_SIZE
+ pos
;
449 * Segment Routing Initialization functions
453 * Thread function to re-attempt connection to the Label Manager and thus be
454 * able to start Segment Routing.
456 * @param start Thread structure that contains area as argument
458 * @return 1 on success
460 static void sr_start_label_manager(struct thread
*start
)
464 ospf
= THREAD_ARG(start
);
466 /* re-attempt to start SR & Label Manager connection */
470 /* Segment Routing starter function */
471 static int ospf_sr_start(struct ospf
*ospf
)
473 struct route_node
*rn
;
474 struct ospf_lsa
*lsa
;
478 osr_debug("SR (%s): Start Segment Routing", __func__
);
480 /* Initialize self SR Node if not already done */
481 if (OspfSR
.self
== NULL
) {
482 srn
= hash_get(OspfSR
.neighbors
, (void *)&(ospf
->router_id
),
483 (void *)sr_node_new
);
485 /* Complete & Store self SR Node */
486 srn
->srgb
.range_size
= OspfSR
.srgb
.size
;
487 srn
->srgb
.lower_bound
= OspfSR
.srgb
.start
;
488 srn
->srlb
.lower_bound
= OspfSR
.srlb
.start
;
489 srn
->srlb
.range_size
= OspfSR
.srlb
.end
- OspfSR
.srlb
.start
+ 1;
490 srn
->algo
[0] = OspfSR
.algo
[0];
491 srn
->msd
= OspfSR
.msd
;
495 /* Then, start Label Manager if not ready */
496 if (!ospf_zebra_label_manager_ready())
497 if (ospf_zebra_label_manager_connect() < 0) {
498 /* Re-attempt to connect to Label Manager in 1 sec. */
499 thread_add_timer(master
, sr_start_label_manager
, ospf
,
500 1, &OspfSR
.t_start_lm
);
501 osr_debug(" |- Failed to start the Label Manager");
506 * Request SRLB & SGRB to the label manager if not already reserved.
507 * If the allocation fails, return an error to disable SR until a new
508 * SRLB and/or SRGB are successfully allocated.
510 if (sr_local_block_init(OspfSR
.srlb
.start
, OspfSR
.srlb
.end
) < 0)
513 if (sr_global_block_init(OspfSR
.srgb
.start
, OspfSR
.srgb
.size
) < 0)
516 /* SR is UP and ready to flood LSA */
517 OspfSR
.status
= SR_UP
;
519 /* Set Router Information SR parameters */
520 osr_debug("SR: Activate SR for Router Information LSA");
522 ospf_router_info_update_sr(true, OspfSR
.self
);
525 osr_debug("SR: Activate SR for Extended Link/Prefix LSA");
527 ospf_ext_update_sr(true);
529 osr_debug("SR (%s): Update SR-DB from LSDB", __func__
);
531 /* Start by looking to Router Info & Extended LSA in lsdb */
532 if ((ospf
!= NULL
) && (ospf
->backbone
!= NULL
)) {
533 LSDB_LOOP (OPAQUE_AREA_LSDB(ospf
->backbone
), rn
, lsa
) {
534 if (IS_LSA_MAXAGE(lsa
) || IS_LSA_SELF(lsa
))
537 GET_OPAQUE_TYPE(ntohl(lsa
->data
->id
.s_addr
));
539 case OPAQUE_TYPE_ROUTER_INFORMATION_LSA
:
540 ospf_sr_ri_lsa_update(lsa
);
542 case OPAQUE_TYPE_EXTENDED_PREFIX_LSA
:
543 ospf_sr_ext_prefix_lsa_update(lsa
);
545 case OPAQUE_TYPE_EXTENDED_LINK_LSA
:
546 ospf_sr_ext_link_lsa_update(lsa
);
558 /* Stop Segment Routing */
559 static void ospf_sr_stop(void)
562 if (OspfSR
.status
== SR_OFF
)
565 osr_debug("SR (%s): Stop Segment Routing", __func__
);
567 /* Disable any re-attempt to connect to Label Manager */
568 THREAD_OFF(OspfSR
.t_start_lm
);
570 /* Release SRGB if active */
571 sr_global_block_delete();
573 /* Release SRLB if active */
574 sr_local_block_delete();
577 * Remove all SR Nodes from the Hash table. Prefix and Link SID will
578 * be remove though list_delete() call. See sr_node_del()
580 hash_clean(OspfSR
.neighbors
, (void *)sr_node_del
);
582 OspfSR
.status
= SR_OFF
;
586 * Segment Routing initialize function
590 * @return 0 if OK, -1 otherwise
592 int ospf_sr_init(void)
596 osr_debug("SR (%s): Initialize SR Data Base", __func__
);
598 memset(&OspfSR
, 0, sizeof(OspfSR
));
599 OspfSR
.status
= SR_OFF
;
600 /* Only AREA flooding is supported in this release */
601 OspfSR
.scope
= OSPF_OPAQUE_AREA_LSA
;
603 /* Initialize Algorithms, SRGB, SRLB and MSD TLVs */
604 /* Only Algorithm SPF is supported */
605 OspfSR
.algo
[0] = SR_ALGORITHM_SPF
;
606 for (int i
= 1; i
< ALGORITHM_COUNT
; i
++)
607 OspfSR
.algo
[i
] = SR_ALGORITHM_UNSET
;
609 OspfSR
.srgb
.size
= DEFAULT_SRGB_SIZE
;
610 OspfSR
.srgb
.start
= DEFAULT_SRGB_LABEL
;
611 OspfSR
.srgb
.reserved
= false;
613 OspfSR
.srlb
.start
= DEFAULT_SRLB_LABEL
;
614 OspfSR
.srlb
.end
= DEFAULT_SRLB_END
;
615 OspfSR
.srlb
.reserved
= false;
618 /* Initialize Hash table for neighbor SR nodes */
619 OspfSR
.neighbors
= hash_create(sr_hash
, sr_cmp
, "OSPF_SR");
620 if (OspfSR
.neighbors
== NULL
)
623 /* Register Segment Routing VTY command */
624 ospf_sr_register_vty();
631 * Segment Routing termination function
636 void ospf_sr_term(void)
639 /* Stop Segment Routing */
642 /* Clear SR Node Table */
643 if (OspfSR
.neighbors
)
644 hash_free(OspfSR
.neighbors
);
649 * Segment Routing finish function
654 void ospf_sr_finish(void)
656 /* Stop Segment Routing */
661 * Following functions are used to manipulate the
662 * Next Hop Label Forwarding entry (NHLFE)
665 /* Compute label from index */
666 static mpls_label_t
index2label(uint32_t index
, struct sr_block srgb
)
670 label
= srgb
.lower_bound
+ index
;
671 if (label
> (srgb
.lower_bound
+ srgb
.range_size
)) {
672 flog_warn(EC_OSPF_SR_SID_OVERFLOW
,
673 "%s: SID index %u falls outside SRGB range",
675 return MPLS_INVALID_LABEL
;
680 /* Get the prefix sid for a specific router id */
681 mpls_label_t
ospf_sr_get_prefix_sid_by_id(struct in_addr
*id
)
684 struct sr_prefix
*srp
;
687 srn
= (struct sr_node
*)hash_lookup(OspfSR
.neighbors
, id
);
691 * TODO: Here we assume that the SRGBs are the same,
692 * and that the node's prefix SID is at the head of
693 * the list, probably needs tweaking.
695 srp
= listnode_head(srn
->ext_prefix
);
696 label
= index2label(srp
->sid
, srn
->srgb
);
698 label
= MPLS_INVALID_LABEL
;
704 /* Get the adjacency sid for a specific 'root' id and 'neighbor' id */
705 mpls_label_t
ospf_sr_get_adj_sid_by_id(struct in_addr
*root_id
,
706 struct in_addr
*neighbor_id
)
711 struct listnode
*node
;
713 srn
= (struct sr_node
*)hash_lookup(OspfSR
.neighbors
, root_id
);
715 label
= MPLS_INVALID_LABEL
;
718 for (ALL_LIST_ELEMENTS_RO(srn
->ext_link
, node
, srl
)) {
719 if (srl
->type
== ADJ_SID
720 && srl
->remote_id
.s_addr
== neighbor_id
->s_addr
) {
730 /* Get neighbor full structure from address */
731 static struct ospf_neighbor
*get_neighbor_by_addr(struct ospf
*top
,
734 struct ospf_neighbor
*nbr
;
735 struct ospf_interface
*oi
;
736 struct listnode
*node
;
737 struct route_node
*rn
;
743 for (ALL_LIST_ELEMENTS_RO(top
->oiflist
, node
, oi
))
744 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
)) {
749 if (IPV4_ADDR_SAME(&nbr
->address
.u
.prefix4
, &addr
) ||
750 IPV4_ADDR_SAME(&nbr
->router_id
, &addr
)) {
751 route_unlock_node(rn
);
758 /* Get OSPF Path from address */
759 static struct ospf_route
*get_nexthop_by_addr(struct ospf
*top
,
760 struct prefix_ipv4 p
)
762 struct route_node
*rn
;
768 osr_debug(" |- Search Nexthop for prefix %pFX",
769 (struct prefix
*)&p
);
771 rn
= route_node_lookup(top
->new_table
, (struct prefix
*)&p
);
774 * Check if we found an OSPF route. May be NULL if SPF has not
775 * yet populate routing table for this prefix.
780 route_unlock_node(rn
);
784 /* Compute NHLFE entry for Extended Link */
785 static int compute_link_nhlfe(struct sr_link
*srl
)
787 struct ospf
*top
= ospf_lookup_by_vrf_id(VRF_DEFAULT
);
788 struct ospf_neighbor
*nh
;
791 osr_debug(" |- Compute NHLFE for link %pI4", &srl
->itf_addr
);
793 /* First determine the OSPF Neighbor */
794 nh
= get_neighbor_by_addr(top
, srl
->nhlfe
[0].nexthop
);
796 /* Neighbor could be not found when OSPF Adjacency just fire up
797 * because SPF don't yet populate routing table. This NHLFE will
798 * be fixed later when SR SPF schedule will be called.
803 osr_debug(" |- Found nexthop %pI4", &nh
->router_id
);
805 /* Set ifindex for this neighbor */
806 srl
->nhlfe
[0].ifindex
= nh
->oi
->ifp
->ifindex
;
807 srl
->nhlfe
[1].ifindex
= nh
->oi
->ifp
->ifindex
;
809 /* Update neighbor address for LAN_ADJ_SID */
810 if (srl
->type
== LAN_ADJ_SID
) {
811 IPV4_ADDR_COPY(&srl
->nhlfe
[0].nexthop
, &nh
->src
);
812 IPV4_ADDR_COPY(&srl
->nhlfe
[1].nexthop
, &nh
->src
);
815 /* Set Input & Output Label */
816 if (CHECK_FLAG(srl
->flags
[0], EXT_SUBTLV_LINK_ADJ_SID_VFLG
))
817 srl
->nhlfe
[0].label_in
= srl
->sid
[0];
819 srl
->nhlfe
[0].label_in
=
820 index2label(srl
->sid
[0], srl
->srn
->srgb
);
821 if (CHECK_FLAG(srl
->flags
[1], EXT_SUBTLV_LINK_ADJ_SID_VFLG
))
822 srl
->nhlfe
[1].label_in
= srl
->sid
[1];
824 srl
->nhlfe
[1].label_in
=
825 index2label(srl
->sid
[1], srl
->srn
->srgb
);
827 srl
->nhlfe
[0].label_out
= MPLS_LABEL_IMPLICIT_NULL
;
828 srl
->nhlfe
[1].label_out
= MPLS_LABEL_IMPLICIT_NULL
;
835 * Compute output label for the given Prefix-SID.
837 * @param srp Segment Routing Prefix
838 * @param srnext Segment Routing nexthop node
840 * @return MPLS label or MPLS_INVALID_LABEL in case of error
842 static mpls_label_t
sr_prefix_out_label(const struct sr_prefix
*srp
,
843 const struct sr_node
*srnext
)
845 /* Check if the nexthop SR Node is the last hop? */
846 if (srnext
== srp
->srn
) {
847 /* SR-Node doesn't request NO-PHP. Return Implicit NULL label */
848 if (!CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_NPFLG
))
849 return MPLS_LABEL_IMPLICIT_NULL
;
851 /* SR-Node requests Explicit NULL Label */
852 if (CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_EFLG
))
853 return MPLS_LABEL_IPV4_EXPLICIT_NULL
;
857 /* Return SID value as MPLS label if it is an Absolute SID */
858 if (CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_VFLG
859 | EXT_SUBTLV_PREFIX_SID_LFLG
)) {
861 * V/L SIDs have local significance, so only adjacent routers
862 * can use them (RFC8665 section #5)
864 if (srp
->srn
!= srnext
)
865 return MPLS_INVALID_LABEL
;
869 /* Return MPLS label as SRGB lower bound + SID index as per RFC 8665 */
870 return (index2label(srp
->sid
, srnext
->srgb
));
874 * Compute NHLFE entry for Extended Prefix
876 * @param srp - Segment Routing Prefix
878 * @return -1 if no route is found, 0 if there is no SR route ready
879 * and 1 if success or update
881 static int compute_prefix_nhlfe(struct sr_prefix
*srp
)
883 struct ospf
*top
= ospf_lookup_by_vrf_id(VRF_DEFAULT
);
884 struct ospf_path
*path
;
885 struct listnode
*node
;
886 struct sr_node
*srnext
;
889 osr_debug(" |- Compute NHLFE for prefix %pFX",
890 (struct prefix
*)&srp
->prefv4
);
893 /* First determine the nexthop */
894 srp
->route
= get_nexthop_by_addr(top
, srp
->prefv4
);
896 /* Nexthop could be not found when OSPF Adjacency just fire up
897 * because SPF don't yet populate routing table. This NHLFE will
898 * be fixed later when SR SPF schedule will be called.
900 if (srp
->route
== NULL
)
903 /* Compute Input Label with self SRGB */
904 srp
->label_in
= index2label(srp
->sid
, OspfSR
.self
->srgb
);
907 for (ALL_LIST_ELEMENTS_RO(srp
->route
->paths
, node
, path
)) {
909 osr_debug(" |- Process new route via %pI4 for this prefix",
913 * Get SR-Node for this nexthop. Could be not yet available
914 * as Extended Link / Prefix and Router Information are flooded
915 * after LSA Type 1 & 2 which populate the OSPF Route Table
917 srnext
= get_sr_node_by_nexthop(top
, path
->nexthop
);
921 /* And store this information for later update */
922 srnext
->neighbor
= OspfSR
.self
;
923 path
->srni
.nexthop
= srnext
;
926 * SR Node could be known, but SRGB could be not initialize
927 * This is due to the fact that Extended Link / Prefix could
928 * be received before corresponding Router Information LSA
930 if (srnext
== NULL
|| srnext
->srgb
.lower_bound
== 0
931 || srnext
->srgb
.range_size
== 0) {
933 " |- SR-Node %pI4 not ready. Stop process",
934 &srnext
->adv_router
);
935 path
->srni
.label_out
= MPLS_INVALID_LABEL
;
939 osr_debug(" |- Found SRGB %u/%u for next hop SR-Node %pI4",
940 srnext
->srgb
.range_size
, srnext
->srgb
.lower_bound
,
941 &srnext
->adv_router
);
943 /* Compute Output Label with Nexthop SR Node SRGB */
944 path
->srni
.label_out
= sr_prefix_out_label(srp
, srnext
);
946 osr_debug(" |- Computed new labels in: %u out: %u",
947 srp
->label_in
, path
->srni
.label_out
);
953 /* Add new NHLFE entry for Adjacency SID */
954 static inline void add_adj_sid(struct sr_nhlfe nhlfe
)
956 if (nhlfe
.label_in
!= 0)
957 ospf_zebra_send_adjacency_sid(ZEBRA_MPLS_LABELS_ADD
, nhlfe
);
960 /* Remove NHLFE entry for Adjacency SID */
961 static inline void del_adj_sid(struct sr_nhlfe nhlfe
)
963 if (nhlfe
.label_in
!= 0)
964 ospf_zebra_send_adjacency_sid(ZEBRA_MPLS_LABELS_DELETE
, nhlfe
);
967 /* Update NHLFE entry for Adjacency SID */
968 static inline void update_adj_sid(struct sr_nhlfe n1
, struct sr_nhlfe n2
)
975 * Functions to parse and get Extended Link / Prefix
979 /* Extended Link SubTLVs Getter */
980 static struct sr_link
*get_ext_link_sid(struct tlv_header
*tlvh
, size_t size
)
984 struct ext_tlv_link
*link
= (struct ext_tlv_link
*)tlvh
;
985 struct ext_subtlv_adj_sid
*adj_sid
;
986 struct ext_subtlv_lan_adj_sid
*lan_sid
;
987 struct ext_subtlv_rmt_itf_addr
*rmt_itf
;
989 struct tlv_header
*sub_tlvh
;
990 uint16_t length
= 0, sum
= 0, i
= 0;
993 if ((ntohs(tlvh
->length
) > size
)
994 || ntohs(tlvh
->length
) < EXT_TLV_LINK_SIZE
) {
995 zlog_warn("Wrong Extended Link TLV size. Abort!");
999 srl
= XCALLOC(MTYPE_OSPF_SR_PARAMS
, sizeof(struct sr_link
));
1001 /* Initialize TLV browsing */
1002 length
= ntohs(tlvh
->length
) - EXT_TLV_LINK_SIZE
;
1003 sub_tlvh
= (struct tlv_header
*)((char *)(tlvh
) + TLV_HDR_SIZE
1004 + EXT_TLV_LINK_SIZE
);
1005 for (; sum
< length
&& sub_tlvh
; sub_tlvh
= TLV_HDR_NEXT(sub_tlvh
)) {
1006 switch (ntohs(sub_tlvh
->type
)) {
1007 case EXT_SUBTLV_ADJ_SID
:
1008 adj_sid
= (struct ext_subtlv_adj_sid
*)sub_tlvh
;
1009 srl
->type
= ADJ_SID
;
1010 i
= CHECK_FLAG(adj_sid
->flags
,
1011 EXT_SUBTLV_LINK_ADJ_SID_BFLG
)
1014 srl
->flags
[i
] = adj_sid
->flags
;
1015 if (CHECK_FLAG(adj_sid
->flags
,
1016 EXT_SUBTLV_LINK_ADJ_SID_VFLG
))
1017 srl
->sid
[i
] = GET_LABEL(ntohl(adj_sid
->value
));
1019 srl
->sid
[i
] = ntohl(adj_sid
->value
);
1020 IPV4_ADDR_COPY(&srl
->nhlfe
[i
].nexthop
, &link
->link_id
);
1022 case EXT_SUBTLV_LAN_ADJ_SID
:
1023 lan_sid
= (struct ext_subtlv_lan_adj_sid
*)sub_tlvh
;
1024 srl
->type
= LAN_ADJ_SID
;
1025 i
= CHECK_FLAG(lan_sid
->flags
,
1026 EXT_SUBTLV_LINK_ADJ_SID_BFLG
)
1029 srl
->flags
[i
] = lan_sid
->flags
;
1030 if (CHECK_FLAG(lan_sid
->flags
,
1031 EXT_SUBTLV_LINK_ADJ_SID_VFLG
))
1032 srl
->sid
[i
] = GET_LABEL(ntohl(lan_sid
->value
));
1034 srl
->sid
[i
] = ntohl(lan_sid
->value
);
1035 IPV4_ADDR_COPY(&srl
->nhlfe
[i
].nexthop
,
1036 &lan_sid
->neighbor_id
);
1038 case EXT_SUBTLV_RMT_ITF_ADDR
:
1039 rmt_itf
= (struct ext_subtlv_rmt_itf_addr
*)sub_tlvh
;
1040 IPV4_ADDR_COPY(&srl
->nhlfe
[0].nexthop
, &rmt_itf
->value
);
1041 IPV4_ADDR_COPY(&srl
->nhlfe
[1].nexthop
, &rmt_itf
->value
);
1046 sum
+= TLV_SIZE(sub_tlvh
);
1049 IPV4_ADDR_COPY(&srl
->itf_addr
, &link
->link_data
);
1051 osr_debug(" |- Found primary %u and backup %u Adj/Lan Sid for %pI4",
1052 srl
->sid
[0], srl
->sid
[1], &srl
->itf_addr
);
1057 /* Extended Prefix SubTLVs Getter */
1058 static struct sr_prefix
*get_ext_prefix_sid(struct tlv_header
*tlvh
,
1062 struct sr_prefix
*srp
;
1063 struct ext_tlv_prefix
*pref
= (struct ext_tlv_prefix
*)tlvh
;
1064 struct ext_subtlv_prefix_sid
*psid
;
1066 struct tlv_header
*sub_tlvh
;
1067 uint16_t length
= 0, sum
= 0;
1069 /* Check TLV size */
1070 if ((ntohs(tlvh
->length
) > size
)
1071 || ntohs(tlvh
->length
) < EXT_TLV_PREFIX_SIZE
) {
1072 zlog_warn("Wrong Extended Link TLV size. Abort!");
1076 srp
= XCALLOC(MTYPE_OSPF_SR_PARAMS
, sizeof(struct sr_prefix
));
1078 /* Initialize TLV browsing */
1079 length
= ntohs(tlvh
->length
) - EXT_TLV_PREFIX_SIZE
;
1080 sub_tlvh
= (struct tlv_header
*)((char *)(tlvh
) + TLV_HDR_SIZE
1081 + EXT_TLV_PREFIX_SIZE
);
1082 for (; sum
< length
&& sub_tlvh
; sub_tlvh
= TLV_HDR_NEXT(sub_tlvh
)) {
1083 switch (ntohs(sub_tlvh
->type
)) {
1084 case EXT_SUBTLV_PREFIX_SID
:
1085 psid
= (struct ext_subtlv_prefix_sid
*)sub_tlvh
;
1086 if (psid
->algorithm
!= SR_ALGORITHM_SPF
) {
1087 flog_err(EC_OSPF_INVALID_ALGORITHM
,
1088 "SR (%s): Unsupported Algorithm",
1090 XFREE(MTYPE_OSPF_SR_PARAMS
, srp
);
1093 srp
->type
= PREF_SID
;
1094 srp
->flags
= psid
->flags
;
1095 if (CHECK_FLAG(psid
->flags
, EXT_SUBTLV_PREFIX_SID_VFLG
))
1096 srp
->sid
= GET_LABEL(ntohl(psid
->value
));
1098 srp
->sid
= ntohl(psid
->value
);
1099 IPV4_ADDR_COPY(&srp
->prefv4
.prefix
, &pref
->address
);
1100 srp
->prefv4
.prefixlen
= pref
->pref_length
;
1101 srp
->prefv4
.family
= AF_INET
;
1102 apply_mask_ipv4(&srp
->prefv4
);
1107 sum
+= TLV_SIZE(sub_tlvh
);
1110 osr_debug(" |- Found SID %u for prefix %pFX", srp
->sid
,
1111 (struct prefix
*)&srp
->prefv4
);
1117 * Functions to manipulate Segment Routing Link & Prefix structures
1120 /* Compare two Segment Link: return 0 if equal, 1 otherwise */
1121 static inline int sr_link_cmp(struct sr_link
*srl1
, struct sr_link
*srl2
)
1123 if ((srl1
->sid
[0] == srl2
->sid
[0]) && (srl1
->sid
[1] == srl2
->sid
[1])
1124 && (srl1
->type
== srl2
->type
) && (srl1
->flags
[0] == srl2
->flags
[0])
1125 && (srl1
->flags
[1] == srl2
->flags
[1]))
1131 /* Compare two Segment Prefix: return 0 if equal, 1 otherwise */
1132 static inline int sr_prefix_cmp(struct sr_prefix
*srp1
, struct sr_prefix
*srp2
)
1134 if ((srp1
->sid
== srp2
->sid
) && (srp1
->flags
== srp2
->flags
))
1140 /* Update Segment Link of given Segment Routing Node */
1141 static void update_ext_link_sid(struct sr_node
*srn
, struct sr_link
*srl
,
1144 struct listnode
*node
;
1150 if ((srn
== NULL
) || (srl
== NULL
))
1153 osr_debug(" |- Process Extended Link Adj/Lan-SID");
1155 /* Detect if Adj/Lan_Adj SID must be configured */
1156 if (!CHECK_FLAG(lsa_flags
, OSPF_LSA_SELF
)
1157 && (CHECK_FLAG(srl
->flags
[0], EXT_SUBTLV_LINK_ADJ_SID_LFLG
)
1158 || CHECK_FLAG(srl
->flags
[1], EXT_SUBTLV_LINK_ADJ_SID_LFLG
)))
1161 /* Search for existing Segment Link */
1162 for (ALL_LIST_ELEMENTS_RO(srn
->ext_link
, node
, lk
))
1163 if (lk
->instance
== srl
->instance
) {
1168 osr_debug(" |- %s SR Link 8.0.0.%u for SR node %pI4",
1169 found
? "Update" : "Add", GET_OPAQUE_ID(srl
->instance
),
1172 /* if not found, add new Segment Link and install NHLFE */
1174 /* Complete SR-Link and add it to SR-Node list */
1176 IPV4_ADDR_COPY(&srl
->adv_router
, &srn
->adv_router
);
1177 listnode_add(srn
->ext_link
, srl
);
1178 /* Try to set MPLS table */
1179 if (config
&& compute_link_nhlfe(srl
)) {
1180 add_adj_sid(srl
->nhlfe
[0]);
1181 add_adj_sid(srl
->nhlfe
[1]);
1184 /* Update SR-Link if they are different */
1185 if (sr_link_cmp(lk
, srl
)) {
1186 /* Try to set MPLS table */
1188 if (compute_link_nhlfe(srl
)) {
1189 update_adj_sid(lk
->nhlfe
[0],
1191 update_adj_sid(lk
->nhlfe
[1],
1194 del_adj_sid(lk
->nhlfe
[0]);
1195 del_adj_sid(lk
->nhlfe
[1]);
1198 /* Replace SR-Link in SR-Node Adjacency List */
1199 listnode_delete(srn
->ext_link
, lk
);
1200 XFREE(MTYPE_OSPF_SR_PARAMS
, lk
);
1202 IPV4_ADDR_COPY(&srl
->adv_router
, &srn
->adv_router
);
1203 listnode_add(srn
->ext_link
, srl
);
1206 * This is just an LSA refresh.
1207 * Stop processing and free SR Link
1209 XFREE(MTYPE_OSPF_SR_PARAMS
, srl
);
1214 /* Update Segment Prefix of given Segment Routing Node */
1215 static void update_ext_prefix_sid(struct sr_node
*srn
, struct sr_prefix
*srp
)
1218 struct listnode
*node
;
1219 struct sr_prefix
*pref
;
1223 if (srn
== NULL
|| srp
== NULL
)
1226 osr_debug(" |- Process Extended Prefix SID %u", srp
->sid
);
1228 /* Process only Global Prefix SID */
1229 if (CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_LFLG
))
1232 /* Search for existing Segment Prefix */
1233 for (ALL_LIST_ELEMENTS_RO(srn
->ext_prefix
, node
, pref
))
1234 if (pref
->instance
== srp
->instance
1235 && prefix_same((struct prefix
*)&srp
->prefv4
,
1241 osr_debug(" |- %s SR LSA ID 7.0.0.%u for SR node %pI4",
1242 found
? "Update" : "Add", GET_OPAQUE_ID(srp
->instance
),
1245 /* Complete SR-Prefix */
1247 IPV4_ADDR_COPY(&srp
->adv_router
, &srn
->adv_router
);
1249 /* if not found, add new Segment Prefix and install NHLFE */
1251 /* Add it to SR-Node list ... */
1252 listnode_add(srn
->ext_prefix
, srp
);
1253 /* ... and try to set MPLS table */
1254 if (compute_prefix_nhlfe(srp
) == 1)
1255 ospf_zebra_update_prefix_sid(srp
);
1258 * An old SR prefix exist. Check if something changes or if it
1259 * is just a refresh.
1261 if (sr_prefix_cmp(pref
, srp
)) {
1262 if (compute_prefix_nhlfe(srp
) == 1) {
1263 ospf_zebra_delete_prefix_sid(pref
);
1264 /* Replace Segment Prefix */
1265 listnode_delete(srn
->ext_prefix
, pref
);
1266 XFREE(MTYPE_OSPF_SR_PARAMS
, pref
);
1267 listnode_add(srn
->ext_prefix
, srp
);
1268 ospf_zebra_update_prefix_sid(srp
);
1270 /* New NHLFE was not found.
1271 * Just free the SR Prefix
1273 XFREE(MTYPE_OSPF_SR_PARAMS
, srp
);
1276 /* This is just an LSA refresh.
1277 * Stop processing and free SR Prefix
1279 XFREE(MTYPE_OSPF_SR_PARAMS
, srp
);
1285 * When change the FRR Self SRGB, update the NHLFE Input Label
1286 * for all Extended Prefix with SID index through hash_iterate()
1288 static void update_in_nhlfe(struct hash_bucket
*bucket
, void *args
)
1290 struct listnode
*node
;
1291 struct sr_node
*srn
= (struct sr_node
*)bucket
->data
;
1292 struct sr_prefix
*srp
;
1294 /* Process Every Extended Prefix for this SR-Node */
1295 for (ALL_LIST_ELEMENTS_RO(srn
->ext_prefix
, node
, srp
)) {
1296 /* Process Self SRN only if NO-PHP is requested */
1297 if ((srn
== OspfSR
.self
)
1298 && !CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_NPFLG
))
1301 /* Process only SID Index */
1302 if (CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_VFLG
))
1305 /* First, remove old MPLS table entries ... */
1306 ospf_zebra_delete_prefix_sid(srp
);
1307 /* ... then compute new input label ... */
1308 srp
->label_in
= index2label(srp
->sid
, OspfSR
.self
->srgb
);
1309 /* ... and install new MPLS LFIB */
1310 ospf_zebra_update_prefix_sid(srp
);
1315 * When SRGB has changed, update NHLFE Output Label for all Extended Prefix
1316 * with SID index which use the given SR-Node as nexthop through hash_iterate()
1318 static void update_out_nhlfe(struct hash_bucket
*bucket
, void *args
)
1320 struct listnode
*node
, *pnode
;
1321 struct sr_node
*srn
= (struct sr_node
*)bucket
->data
;
1322 struct sr_node
*srnext
= (struct sr_node
*)args
;
1323 struct sr_prefix
*srp
;
1324 struct ospf_path
*path
;
1326 /* Skip Self SR-Node */
1327 if (srn
== OspfSR
.self
)
1330 osr_debug("SR (%s): Update Out NHLFE for neighbor SR-Node %pI4",
1331 __func__
, &srn
->adv_router
);
1333 for (ALL_LIST_ELEMENTS_RO(srn
->ext_prefix
, node
, srp
)) {
1334 /* Skip Prefix that has not yet a valid route */
1335 if (srp
->route
== NULL
)
1338 for (ALL_LIST_ELEMENTS_RO(srp
->route
->paths
, pnode
, path
)) {
1339 /* Skip path that has not next SR-Node as nexthop */
1340 if (path
->srni
.nexthop
!= srnext
)
1343 /* Compute new Output Label */
1344 path
->srni
.label_out
= sr_prefix_out_label(srp
, srnext
);
1347 /* Finally update MPLS table */
1348 ospf_zebra_update_prefix_sid(srp
);
1353 * Following functions are call when new Segment Routing LSA are received
1354 * - Router Information: ospf_sr_ri_lsa_update() & ospf_sr_ri_lsa_delete()
1355 * - Extended Link: ospf_sr_ext_link_update() & ospf_sr_ext_link_delete()
1356 * - Extended Prefix: ospf_ext_prefix_update() & ospf_sr_ext_prefix_delete()
1359 /* Update Segment Routing from Router Information LSA */
1360 void ospf_sr_ri_lsa_update(struct ospf_lsa
*lsa
)
1362 struct sr_node
*srn
;
1363 struct tlv_header
*tlvh
;
1364 struct lsa_header
*lsah
= lsa
->data
;
1365 struct ri_sr_tlv_sid_label_range
*ri_srgb
= NULL
;
1366 struct ri_sr_tlv_sid_label_range
*ri_srlb
= NULL
;
1367 struct ri_sr_tlv_sr_algorithm
*algo
= NULL
;
1368 struct sr_block srgb
;
1369 uint16_t length
= 0, sum
= 0;
1372 osr_debug("SR (%s): Process Router Information LSA 4.0.0.%u from %pI4",
1373 __func__
, GET_OPAQUE_ID(ntohl(lsah
->id
.s_addr
)),
1377 if (IS_LSA_SELF(lsa
))
1380 if (OspfSR
.neighbors
== NULL
) {
1381 flog_err(EC_OSPF_SR_INVALID_DB
,
1382 "SR (%s): Abort! no valid SR DataBase", __func__
);
1386 /* Search SR Node in hash table from Router ID */
1387 srn
= (struct sr_node
*)hash_lookup(OspfSR
.neighbors
,
1391 /* Collect Router Information Sub TLVs */
1392 /* Initialize TLV browsing */
1393 length
= lsa
->size
- OSPF_LSA_HEADER_SIZE
;
1394 srgb
.range_size
= 0;
1395 srgb
.lower_bound
= 0;
1397 for (tlvh
= TLV_HDR_TOP(lsah
); (sum
< length
) && (tlvh
!= NULL
);
1398 tlvh
= TLV_HDR_NEXT(tlvh
)) {
1399 switch (ntohs(tlvh
->type
)) {
1400 case RI_SR_TLV_SR_ALGORITHM
:
1401 algo
= (struct ri_sr_tlv_sr_algorithm
*)tlvh
;
1403 case RI_SR_TLV_SRGB_LABEL_RANGE
:
1404 ri_srgb
= (struct ri_sr_tlv_sid_label_range
*)tlvh
;
1406 case RI_SR_TLV_SRLB_LABEL_RANGE
:
1407 ri_srlb
= (struct ri_sr_tlv_sid_label_range
*)tlvh
;
1409 case RI_SR_TLV_NODE_MSD
:
1410 msd
= ((struct ri_sr_tlv_node_msd
*)(tlvh
))->value
;
1415 sum
+= TLV_SIZE(tlvh
);
1418 /* Check if Segment Routing Capabilities has been found */
1419 if (ri_srgb
== NULL
) {
1420 /* Skip Router Information without SR capabilities
1421 * advertise by a non SR Node */
1425 /* Remove SR Node that advertise Router Information
1426 * without SR capabilities. This could correspond to a
1427 * Node stopping Segment Routing */
1428 hash_release(OspfSR
.neighbors
, &(srn
->adv_router
));
1434 /* Check that RI LSA belongs to the correct SR Node */
1435 if ((srn
!= NULL
) && (srn
->instance
!= 0)
1436 && (srn
->instance
!= ntohl(lsah
->id
.s_addr
))) {
1437 flog_err(EC_OSPF_SR_INVALID_LSA_ID
,
1438 "SR (%s): Abort! Wrong LSA ID 4.0.0.%u for SR node %pI4/%u",
1439 __func__
, GET_OPAQUE_ID(ntohl(lsah
->id
.s_addr
)),
1440 &lsah
->adv_router
, srn
->instance
);
1444 /* OK. All things look good. Get SRGB */
1445 srgb
.range_size
= GET_RANGE_SIZE(ntohl(ri_srgb
->size
));
1446 srgb
.lower_bound
= GET_LABEL(ntohl(ri_srgb
->lower
.value
));
1448 /* Check if it is a new SR Node or not */
1450 /* Get a new SR Node in hash table from Router ID */
1451 srn
= (struct sr_node
*)hash_get(OspfSR
.neighbors
,
1453 (void *)sr_node_new
);
1455 srn
->instance
= ntohl(lsah
->id
.s_addr
);
1457 srn
->srgb
.range_size
= srgb
.range_size
;
1458 srn
->srgb
.lower_bound
= srgb
.lower_bound
;
1461 /* Update Algorithm, SRLB and MSD if present */
1464 for (i
= 0; i
< ntohs(algo
->header
.length
); i
++)
1465 srn
->algo
[i
] = algo
->value
[0];
1466 for (; i
< ALGORITHM_COUNT
; i
++)
1467 srn
->algo
[i
] = SR_ALGORITHM_UNSET
;
1469 srn
->algo
[0] = SR_ALGORITHM_SPF
;
1472 if (ri_srlb
!= NULL
) {
1473 srn
->srlb
.range_size
= GET_RANGE_SIZE(ntohl(ri_srlb
->size
));
1474 srn
->srlb
.lower_bound
= GET_LABEL(ntohl(ri_srlb
->lower
.value
));
1477 /* Check if SRGB has changed */
1478 if ((srn
->srgb
.range_size
== srgb
.range_size
)
1479 && (srn
->srgb
.lower_bound
== srgb
.lower_bound
))
1483 srn
->srgb
.range_size
= srgb
.range_size
;
1484 srn
->srgb
.lower_bound
= srgb
.lower_bound
;
1486 osr_debug(" |- Update SR-Node[%pI4], SRGB[%u/%u], SRLB[%u/%u], Algo[%u], MSD[%u]",
1487 &srn
->adv_router
, srn
->srgb
.lower_bound
, srn
->srgb
.range_size
,
1488 srn
->srlb
.lower_bound
, srn
->srlb
.range_size
, srn
->algo
[0],
1491 /* ... and NHLFE if it is a neighbor SR node */
1492 if (srn
->neighbor
== OspfSR
.self
)
1493 hash_iterate(OspfSR
.neighbors
, update_out_nhlfe
, srn
);
1497 * Delete SR Node entry in hash table information corresponding to an expired
1498 * Router Information LSA
1500 void ospf_sr_ri_lsa_delete(struct ospf_lsa
*lsa
)
1502 struct sr_node
*srn
;
1503 struct lsa_header
*lsah
= lsa
->data
;
1505 osr_debug("SR (%s): Remove SR node %pI4 from lsa_id 4.0.0.%u", __func__
,
1506 &lsah
->adv_router
, GET_OPAQUE_ID(ntohl(lsah
->id
.s_addr
)));
1509 if (OspfSR
.neighbors
== NULL
) {
1510 flog_err(EC_OSPF_SR_INVALID_DB
,
1511 "SR (%s): Abort! no valid SR Data Base", __func__
);
1515 /* Release Router ID entry in SRDB hash table */
1516 srn
= hash_release(OspfSR
.neighbors
, &(lsah
->adv_router
));
1520 flog_err(EC_OSPF_SR_NODE_CREATE
,
1521 "SR (%s): Abort! no entry in SRDB for SR Node %pI4",
1522 __func__
, &lsah
->adv_router
);
1526 if ((srn
->instance
!= 0) && (srn
->instance
!= ntohl(lsah
->id
.s_addr
))) {
1528 EC_OSPF_SR_INVALID_LSA_ID
,
1529 "SR (%s): Abort! Wrong LSA ID 4.0.0.%u for SR node %pI4",
1530 __func__
, GET_OPAQUE_ID(ntohl(lsah
->id
.s_addr
)),
1535 /* Remove SR node */
1539 /* Update Segment Routing from Extended Link LSA */
1540 void ospf_sr_ext_link_lsa_update(struct ospf_lsa
*lsa
)
1542 struct sr_node
*srn
;
1543 struct tlv_header
*tlvh
;
1544 struct lsa_header
*lsah
= lsa
->data
;
1545 struct sr_link
*srl
;
1549 osr_debug("SR (%s): Process Extended Link LSA 8.0.0.%u from %pI4",
1550 __func__
, GET_OPAQUE_ID(ntohl(lsah
->id
.s_addr
)),
1554 if (OspfSR
.neighbors
== NULL
) {
1555 flog_err(EC_OSPF_SR_INVALID_DB
,
1556 "SR (%s): Abort! no valid SR DataBase", __func__
);
1560 /* Get SR Node in hash table from Router ID */
1561 srn
= (struct sr_node
*)hash_get(OspfSR
.neighbors
,
1562 (void *)&(lsah
->adv_router
),
1563 (void *)sr_node_new
);
1565 /* Initialize TLV browsing */
1566 length
= lsa
->size
- OSPF_LSA_HEADER_SIZE
;
1567 for (tlvh
= TLV_HDR_TOP(lsah
); length
> 0 && tlvh
;
1568 tlvh
= TLV_HDR_NEXT(tlvh
)) {
1569 if (ntohs(tlvh
->type
) == EXT_TLV_LINK
) {
1570 /* Got Extended Link information */
1571 srl
= get_ext_link_sid(tlvh
, length
);
1572 /* Update SID if not null */
1574 srl
->instance
= ntohl(lsah
->id
.s_addr
);
1575 update_ext_link_sid(srn
, srl
, lsa
->flags
);
1578 length
-= TLV_SIZE(tlvh
);
1582 /* Delete Segment Routing from Extended Link LSA */
1583 void ospf_sr_ext_link_lsa_delete(struct ospf_lsa
*lsa
)
1585 struct listnode
*node
;
1586 struct sr_link
*srl
;
1587 struct sr_node
*srn
;
1588 struct lsa_header
*lsah
= lsa
->data
;
1589 uint32_t instance
= ntohl(lsah
->id
.s_addr
);
1591 osr_debug("SR (%s): Remove Extended Link LSA 8.0.0.%u from %pI4",
1592 __func__
, GET_OPAQUE_ID(ntohl(lsah
->id
.s_addr
)),
1596 if (OspfSR
.neighbors
== NULL
) {
1597 flog_err(EC_OSPF_SR_INVALID_DB
,
1598 "SR (%s): Abort! no valid SR DataBase", __func__
);
1602 /* Search SR Node in hash table from Router ID */
1603 srn
= (struct sr_node
*)hash_lookup(OspfSR
.neighbors
,
1604 (void *)&(lsah
->adv_router
));
1607 * SR-Node may be NULL if it has been remove previously when
1608 * processing Router Information LSA deletion
1611 flog_err(EC_OSPF_SR_INVALID_DB
,
1612 "SR (%s): Stop! no entry in SRDB for SR Node %pI4",
1613 __func__
, &lsah
->adv_router
);
1617 /* Search for corresponding Segment Link */
1618 for (ALL_LIST_ELEMENTS_RO(srn
->ext_link
, node
, srl
))
1619 if (srl
->instance
== instance
)
1622 /* Remove Segment Link if found. Note that for Neighbors, only Global
1623 * Adj/Lan-Adj SID are stored in the SR-DB */
1624 if ((srl
!= NULL
) && (srl
->instance
== instance
)) {
1625 del_adj_sid(srl
->nhlfe
[0]);
1626 del_adj_sid(srl
->nhlfe
[1]);
1627 listnode_delete(srn
->ext_link
, srl
);
1628 XFREE(MTYPE_OSPF_SR_PARAMS
, srl
);
1632 /* Add (LAN)Adjacency-SID from Extended Link Information */
1633 void ospf_sr_ext_itf_add(struct ext_itf
*exti
)
1635 struct sr_node
*srn
= OspfSR
.self
;
1636 struct sr_link
*srl
;
1638 osr_debug("SR (%s): Add Extended Link LSA 8.0.0.%u from self", __func__
,
1645 /* Initialize new Segment Routing Link */
1646 srl
= XCALLOC(MTYPE_OSPF_SR_PARAMS
, sizeof(struct sr_link
));
1648 srl
->adv_router
= srn
->adv_router
;
1649 srl
->itf_addr
= exti
->link
.link_data
;
1651 SET_OPAQUE_LSID(OPAQUE_TYPE_EXTENDED_LINK_LSA
, exti
->instance
);
1652 srl
->remote_id
= exti
->link
.link_id
;
1653 switch (exti
->stype
) {
1655 srl
->type
= ADJ_SID
;
1656 /* Primary information */
1657 srl
->flags
[0] = exti
->adj_sid
[0].flags
;
1658 if (CHECK_FLAG(exti
->adj_sid
[0].flags
,
1659 EXT_SUBTLV_LINK_ADJ_SID_VFLG
))
1660 srl
->sid
[0] = GET_LABEL(ntohl(exti
->adj_sid
[0].value
));
1662 srl
->sid
[0] = ntohl(exti
->adj_sid
[0].value
);
1663 if (exti
->rmt_itf_addr
.header
.type
== 0)
1664 srl
->nhlfe
[0].nexthop
= exti
->link
.link_id
;
1666 srl
->nhlfe
[0].nexthop
= exti
->rmt_itf_addr
.value
;
1667 /* Backup Information if set */
1668 if (exti
->adj_sid
[1].header
.type
== 0)
1670 srl
->flags
[1] = exti
->adj_sid
[1].flags
;
1671 if (CHECK_FLAG(exti
->adj_sid
[1].flags
,
1672 EXT_SUBTLV_LINK_ADJ_SID_VFLG
))
1673 srl
->sid
[1] = GET_LABEL(ntohl(exti
->adj_sid
[1].value
));
1675 srl
->sid
[1] = ntohl(exti
->adj_sid
[1].value
);
1676 if (exti
->rmt_itf_addr
.header
.type
== 0)
1677 srl
->nhlfe
[1].nexthop
= exti
->link
.link_id
;
1679 srl
->nhlfe
[1].nexthop
= exti
->rmt_itf_addr
.value
;
1682 srl
->type
= LAN_ADJ_SID
;
1683 /* Primary information */
1684 srl
->flags
[0] = exti
->lan_sid
[0].flags
;
1685 if (CHECK_FLAG(exti
->lan_sid
[0].flags
,
1686 EXT_SUBTLV_LINK_ADJ_SID_VFLG
))
1687 srl
->sid
[0] = GET_LABEL(ntohl(exti
->lan_sid
[0].value
));
1689 srl
->sid
[0] = ntohl(exti
->lan_sid
[0].value
);
1690 if (exti
->rmt_itf_addr
.header
.type
== 0)
1691 srl
->nhlfe
[0].nexthop
= exti
->lan_sid
[0].neighbor_id
;
1693 srl
->nhlfe
[0].nexthop
= exti
->rmt_itf_addr
.value
;
1694 /* Backup Information if set */
1695 if (exti
->lan_sid
[1].header
.type
== 0)
1697 srl
->flags
[1] = exti
->lan_sid
[1].flags
;
1698 if (CHECK_FLAG(exti
->lan_sid
[1].flags
,
1699 EXT_SUBTLV_LINK_ADJ_SID_VFLG
))
1700 srl
->sid
[1] = GET_LABEL(ntohl(exti
->lan_sid
[1].value
));
1702 srl
->sid
[1] = ntohl(exti
->lan_sid
[1].value
);
1703 if (exti
->rmt_itf_addr
.header
.type
== 0)
1704 srl
->nhlfe
[1].nexthop
= exti
->lan_sid
[1].neighbor_id
;
1706 srl
->nhlfe
[1].nexthop
= exti
->rmt_itf_addr
.value
;
1710 /* Wrong SID Type. Abort! */
1711 XFREE(MTYPE_OSPF_SR_PARAMS
, srl
);
1715 /* Segment Routing Link is ready, update it */
1716 update_ext_link_sid(srn
, srl
, OSPF_LSA_SELF
);
1719 /* Delete Prefix or (LAN)Adjacency-SID from Extended Link Information */
1720 void ospf_sr_ext_itf_delete(struct ext_itf
*exti
)
1722 struct listnode
*node
;
1723 struct sr_node
*srn
= OspfSR
.self
;
1724 struct sr_prefix
*srp
= NULL
;
1725 struct sr_link
*srl
= NULL
;
1728 osr_debug("SR (%s): Remove Extended LSA %u.0.0.%u from self",
1729 __func__
, exti
->stype
== PREF_SID
? 7 : 8, exti
->instance
);
1731 /* Sanity check: SR-Node and Extended Prefix/Link list may have been
1732 * removed earlier when stopping OSPF or OSPF-SR */
1733 if (srn
== NULL
|| srn
->ext_prefix
== NULL
|| srn
->ext_link
== NULL
)
1736 if (exti
->stype
== PREF_SID
) {
1737 instance
= SET_OPAQUE_LSID(OPAQUE_TYPE_EXTENDED_PREFIX_LSA
,
1739 for (ALL_LIST_ELEMENTS_RO(srn
->ext_prefix
, node
, srp
))
1740 if (srp
->instance
== instance
)
1743 /* Uninstall Segment Prefix SID if found */
1744 if ((srp
!= NULL
) && (srp
->instance
== instance
))
1745 ospf_zebra_delete_prefix_sid(srp
);
1747 /* Search for corresponding Segment Link for self SR-Node */
1748 instance
= SET_OPAQUE_LSID(OPAQUE_TYPE_EXTENDED_LINK_LSA
,
1750 for (ALL_LIST_ELEMENTS_RO(srn
->ext_link
, node
, srl
))
1751 if (srl
->instance
== instance
)
1754 /* Remove Segment Link if found */
1755 if ((srl
!= NULL
) && (srl
->instance
== instance
)) {
1756 del_adj_sid(srl
->nhlfe
[0]);
1757 del_adj_sid(srl
->nhlfe
[1]);
1758 listnode_delete(srn
->ext_link
, srl
);
1759 XFREE(MTYPE_OSPF_SR_PARAMS
, srl
);
1764 /* Update Segment Routing from Extended Prefix LSA */
1765 void ospf_sr_ext_prefix_lsa_update(struct ospf_lsa
*lsa
)
1767 struct sr_node
*srn
;
1768 struct tlv_header
*tlvh
;
1769 struct lsa_header
*lsah
= (struct lsa_header
*)lsa
->data
;
1770 struct sr_prefix
*srp
;
1774 osr_debug("SR (%s): Process Extended Prefix LSA 7.0.0.%u from %pI4",
1775 __func__
, GET_OPAQUE_ID(ntohl(lsah
->id
.s_addr
)),
1779 if (OspfSR
.neighbors
== NULL
) {
1780 flog_err(EC_OSPF_SR_INVALID_DB
,
1781 "SR (%s): Abort! no valid SR DataBase", __func__
);
1785 /* Get SR Node in hash table from Router ID */
1786 srn
= (struct sr_node
*)hash_get(OspfSR
.neighbors
,
1787 (void *)&(lsah
->adv_router
),
1788 (void *)sr_node_new
);
1789 /* Initialize TLV browsing */
1790 length
= lsa
->size
- OSPF_LSA_HEADER_SIZE
;
1791 for (tlvh
= TLV_HDR_TOP(lsah
); length
> 0 && tlvh
;
1792 tlvh
= TLV_HDR_NEXT(tlvh
)) {
1793 if (ntohs(tlvh
->type
) == EXT_TLV_LINK
) {
1794 /* Got Extended Link information */
1795 srp
= get_ext_prefix_sid(tlvh
, length
);
1796 /* Update SID if not null */
1798 srp
->instance
= ntohl(lsah
->id
.s_addr
);
1799 update_ext_prefix_sid(srn
, srp
);
1802 length
-= TLV_SIZE(tlvh
);
1806 /* Delete Segment Routing from Extended Prefix LSA */
1807 void ospf_sr_ext_prefix_lsa_delete(struct ospf_lsa
*lsa
)
1809 struct listnode
*node
;
1810 struct sr_prefix
*srp
;
1811 struct sr_node
*srn
;
1812 struct lsa_header
*lsah
= (struct lsa_header
*)lsa
->data
;
1813 uint32_t instance
= ntohl(lsah
->id
.s_addr
);
1815 osr_debug("SR (%s): Remove Extended Prefix LSA 7.0.0.%u from %pI4",
1816 __func__
, GET_OPAQUE_ID(ntohl(lsah
->id
.s_addr
)),
1820 if (OspfSR
.neighbors
== NULL
) {
1821 flog_err(EC_OSPF_SR_INVALID_DB
,
1822 "SR (%s): Abort! no valid SR DataBase", __func__
);
1826 /* Search SR Node in hash table from Router ID */
1827 srn
= (struct sr_node
*)hash_lookup(OspfSR
.neighbors
,
1828 (void *)&(lsah
->adv_router
));
1831 * SR-Node may be NULL if it has been remove previously when
1832 * processing Router Information LSA deletion
1835 flog_err(EC_OSPF_SR_INVALID_DB
,
1836 "SR (%s): Stop! no entry in SRDB for SR Node %pI4",
1837 __func__
, &lsah
->adv_router
);
1841 /* Search for corresponding Segment Prefix */
1842 for (ALL_LIST_ELEMENTS_RO(srn
->ext_prefix
, node
, srp
))
1843 if (srp
->instance
== instance
)
1846 /* Remove Prefix if found */
1847 if ((srp
!= NULL
) && (srp
->instance
== instance
)) {
1848 ospf_zebra_delete_prefix_sid(srp
);
1849 listnode_delete(srn
->ext_prefix
, srp
);
1850 XFREE(MTYPE_OSPF_SR_PARAMS
, srp
);
1853 EC_OSPF_SR_INVALID_DB
,
1854 "SR (%s): Didn't found corresponding SR Prefix 7.0.0.%u for SR Node %pI4",
1855 __func__
, GET_OPAQUE_ID(ntohl(lsah
->id
.s_addr
)),
1861 * Update Prefix SID. Call by ospf_ext_pref_ism_change to
1862 * complete initial CLI command at startup.
1864 * @param ifp - Loopback interface
1865 * @param pref - Prefix address of this interface
1869 void ospf_sr_update_local_prefix(struct interface
*ifp
, struct prefix
*p
)
1871 struct listnode
*node
;
1872 struct sr_prefix
*srp
;
1875 if ((ifp
== NULL
) || (p
== NULL
))
1879 * Search if there is a Segment Prefix that correspond to this
1880 * interface or prefix, and update it if found
1882 for (ALL_LIST_ELEMENTS_RO(OspfSR
.self
->ext_prefix
, node
, srp
)) {
1883 if ((srp
->nhlfe
.ifindex
== ifp
->ifindex
)
1884 || ((IPV4_ADDR_SAME(&srp
->prefv4
.prefix
, &p
->u
.prefix4
))
1885 && (srp
->prefv4
.prefixlen
== p
->prefixlen
))) {
1887 /* Update Interface & Prefix info */
1888 srp
->nhlfe
.ifindex
= ifp
->ifindex
;
1889 IPV4_ADDR_COPY(&srp
->prefv4
.prefix
, &p
->u
.prefix4
);
1890 srp
->prefv4
.prefixlen
= p
->prefixlen
;
1891 srp
->prefv4
.family
= p
->family
;
1892 IPV4_ADDR_COPY(&srp
->nhlfe
.nexthop
, &p
->u
.prefix4
);
1894 /* OK. Let's Schedule Extended Prefix LSA */
1895 srp
->instance
= ospf_ext_schedule_prefix_index(
1896 ifp
, srp
->sid
, &srp
->prefv4
, srp
->flags
);
1899 " |- Update Node SID %pFX - %u for self SR Node",
1900 (struct prefix
*)&srp
->prefv4
, srp
->sid
);
1902 /* Install SID if NO-PHP is set and not EXPLICIT-NULL */
1903 if (CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_NPFLG
)
1904 && !CHECK_FLAG(srp
->flags
,
1905 EXT_SUBTLV_PREFIX_SID_EFLG
)) {
1906 srp
->label_in
= index2label(srp
->sid
,
1908 srp
->nhlfe
.label_out
= MPLS_LABEL_IMPLICIT_NULL
;
1909 ospf_zebra_update_prefix_sid(srp
);
1916 * Following functions are used to update MPLS LFIB after a SPF run
1919 static void ospf_sr_nhlfe_update(struct hash_bucket
*bucket
, void *args
)
1922 struct sr_node
*srn
= (struct sr_node
*)bucket
->data
;
1923 struct listnode
*node
;
1924 struct sr_prefix
*srp
;
1928 osr_debug(" |- Update Prefix for SR Node %pI4", &srn
->adv_router
);
1930 /* Skip Self SR Node */
1931 if (srn
== OspfSR
.self
)
1934 /* Update Extended Prefix */
1935 for (ALL_LIST_ELEMENTS_RO(srn
->ext_prefix
, node
, srp
)) {
1937 /* Keep track of valid route */
1938 old
= srp
->route
!= NULL
;
1940 /* Compute the new NHLFE */
1941 rc
= compute_prefix_nhlfe(srp
);
1943 /* Check computation result */
1945 /* Routes are not know, remove old NHLFE if any to avoid loop */
1948 ospf_zebra_delete_prefix_sid(srp
);
1950 /* Routes exist but are not ready, skip it */
1953 /* There is at least one route, update NHLFE */
1955 ospf_zebra_update_prefix_sid(srp
);
1963 void ospf_sr_update_task(struct ospf
*ospf
)
1966 struct timeval start_time
, stop_time
;
1968 /* Check ospf and SR status */
1969 if ((ospf
== NULL
) || (OspfSR
.status
!= SR_UP
))
1972 monotime(&start_time
);
1974 osr_debug("SR (%s): Start SPF update", __func__
);
1976 hash_iterate(OspfSR
.neighbors
, (void (*)(struct hash_bucket
*,
1977 void *))ospf_sr_nhlfe_update
,
1980 monotime(&stop_time
);
1982 osr_debug("SR (%s): SPF Processing Time(usecs): %lld", __func__
,
1983 (stop_time
.tv_sec
- start_time
.tv_sec
) * 1000000LL
1984 + (stop_time
.tv_usec
- start_time
.tv_usec
));
1988 * --------------------------------------
1989 * Following are vty command functions.
1990 * --------------------------------------
1994 * Segment Routing Router configuration
1996 * Must be centralize as it concerns both Extended Link/Prefix LSA
1997 * and Router Information LSA. Choose to call it from Extended Prefix
1998 * write_config() call back.
2000 * @param vty VTY output
2004 void ospf_sr_config_write_router(struct vty
*vty
)
2006 struct listnode
*node
;
2007 struct sr_prefix
*srp
;
2010 if (OspfSR
.status
== SR_UP
)
2011 vty_out(vty
, " segment-routing on\n");
2013 upper
= OspfSR
.srgb
.start
+ OspfSR
.srgb
.size
- 1;
2014 if ((OspfSR
.srgb
.start
!= DEFAULT_SRGB_LABEL
)
2015 || (OspfSR
.srgb
.size
!= DEFAULT_SRGB_SIZE
))
2016 vty_out(vty
, " segment-routing global-block %u %u",
2017 OspfSR
.srgb
.start
, upper
);
2019 if ((OspfSR
.srlb
.start
!= DEFAULT_SRLB_LABEL
) ||
2020 (OspfSR
.srlb
.end
!= DEFAULT_SRLB_END
)) {
2021 if ((OspfSR
.srgb
.start
== DEFAULT_SRGB_LABEL
) &&
2022 (OspfSR
.srgb
.size
== DEFAULT_SRGB_SIZE
))
2023 vty_out(vty
, " segment-routing global-block %u %u",
2024 OspfSR
.srgb
.start
, upper
);
2025 vty_out(vty
, " local-block %u %u\n", OspfSR
.srlb
.start
,
2030 if (OspfSR
.msd
!= 0)
2031 vty_out(vty
, " segment-routing node-msd %u\n", OspfSR
.msd
);
2033 if (OspfSR
.self
!= NULL
) {
2034 for (ALL_LIST_ELEMENTS_RO(OspfSR
.self
->ext_prefix
, node
, srp
)) {
2035 vty_out(vty
, " segment-routing prefix %pFX index %u",
2036 &srp
->prefv4
, srp
->sid
);
2037 if (CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_EFLG
))
2038 vty_out(vty
, " explicit-null\n");
2039 else if (CHECK_FLAG(srp
->flags
,
2040 EXT_SUBTLV_PREFIX_SID_NPFLG
))
2041 vty_out(vty
, " no-php-flag\n");
2048 DEFUN(ospf_sr_enable
,
2050 "segment-routing on",
2052 "Enable Segment Routing\n")
2055 VTY_DECLVAR_INSTANCE_CONTEXT(ospf
, ospf
);
2057 if (OspfSR
.status
!= SR_OFF
)
2060 if (ospf
->vrf_id
!= VRF_DEFAULT
) {
2062 "Segment Routing is only supported in default VRF\n");
2063 return CMD_WARNING_CONFIG_FAILED
;
2066 osr_debug("SR: Segment Routing: OFF -> ON");
2068 /* Start Segment Routing */
2069 OspfSR
.status
= SR_ON
;
2070 ospf_sr_start(ospf
);
2075 DEFUN (no_ospf_sr_enable
,
2076 no_ospf_sr_enable_cmd
,
2077 "no segment-routing [on]",
2080 "Disable Segment Routing\n")
2083 if (OspfSR
.status
== SR_OFF
)
2086 osr_debug("SR: Segment Routing: ON -> OFF");
2088 /* Start by Disabling Extended Link & Prefix LSA */
2089 ospf_ext_update_sr(false);
2091 /* then, disable Router Information SR parameters */
2092 ospf_router_info_update_sr(false, OspfSR
.self
);
2094 /* Finally, stop Segment Routing */
2100 static int ospf_sr_enabled(struct vty
*vty
)
2102 if (OspfSR
.status
!= SR_OFF
)
2106 vty_out(vty
, "%% OSPF SR is not turned on\n");
2111 /* tell if two ranges [r1_lower, r1_upper] and [r2_lower,r2_upper] overlap */
2112 static bool ranges_overlap(uint32_t r1_lower
, uint32_t r1_upper
,
2113 uint32_t r2_lower
, uint32_t r2_upper
)
2115 return !((r1_upper
< r2_lower
) || (r1_lower
> r2_upper
));
2119 /* tell if a range is valid */
2120 static bool sr_range_is_valid(uint32_t lower
, uint32_t upper
, uint32_t min_size
)
2122 return (upper
>= lower
+ min_size
);
2126 * Update SRGB and/or SRLB using new CLI values.
2128 * @param gb_lower Lower bound of the SRGB
2129 * @param gb_upper Upper bound of the SRGB
2130 * @param lb_lower Lower bound of the SRLB
2131 * @param lb_upper Upper bound of the SRLB
2133 * @return 0 on success, -1 otherwise
2135 static int update_sr_blocks(uint32_t gb_lower
, uint32_t gb_upper
,
2136 uint32_t lb_lower
, uint32_t lb_upper
)
2139 /* Check if values have changed */
2140 bool gb_changed
, lb_changed
;
2141 uint32_t gb_size
= gb_upper
- gb_lower
+ 1;
2142 uint32_t lb_size
= lb_upper
- lb_lower
+ 1;
2145 (OspfSR
.srgb
.size
!= gb_size
|| OspfSR
.srgb
.start
!= gb_lower
);
2147 (OspfSR
.srlb
.end
!= lb_upper
|| OspfSR
.srlb
.start
!= lb_lower
);
2148 if (!gb_changed
&& !lb_changed
)
2151 /* Check if SR is correctly started i.e. Label Manager connected */
2152 if (OspfSR
.status
!= SR_UP
) {
2153 OspfSR
.srgb
.size
= gb_size
;
2154 OspfSR
.srgb
.start
= gb_lower
;
2155 OspfSR
.srlb
.end
= lb_upper
;
2156 OspfSR
.srlb
.start
= lb_lower
;
2160 /* Release old SRGB if it has changed and is active. */
2163 sr_global_block_delete();
2165 /* Set new SRGB values - but do not reserve yet (we need to
2166 * release the SRLB too) */
2167 OspfSR
.srgb
.size
= gb_size
;
2168 OspfSR
.srgb
.start
= gb_lower
;
2169 if (OspfSR
.self
!= NULL
) {
2170 OspfSR
.self
->srgb
.range_size
= gb_size
;
2171 OspfSR
.self
->srgb
.lower_bound
= gb_lower
;
2174 /* Release old SRLB if it has changed and reserve new block as needed.
2178 sr_local_block_delete();
2180 /* Set new SRLB values */
2181 if (sr_local_block_init(lb_lower
, lb_upper
) < 0) {
2185 if (OspfSR
.self
!= NULL
) {
2186 OspfSR
.self
->srlb
.lower_bound
= lb_lower
;
2187 OspfSR
.self
->srlb
.range_size
= lb_size
;
2192 * Try to reserve the new SRGB from the Label Manger. If the
2193 * allocation fails, disable SR until new blocks are successfully
2197 if (sr_global_block_init(OspfSR
.srgb
.start
, OspfSR
.srgb
.size
)
2204 /* Update Self SR-Node */
2205 if (OspfSR
.self
!= NULL
) {
2206 /* SRGB is reserved, set Router Information parameters */
2207 ospf_router_info_update_sr(true, OspfSR
.self
);
2209 /* and update NHLFE entries */
2211 hash_iterate(OspfSR
.neighbors
,
2212 (void (*)(struct hash_bucket
*,
2213 void *))update_in_nhlfe
,
2216 /* and update (LAN)-Adjacency SID */
2218 ospf_ext_link_srlb_update();
2224 DEFUN(sr_global_label_range
, sr_global_label_range_cmd
,
2225 "segment-routing global-block (16-1048575) (16-1048575) [local-block (16-1048575) (16-1048575)]",
2227 "Segment Routing Global Block label range\n"
2228 "Lower-bound range in decimal (16-1048575)\n"
2229 "Upper-bound range in decimal (16-1048575)\n"
2230 "Segment Routing Local Block label range\n"
2231 "Lower-bound range in decimal (16-1048575)\n"
2232 "Upper-bound range in decimal (16-1048575)\n")
2234 uint32_t lb_upper
, lb_lower
;
2235 uint32_t gb_upper
, gb_lower
;
2236 int idx_gb_low
= 2, idx_gb_up
= 3;
2237 int idx_lb_low
= 5, idx_lb_up
= 6;
2239 /* Get lower and upper bound for mandatory global-block */
2240 gb_lower
= strtoul(argv
[idx_gb_low
]->arg
, NULL
, 10);
2241 gb_upper
= strtoul(argv
[idx_gb_up
]->arg
, NULL
, 10);
2243 /* SRLB values are taken from vtysh if there, else use the known ones */
2244 lb_upper
= argc
> idx_lb_up
? strtoul(argv
[idx_lb_up
]->arg
, NULL
, 10)
2246 lb_lower
= argc
> idx_lb_low
? strtoul(argv
[idx_lb_low
]->arg
, NULL
, 10)
2247 : OspfSR
.srlb
.start
;
2249 /* check correctness of input SRGB */
2250 if (!sr_range_is_valid(gb_lower
, gb_upper
, MIN_SRGB_SIZE
)) {
2251 vty_out(vty
, "Invalid SRGB range\n");
2252 return CMD_WARNING_CONFIG_FAILED
;
2255 /* check correctness of SRLB */
2256 if (!sr_range_is_valid(lb_lower
, lb_upper
, MIN_SRLB_SIZE
)) {
2257 vty_out(vty
, "Invalid SRLB range\n");
2258 return CMD_WARNING_CONFIG_FAILED
;
2261 /* Validate SRGB against SRLB */
2262 if (ranges_overlap(gb_lower
, gb_upper
, lb_lower
, lb_upper
)) {
2264 "New SR Global Block (%u/%u) conflicts with Local Block (%u/%u)\n",
2265 gb_lower
, gb_upper
, lb_lower
, lb_upper
);
2266 return CMD_WARNING_CONFIG_FAILED
;
2269 if (update_sr_blocks(gb_lower
, gb_upper
, lb_lower
, lb_upper
) < 0)
2270 return CMD_WARNING_CONFIG_FAILED
;
2275 DEFUN(no_sr_global_label_range
, no_sr_global_label_range_cmd
,
2276 "no segment-routing global-block [(16-1048575) (16-1048575) local-block (16-1048575) (16-1048575)]",
2278 "Segment Routing Global Block label range\n"
2279 "Lower-bound range in decimal (16-1048575)\n"
2280 "Upper-bound range in decimal (16-1048575)\n"
2281 "Segment Routing Local Block label range\n"
2282 "Lower-bound range in decimal (16-1048575)\n"
2283 "Upper-bound range in decimal (16-1048575)\n")
2285 if (update_sr_blocks(DEFAULT_SRGB_LABEL
, DEFAULT_SRGB_END
,
2286 DEFAULT_SRLB_LABEL
, DEFAULT_SRLB_END
)
2288 return CMD_WARNING_CONFIG_FAILED
;
2295 "segment-routing node-msd (1-16)",
2297 "Maximum Stack Depth for this router\n"
2298 "Maximum number of label that could be stack (1-16)\n")
2303 if (!ospf_sr_enabled(vty
))
2304 return CMD_WARNING_CONFIG_FAILED
;
2307 argv_find(argv
, argc
, "(1-16)", &idx
);
2308 msd
= strtoul(argv
[idx
]->arg
, NULL
, 10);
2309 if (msd
< 1 || msd
> MPLS_MAX_LABELS
) {
2310 vty_out(vty
, "MSD must be comprise between 1 and %u\n",
2312 return CMD_WARNING_CONFIG_FAILED
;
2315 /* Check if value has changed */
2316 if (OspfSR
.msd
== msd
)
2319 /* Set this router MSD */
2321 if (OspfSR
.self
!= NULL
) {
2322 OspfSR
.self
->msd
= msd
;
2324 /* Set Router Information parameters if SR is UP */
2325 if (OspfSR
.status
== SR_UP
)
2326 ospf_router_info_update_sr(true, OspfSR
.self
);
2332 DEFUN (no_sr_node_msd
,
2334 "no segment-routing node-msd [(1-16)]",
2337 "Maximum Stack Depth for this router\n"
2338 "Maximum number of label that could be stack (1-16)\n")
2341 if (!ospf_sr_enabled(vty
))
2342 return CMD_WARNING_CONFIG_FAILED
;
2344 /* unset this router MSD */
2346 if (OspfSR
.self
!= NULL
) {
2347 OspfSR
.self
->msd
= 0;
2349 /* Set Router Information parameters if SR is UP */
2350 if (OspfSR
.status
== SR_UP
)
2351 ospf_router_info_update_sr(true, OspfSR
.self
);
2357 DEFUN (sr_prefix_sid
,
2359 "segment-routing prefix A.B.C.D/M index (0-65535) [no-php-flag|explicit-null]",
2362 "IPv4 Prefix as A.B.C.D/M\n"
2363 "SID index for this prefix in decimal (0-65535)\n"
2364 "Index value inside SRGB (lower_bound < index < upper_bound)\n"
2365 "Don't request Penultimate Hop Popping (PHP)\n"
2366 "Upstream neighbor must replace prefix-sid with explicit null label\n")
2369 struct prefix p
, pexist
;
2371 struct listnode
*node
;
2372 struct sr_prefix
*srp
, *exist
= NULL
;
2373 struct interface
*ifp
;
2374 bool no_php_flag
= false;
2375 bool exp_null
= false;
2376 bool index_in_use
= false;
2377 uint8_t desired_flags
= 0;
2379 if (!ospf_sr_enabled(vty
))
2380 return CMD_WARNING_CONFIG_FAILED
;
2382 /* Get network prefix */
2383 argv_find(argv
, argc
, "A.B.C.D/M", &idx
);
2384 if (!str2prefix(argv
[idx
]->arg
, &p
)) {
2385 vty_out(vty
, "Invalid prefix format %s\n", argv
[idx
]->arg
);
2386 return CMD_WARNING_CONFIG_FAILED
;
2389 /* Get & verify index value */
2390 argv_find(argv
, argc
, "(0-65535)", &idx
);
2391 index
= strtoul(argv
[idx
]->arg
, NULL
, 10);
2392 if (index
> OspfSR
.srgb
.size
- 1) {
2393 vty_out(vty
, "Index %u must be lower than range size %u\n",
2394 index
, OspfSR
.srgb
.size
);
2395 return CMD_WARNING_CONFIG_FAILED
;
2399 no_php_flag
= argv_find(argv
, argc
, "no-php-flag", &idx
);
2400 exp_null
= argv_find(argv
, argc
, "explicit-null", &idx
);
2402 desired_flags
|= no_php_flag
? EXT_SUBTLV_PREFIX_SID_NPFLG
: 0;
2403 desired_flags
|= exp_null
? EXT_SUBTLV_PREFIX_SID_NPFLG
: 0;
2404 desired_flags
|= exp_null
? EXT_SUBTLV_PREFIX_SID_EFLG
: 0;
2406 /* Search for an existing Prefix-SID */
2407 for (ALL_LIST_ELEMENTS_RO(OspfSR
.self
->ext_prefix
, node
, srp
)) {
2408 if (prefix_same((struct prefix
*)&srp
->prefv4
, &p
))
2410 if (srp
->sid
== index
) {
2411 index_in_use
= true;
2416 /* done if prefix segment already there with same index and flags */
2417 if (exist
&& exist
->sid
== index
&& exist
->flags
== desired_flags
)
2420 /* deny if index is already in use by a distinct prefix */
2421 if (!exist
&& index_in_use
) {
2422 vty_out(vty
, "Index %u is already used by %pFX\n", index
,
2424 return CMD_WARNING_CONFIG_FAILED
;
2427 /* First, remove old NHLFE if installed */
2428 if (exist
&& CHECK_FLAG(exist
->flags
, EXT_SUBTLV_PREFIX_SID_NPFLG
)
2429 && !CHECK_FLAG(exist
->flags
, EXT_SUBTLV_PREFIX_SID_EFLG
))
2430 ospf_zebra_delete_prefix_sid(exist
);
2432 /* Create new Extended Prefix to SRDB if not found */
2433 if (exist
== NULL
) {
2434 srp
= XCALLOC(MTYPE_OSPF_SR_PARAMS
, sizeof(struct sr_prefix
));
2435 IPV4_ADDR_COPY(&srp
->prefv4
.prefix
, &p
.u
.prefix4
);
2436 srp
->prefv4
.prefixlen
= p
.prefixlen
;
2437 srp
->prefv4
.family
= p
.family
;
2439 srp
->type
= LOCAL_SID
;
2441 /* we work on the existing SR prefix */
2445 /* Reset labels to handle flag update */
2447 srp
->nhlfe
.label_out
= 0;
2449 srp
->flags
= desired_flags
;
2451 /* If NO PHP flag is present, compute NHLFE and set label */
2453 srp
->label_in
= index2label(srp
->sid
, OspfSR
.self
->srgb
);
2454 srp
->nhlfe
.label_out
= MPLS_LABEL_IMPLICIT_NULL
;
2457 osr_debug("SR (%s): Add new index %u to Prefix %pFX", __func__
, index
,
2458 (struct prefix
*)&srp
->prefv4
);
2460 /* Get Interface and check if it is a Loopback */
2461 ifp
= if_lookup_prefix(&p
, VRF_DEFAULT
);
2464 * Interface could be not yet available i.e. when this
2465 * command is in the configuration file, OSPF is not yet
2466 * ready. In this case, store the prefix SID for latter
2467 * update of this Extended Prefix
2470 listnode_add(OspfSR
.self
->ext_prefix
, srp
);
2472 "Interface for prefix %pFX not found. Deferred LSA flooding",
2477 if (!if_is_loopback(ifp
)) {
2478 vty_out(vty
, "interface %s is not a Loopback\n", ifp
->name
);
2479 XFREE(MTYPE_OSPF_SR_PARAMS
, srp
);
2480 return CMD_WARNING_CONFIG_FAILED
;
2482 srp
->nhlfe
.ifindex
= ifp
->ifindex
;
2484 /* Add SR Prefix if new */
2486 listnode_add(OspfSR
.self
->ext_prefix
, srp
);
2488 /* Update Prefix SID if SR is UP */
2489 if (OspfSR
.status
== SR_UP
) {
2490 if (no_php_flag
&& !exp_null
)
2491 ospf_zebra_update_prefix_sid(srp
);
2495 /* Finally, update Extended Prefix LSA id SR is UP */
2496 srp
->instance
= ospf_ext_schedule_prefix_index(
2497 ifp
, srp
->sid
, &srp
->prefv4
, srp
->flags
);
2498 if (srp
->instance
== 0) {
2499 vty_out(vty
, "Unable to set index %u for prefix %pFX\n",
2507 DEFUN (no_sr_prefix_sid
,
2508 no_sr_prefix_sid_cmd
,
2509 "no segment-routing prefix A.B.C.D/M [index (0-65535)|no-php-flag|explicit-null]",
2513 "IPv4 Prefix as A.B.C.D/M\n"
2514 "SID index for this prefix in decimal (0-65535)\n"
2515 "Index value inside SRGB (lower_bound < index < upper_bound)\n"
2516 "Don't request Penultimate Hop Popping (PHP)\n"
2517 "Upstream neighbor must replace prefix-sid with explicit null label\n")
2521 struct listnode
*node
;
2522 struct sr_prefix
*srp
;
2523 struct interface
*ifp
;
2527 if (!ospf_sr_enabled(vty
))
2528 return CMD_WARNING_CONFIG_FAILED
;
2530 if (OspfSR
.status
!= SR_UP
)
2533 /* Get network prefix */
2534 argv_find(argv
, argc
, "A.B.C.D/M", &idx
);
2535 rc
= str2prefix(argv
[idx
]->arg
, &p
);
2537 vty_out(vty
, "Invalid prefix format %s\n", argv
[idx
]->arg
);
2538 return CMD_WARNING_CONFIG_FAILED
;
2541 /* check that the prefix is already set */
2542 for (ALL_LIST_ELEMENTS_RO(OspfSR
.self
->ext_prefix
, node
, srp
))
2543 if (IPV4_ADDR_SAME(&srp
->prefv4
.prefix
, &p
.u
.prefix4
)
2544 && (srp
->prefv4
.prefixlen
== p
.prefixlen
)) {
2550 vty_out(vty
, "Prefix %s is not found. Abort!\n",
2552 return CMD_WARNING_CONFIG_FAILED
;
2555 osr_debug("SR (%s): Remove Prefix %pFX with index %u", __func__
,
2556 (struct prefix
*)&srp
->prefv4
, srp
->sid
);
2559 ifp
= if_lookup_by_index(srp
->nhlfe
.ifindex
, VRF_DEFAULT
);
2561 vty_out(vty
, "interface for prefix %s not found.\n",
2563 /* silently remove from list */
2564 listnode_delete(OspfSR
.self
->ext_prefix
, srp
);
2565 XFREE(MTYPE_OSPF_SR_PARAMS
, srp
);
2569 /* Update Extended Prefix LSA */
2570 if (!ospf_ext_schedule_prefix_index(ifp
, 0, NULL
, 0)) {
2571 vty_out(vty
, "No corresponding loopback interface. Abort!\n");
2575 /* Delete NHLFE if NO-PHP is set and EXPLICIT NULL not set */
2576 if (CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_NPFLG
)
2577 && !CHECK_FLAG(srp
->flags
, EXT_SUBTLV_PREFIX_SID_EFLG
))
2578 ospf_zebra_delete_prefix_sid(srp
);
2580 /* OK, all is clean, remove SRP from SRDB */
2581 listnode_delete(OspfSR
.self
->ext_prefix
, srp
);
2582 XFREE(MTYPE_OSPF_SR_PARAMS
, srp
);
2588 static char *sr_op2str(char *buf
, size_t size
, mpls_label_t label_in
,
2589 mpls_label_t label_out
)
2594 switch (label_out
) {
2595 case MPLS_LABEL_IMPLICIT_NULL
:
2596 snprintf(buf
, size
, "Pop(%u)", label_in
);
2598 case MPLS_LABEL_IPV4_EXPLICIT_NULL
:
2599 if (label_in
== MPLS_LABEL_IPV4_EXPLICIT_NULL
)
2600 snprintf(buf
, size
, "no-op.");
2602 snprintf(buf
, size
, "Swap(%u, null)", label_in
);
2604 case MPLS_INVALID_LABEL
:
2605 snprintf(buf
, size
, "no-op.");
2608 snprintf(buf
, size
, "Swap(%u, %u)", label_in
, label_out
);
2614 static void show_sr_prefix(struct sbuf
*sbuf
, struct json_object
*json
,
2615 struct sr_prefix
*srp
)
2618 struct listnode
*node
;
2619 struct ospf_path
*path
;
2620 struct interface
*itf
;
2621 json_object
*json_route
= NULL
, *json_obj
;
2625 char buf
[PREFIX_STRLEN
];
2628 snprintfrr(pref
, 19, "%pFX", (struct prefix
*)&srp
->prefv4
);
2629 snprintf(sid
, 22, "SR Pfx (idx %u)", srp
->sid
);
2631 json_object_string_add(json
, "prefix", pref
);
2632 json_object_int_add(json
, "sid", srp
->sid
);
2633 json_object_int_add(json
, "inputLabel", srp
->label_in
);
2635 sbuf_push(sbuf
, 0, "%18s %21s ", pref
, sid
);
2638 /* Check if it is a Local Node SID */
2639 if (srp
->type
== LOCAL_SID
) {
2640 itf
= if_lookup_by_index(srp
->nhlfe
.ifindex
, VRF_DEFAULT
);
2643 json_route
= json_object_new_array();
2644 json_object_object_add(json
, "prefixRoute",
2647 json_obj
= json_object_new_object();
2648 json_object_int_add(json_obj
, "outputLabel",
2649 srp
->nhlfe
.label_out
);
2650 json_object_string_add(json_obj
, "interface",
2651 itf
? itf
->name
: "-");
2652 json_object_string_addf(json_obj
, "nexthop", "%pI4",
2653 &srp
->nhlfe
.nexthop
);
2654 json_object_array_add(json_route
, json_obj
);
2656 sbuf_push(sbuf
, 0, "%20s %9s %15s\n",
2657 sr_op2str(op
, 32, srp
->label_in
,
2658 srp
->nhlfe
.label_out
),
2659 itf
? itf
->name
: "-",
2660 inet_ntop(AF_INET
, &srp
->nhlfe
.nexthop
,
2666 /* Check if we have a valid path for this prefix */
2667 if (srp
->route
== NULL
) {
2669 sbuf_push(sbuf
, 0, "\n");
2674 /* Process list of OSPF paths */
2675 for (ALL_LIST_ELEMENTS_RO(srp
->route
->paths
, node
, path
)) {
2676 itf
= if_lookup_by_index(path
->ifindex
, VRF_DEFAULT
);
2679 json_route
= json_object_new_array();
2680 json_object_object_add(json
, "prefixRoute",
2683 json_obj
= json_object_new_object();
2684 json_object_int_add(json_obj
, "outputLabel",
2685 path
->srni
.label_out
);
2686 json_object_string_add(json_obj
, "interface",
2687 itf
? itf
->name
: "-");
2688 json_object_string_addf(json_obj
, "nexthop", "%pI4",
2690 json_object_array_add(json_route
, json_obj
);
2692 sbuf_push(sbuf
, indent
, "%20s %9s %15s\n",
2693 sr_op2str(op
, 32, srp
->label_in
,
2694 path
->srni
.label_out
),
2695 itf
? itf
->name
: "-",
2696 inet_ntop(AF_INET
, &path
->nexthop
, buf
,
2698 /* Offset to align information for ECMP */
2704 static void show_sr_node(struct vty
*vty
, struct json_object
*json
,
2705 struct sr_node
*srn
)
2708 struct listnode
*node
;
2709 struct sr_link
*srl
;
2710 struct sr_prefix
*srp
;
2711 struct interface
*itf
;
2716 char buf
[PREFIX_STRLEN
];
2718 json_object
*json_node
= NULL
, *json_algo
, *json_obj
;
2719 json_object
*json_prefix
= NULL
, *json_link
= NULL
;
2725 sbuf_init(&sbuf
, NULL
, 0);
2728 json_node
= json_object_new_object();
2729 json_object_string_addf(json_node
, "routerID", "%pI4",
2731 json_object_int_add(json_node
, "srgbSize",
2732 srn
->srgb
.range_size
);
2733 json_object_int_add(json_node
, "srgbLabel",
2734 srn
->srgb
.lower_bound
);
2735 json_object_int_add(json_node
, "srlbSize",
2736 srn
->srlb
.range_size
);
2737 json_object_int_add(json_node
, "srlbLabel",
2738 srn
->srlb
.lower_bound
);
2739 json_algo
= json_object_new_array();
2740 json_object_object_add(json_node
, "algorithms", json_algo
);
2741 for (int i
= 0; i
< ALGORITHM_COUNT
; i
++) {
2742 if (srn
->algo
[i
] == SR_ALGORITHM_UNSET
)
2744 json_obj
= json_object_new_object();
2747 snprintf(tmp
, sizeof(tmp
), "%u", i
);
2748 json_object_string_add(json_obj
, tmp
,
2749 srn
->algo
[i
] == SR_ALGORITHM_SPF
2752 json_object_array_add(json_algo
, json_obj
);
2755 json_object_int_add(json_node
, "nodeMsd", srn
->msd
);
2757 sbuf_push(&sbuf
, 0, "SR-Node: %pI4", &srn
->adv_router
);
2758 upper
= srn
->srgb
.lower_bound
+ srn
->srgb
.range_size
- 1;
2759 sbuf_push(&sbuf
, 0, "\tSRGB: [%u/%u]",
2760 srn
->srgb
.lower_bound
, upper
);
2761 upper
= srn
->srlb
.lower_bound
+ srn
->srlb
.range_size
- 1;
2762 sbuf_push(&sbuf
, 0, "\tSRLB: [%u/%u]",
2763 srn
->srlb
.lower_bound
, upper
);
2764 sbuf_push(&sbuf
, 0, "\tAlgo.(s): %s",
2765 srn
->algo
[0] == SR_ALGORITHM_SPF
? "SPF" : "S-SPF");
2766 for (int i
= 1; i
< ALGORITHM_COUNT
; i
++) {
2767 if (srn
->algo
[i
] == SR_ALGORITHM_UNSET
)
2769 sbuf_push(&sbuf
, 0, "/%s",
2770 srn
->algo
[i
] == SR_ALGORITHM_SPF
? "SPF"
2774 sbuf_push(&sbuf
, 0, "\tMSD: %u", srn
->msd
);
2779 "\n\n Prefix or Link Node or Adj. SID Label Operation Interface Nexthop\n");
2781 "------------------ --------------------- -------------------- --------- ---------------\n");
2783 for (ALL_LIST_ELEMENTS_RO(srn
->ext_prefix
, node
, srp
)) {
2786 json_prefix
= json_object_new_array();
2787 json_object_object_add(json_node
,
2791 json_obj
= json_object_new_object();
2792 show_sr_prefix(NULL
, json_obj
, srp
);
2793 json_object_array_add(json_prefix
, json_obj
);
2795 show_sr_prefix(&sbuf
, NULL
, srp
);
2799 for (ALL_LIST_ELEMENTS_RO(srn
->ext_link
, node
, srl
)) {
2800 snprintfrr(pref
, 19, "%pI4/32", &srl
->itf_addr
);
2801 snprintf(sid
, 22, "SR Adj. (lbl %u)", srl
->sid
[0]);
2802 itf
= if_lookup_by_index(srl
->nhlfe
[0].ifindex
, VRF_DEFAULT
);
2805 json_link
= json_object_new_array();
2806 json_object_object_add(
2807 json_node
, "extendedLink", json_link
);
2810 json_obj
= json_object_new_object();
2811 json_object_string_add(json_obj
, "prefix", pref
);
2812 json_object_int_add(json_obj
, "sid", srl
->sid
[0]);
2813 json_object_int_add(json_obj
, "inputLabel",
2814 srl
->nhlfe
[0].label_in
);
2815 json_object_int_add(json_obj
, "outputLabel",
2816 srl
->nhlfe
[0].label_out
);
2817 json_object_string_add(json_obj
, "interface",
2818 itf
? itf
->name
: "-");
2819 json_object_string_addf(json_obj
, "nexthop", "%pI4",
2820 &srl
->nhlfe
[0].nexthop
);
2821 json_object_array_add(json_link
, json_obj
);
2823 json_obj
= json_object_new_object();
2824 snprintf(sid
, 22, "SR Adj. (lbl %u)", srl
->sid
[1]);
2825 json_object_string_add(json_obj
, "prefix", pref
);
2826 json_object_int_add(json_obj
, "sid", srl
->sid
[1]);
2827 json_object_int_add(json_obj
, "inputLabel",
2828 srl
->nhlfe
[1].label_in
);
2829 json_object_int_add(json_obj
, "outputLabel",
2830 srl
->nhlfe
[1].label_out
);
2831 json_object_string_add(json_obj
, "interface",
2832 itf
? itf
->name
: "-");
2833 json_object_string_addf(json_obj
, "nexthop", "%pI4",
2834 &srl
->nhlfe
[1].nexthop
);
2835 json_object_array_add(json_link
, json_obj
);
2837 sbuf_push(&sbuf
, 0, "%18s %21s %20s %9s %15s\n",
2839 sr_op2str(op
, 32, srl
->nhlfe
[0].label_in
,
2840 srl
->nhlfe
[0].label_out
),
2841 itf
? itf
->name
: "-",
2842 inet_ntop(AF_INET
, &srl
->nhlfe
[0].nexthop
,
2844 snprintf(sid
, 22, "SR Adj. (lbl %u)", srl
->sid
[1]);
2845 sbuf_push(&sbuf
, 0, "%18s %21s %20s %9s %15s\n",
2847 sr_op2str(op
, 32, srl
->nhlfe
[1].label_in
,
2848 srl
->nhlfe
[1].label_out
),
2849 itf
? itf
->name
: "-",
2850 inet_ntop(AF_INET
, &srl
->nhlfe
[1].nexthop
,
2855 json_object_array_add(json
, json_node
);
2857 vty_out(vty
, "%s\n", sbuf_buf(&sbuf
));
2862 static void show_vty_srdb(struct hash_bucket
*bucket
, void *args
)
2864 struct vty
*vty
= (struct vty
*)args
;
2865 struct sr_node
*srn
= (struct sr_node
*)bucket
->data
;
2867 show_sr_node(vty
, NULL
, srn
);
2870 static void show_json_srdb(struct hash_bucket
*bucket
, void *args
)
2872 struct json_object
*json
= (struct json_object
*)args
;
2873 struct sr_node
*srn
= (struct sr_node
*)bucket
->data
;
2875 show_sr_node(NULL
, json
, srn
);
2878 DEFUN (show_ip_opsf_srdb
,
2879 show_ip_ospf_srdb_cmd
,
2880 "show ip ospf database segment-routing [adv-router A.B.C.D|self-originate] [json]",
2884 "Database summary\n"
2885 "Show Segment Routing Data Base\n"
2886 "Advertising SR node\n"
2887 "Advertising SR node ID (as an IP address)\n"
2888 "Self-originated SR node\n"
2893 struct sr_node
*srn
;
2894 bool uj
= use_json(argc
, argv
);
2895 json_object
*json
= NULL
, *json_node_array
= NULL
;
2897 if (OspfSR
.status
== SR_OFF
) {
2898 vty_out(vty
, "Segment Routing is disabled on this router\n");
2903 json
= json_object_new_object();
2904 json_node_array
= json_object_new_array();
2905 json_object_string_addf(json
, "srdbID", "%pI4",
2906 &OspfSR
.self
->adv_router
);
2907 json_object_object_add(json
, "srNodes", json_node_array
);
2910 "\n\t\tOSPF Segment Routing database for ID %pI4\n\n",
2911 &OspfSR
.self
->adv_router
);
2914 if (argv_find(argv
, argc
, "self-originate", &idx
)) {
2916 show_sr_node(vty
, json_node_array
, srn
);
2918 vty_json(vty
, json
);
2922 if (argv_find(argv
, argc
, "A.B.C.D", &idx
)) {
2923 if (!inet_aton(argv
[idx
]->arg
, &rid
)) {
2924 vty_out(vty
, "Specified Router ID %s is invalid\n",
2926 return CMD_WARNING_CONFIG_FAILED
;
2928 /* Get the SR Node from the SRDB */
2929 srn
= (struct sr_node
*)hash_lookup(OspfSR
.neighbors
,
2931 show_sr_node(vty
, json_node_array
, srn
);
2933 vty_json(vty
, json
);
2937 /* No parameters have been provided, Iterate through all the SRDB */
2939 hash_iterate(OspfSR
.neighbors
, (void (*)(struct hash_bucket
*,
2940 void *))show_json_srdb
,
2941 (void *)json_node_array
);
2942 vty_json(vty
, json
);
2944 hash_iterate(OspfSR
.neighbors
, (void (*)(struct hash_bucket
*,
2945 void *))show_vty_srdb
,
2951 /* Install new CLI commands */
2952 void ospf_sr_register_vty(void)
2954 install_element(VIEW_NODE
, &show_ip_ospf_srdb_cmd
);
2956 install_element(OSPF_NODE
, &ospf_sr_enable_cmd
);
2957 install_element(OSPF_NODE
, &no_ospf_sr_enable_cmd
);
2958 install_element(OSPF_NODE
, &sr_global_label_range_cmd
);
2959 install_element(OSPF_NODE
, &no_sr_global_label_range_cmd
);
2960 install_element(OSPF_NODE
, &sr_node_msd_cmd
);
2961 install_element(OSPF_NODE
, &no_sr_node_msd_cmd
);
2962 install_element(OSPF_NODE
, &sr_prefix_sid_cmd
);
2963 install_element(OSPF_NODE
, &no_sr_prefix_sid_cmd
);