2 * This is an implementation of RFC3630
3 * Copyright (C) 2001 KDD R&D Laboratories, Inc.
4 * http://www.kddlabs.co.jp/
6 * Copyright (C) 2012 Orange Labs
7 * http://www.orange.com
9 * This file is part of GNU Zebra.
11 * GNU Zebra is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2, or (at your option) any
16 * GNU Zebra is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * You should have received a copy of the GNU General Public License along
22 * with this program; see the file COPYING; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
26 /* Add support of RFC7471 */
27 /* Add support of RFC5392, RFC6827 */
44 #include "sockunion.h" /* for inet_aton() */
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_zebra.h"
62 #include "ospfd/ospf_te.h"
63 #include "ospfd/ospf_vty.h"
64 #include "ospfd/ospf_errors.h"
67 * Global variable to manage Opaque-LSA/MPLS-TE on this node.
68 * Note that all parameter values are stored in network byte order.
70 struct ospf_mpls_te OspfMplsTE
;
72 static const char *const mode2text
[] = {"Off", "AS", "Area"};
74 /*------------------------------------------------------------------------*
75 * Followings are initialize/terminate functions for MPLS-TE handling.
76 *------------------------------------------------------------------------*/
78 static int ospf_mpls_te_new_if(struct interface
*ifp
);
79 static int ospf_mpls_te_del_if(struct interface
*ifp
);
80 static void ospf_mpls_te_ism_change(struct ospf_interface
*oi
, int old_status
);
81 static void ospf_mpls_te_nsm_change(struct ospf_neighbor
*nbr
, int old_status
);
82 static void ospf_mpls_te_config_write_router(struct vty
*vty
);
83 static void ospf_mpls_te_show_info(struct vty
*vty
, struct ospf_lsa
*lsa
);
84 static int ospf_mpls_te_lsa_originate_area(void *arg
);
85 static int ospf_mpls_te_lsa_originate_as(void *arg
);
86 static struct ospf_lsa
*ospf_mpls_te_lsa_refresh(struct ospf_lsa
*lsa
);
88 static void del_mpls_te_link(void *val
);
89 static void ospf_mpls_te_register_vty(void);
91 int ospf_mpls_te_init(void)
95 rc
= ospf_register_opaque_functab(
96 OSPF_OPAQUE_AREA_LSA
, OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA
,
97 ospf_mpls_te_new_if
, ospf_mpls_te_del_if
,
98 ospf_mpls_te_ism_change
, ospf_mpls_te_nsm_change
,
99 ospf_mpls_te_config_write_router
,
100 NULL
, /*ospf_mpls_te_config_write_if */
101 NULL
, /* ospf_mpls_te_config_write_debug */
102 ospf_mpls_te_show_info
, ospf_mpls_te_lsa_originate_area
,
103 ospf_mpls_te_lsa_refresh
, NULL
, /* ospf_mpls_te_new_lsa_hook */
104 NULL
/* ospf_mpls_te_del_lsa_hook */);
107 EC_OSPF_OPAQUE_REGISTRATION
,
108 "ospf_mpls_te_init: Failed to register Traffic Engineering functions");
112 memset(&OspfMplsTE
, 0, sizeof(struct ospf_mpls_te
));
113 OspfMplsTE
.enabled
= false;
114 OspfMplsTE
.inter_as
= Off
;
115 OspfMplsTE
.iflist
= list_new();
116 OspfMplsTE
.iflist
->del
= del_mpls_te_link
;
118 ospf_mpls_te_register_vty();
123 /* Additional register for RFC5392 support */
124 static int ospf_mpls_te_register(enum inter_as_mode mode
)
129 if (OspfMplsTE
.inter_as
!= Off
)
133 scope
= OSPF_OPAQUE_AS_LSA
;
135 scope
= OSPF_OPAQUE_AREA_LSA
;
137 rc
= ospf_register_opaque_functab(scope
, OPAQUE_TYPE_INTER_AS_LSA
, NULL
,
138 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
139 ospf_mpls_te_show_info
,
140 ospf_mpls_te_lsa_originate_as
,
141 ospf_mpls_te_lsa_refresh
, NULL
, NULL
);
145 EC_OSPF_OPAQUE_REGISTRATION
,
146 "ospf_router_info_init: Failed to register Inter-AS functions");
153 static int ospf_mpls_te_unregister(void)
157 if (OspfMplsTE
.inter_as
== Off
)
160 if (OspfMplsTE
.inter_as
== AS
)
161 scope
= OSPF_OPAQUE_AS_LSA
;
163 scope
= OSPF_OPAQUE_AREA_LSA
;
165 ospf_delete_opaque_functab(scope
, OPAQUE_TYPE_INTER_AS_LSA
);
170 void ospf_mpls_te_term(void)
172 list_delete(&OspfMplsTE
.iflist
);
174 ospf_delete_opaque_functab(OSPF_OPAQUE_AREA_LSA
,
175 OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA
);
177 OspfMplsTE
.enabled
= false;
179 ospf_mpls_te_unregister();
180 OspfMplsTE
.inter_as
= Off
;
185 void ospf_mpls_te_finish(void)
187 // list_delete_all_node(OspfMplsTE.iflist);
189 OspfMplsTE
.enabled
= false;
190 OspfMplsTE
.inter_as
= Off
;
193 /*------------------------------------------------------------------------*
194 * Followings are control functions for MPLS-TE parameters management.
195 *------------------------------------------------------------------------*/
197 static void del_mpls_te_link(void *val
)
199 XFREE(MTYPE_OSPF_MPLS_TE
, val
);
203 static uint32_t get_mpls_te_instance_value(void)
205 static uint32_t seqno
= 0;
207 if (seqno
< MAX_LEGAL_TE_INSTANCE_NUM
)
210 seqno
= 1; /* Avoid zero. */
215 static struct mpls_te_link
*lookup_linkparams_by_ifp(struct interface
*ifp
)
217 struct listnode
*node
, *nnode
;
218 struct mpls_te_link
*lp
;
220 for (ALL_LIST_ELEMENTS(OspfMplsTE
.iflist
, node
, nnode
, lp
))
227 static struct mpls_te_link
*lookup_linkparams_by_instance(struct ospf_lsa
*lsa
)
229 struct listnode
*node
;
230 struct mpls_te_link
*lp
;
231 unsigned int key
= GET_OPAQUE_ID(ntohl(lsa
->data
->id
.s_addr
));
233 for (ALL_LIST_ELEMENTS_RO(OspfMplsTE
.iflist
, node
, lp
))
234 if (lp
->instance
== key
)
237 zlog_info("lookup_linkparams_by_instance: Entry not found: key(%x)",
242 static void ospf_mpls_te_foreach_area(
243 void (*func
)(struct mpls_te_link
*lp
, enum lsa_opcode sched_opcode
),
244 enum lsa_opcode sched_opcode
)
246 struct listnode
*node
, *nnode
;
247 struct listnode
*node2
;
248 struct mpls_te_link
*lp
;
249 struct ospf_area
*area
;
251 for (ALL_LIST_ELEMENTS(OspfMplsTE
.iflist
, node
, nnode
, lp
)) {
252 /* Skip Inter-AS TEv2 Links */
253 if (IS_INTER_AS(lp
->type
))
255 if ((area
= lp
->area
) == NULL
)
257 if (CHECK_FLAG(lp
->flags
, LPFLG_LOOKUP_DONE
))
261 (*func
)(lp
, sched_opcode
);
263 for (node2
= listnextnode(node
); node2
;
264 node2
= listnextnode(node2
))
265 if ((lp
= listgetdata(node2
)) != NULL
)
266 if (lp
->area
!= NULL
)
267 if (IPV4_ADDR_SAME(&lp
->area
->area_id
,
273 for (ALL_LIST_ELEMENTS_RO(OspfMplsTE
.iflist
, node
, lp
))
274 if (lp
->area
!= NULL
)
275 UNSET_FLAG(lp
->flags
, LPFLG_LOOKUP_DONE
);
280 static void set_mpls_te_router_addr(struct in_addr ipv4
)
282 OspfMplsTE
.router_addr
.header
.type
= htons(TE_TLV_ROUTER_ADDR
);
283 OspfMplsTE
.router_addr
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
284 OspfMplsTE
.router_addr
.value
= ipv4
;
288 static void set_linkparams_link_header(struct mpls_te_link
*lp
)
292 /* TE_LINK_SUBTLV_LINK_TYPE */
293 if (ntohs(lp
->link_type
.header
.type
) != 0)
294 length
+= TLV_SIZE(&lp
->link_type
.header
);
296 /* TE_LINK_SUBTLV_LINK_ID */
297 if (ntohs(lp
->link_id
.header
.type
) != 0)
298 length
+= TLV_SIZE(&lp
->link_id
.header
);
300 /* TE_LINK_SUBTLV_LCLIF_IPADDR */
301 if (lp
->lclif_ipaddr
.header
.type
!= 0)
302 length
+= TLV_SIZE(&lp
->lclif_ipaddr
.header
);
304 /* TE_LINK_SUBTLV_RMTIF_IPADDR */
305 if (lp
->rmtif_ipaddr
.header
.type
!= 0)
306 length
+= TLV_SIZE(&lp
->rmtif_ipaddr
.header
);
308 /* TE_LINK_SUBTLV_TE_METRIC */
309 if (ntohs(lp
->te_metric
.header
.type
) != 0)
310 length
+= TLV_SIZE(&lp
->te_metric
.header
);
312 /* TE_LINK_SUBTLV_MAX_BW */
313 if (ntohs(lp
->max_bw
.header
.type
) != 0)
314 length
+= TLV_SIZE(&lp
->max_bw
.header
);
316 /* TE_LINK_SUBTLV_MAX_RSV_BW */
317 if (ntohs(lp
->max_rsv_bw
.header
.type
) != 0)
318 length
+= TLV_SIZE(&lp
->max_rsv_bw
.header
);
320 /* TE_LINK_SUBTLV_UNRSV_BW */
321 if (ntohs(lp
->unrsv_bw
.header
.type
) != 0)
322 length
+= TLV_SIZE(&lp
->unrsv_bw
.header
);
324 /* TE_LINK_SUBTLV_RSC_CLSCLR */
325 if (ntohs(lp
->rsc_clsclr
.header
.type
) != 0)
326 length
+= TLV_SIZE(&lp
->rsc_clsclr
.header
);
328 /* TE_LINK_SUBTLV_LLRI */
329 if (ntohs(lp
->llri
.header
.type
) != 0)
330 length
+= TLV_SIZE(&lp
->llri
.header
);
332 /* TE_LINK_SUBTLV_RIP */
333 if (ntohs(lp
->rip
.header
.type
) != 0)
334 length
+= TLV_SIZE(&lp
->rip
.header
);
336 /* TE_LINK_SUBTLV_RAS */
337 if (ntohs(lp
->ras
.header
.type
) != 0)
338 length
+= TLV_SIZE(&lp
->ras
.header
);
340 /* TE_LINK_SUBTLV_LRRID */
341 if (ntohs(lp
->lrrid
.header
.type
) != 0)
342 length
+= TLV_SIZE(&lp
->lrrid
.header
);
344 /* TE_LINK_SUBTLV_AV_DELAY */
345 if (ntohs(lp
->av_delay
.header
.type
) != 0)
346 length
+= TLV_SIZE(&lp
->av_delay
.header
);
348 /* TE_LINK_SUBTLV_MM_DELAY */
349 if (ntohs(lp
->mm_delay
.header
.type
) != 0)
350 length
+= TLV_SIZE(&lp
->mm_delay
.header
);
352 /* TE_LINK_SUBTLV_DELAY_VAR */
353 if (ntohs(lp
->delay_var
.header
.type
) != 0)
354 length
+= TLV_SIZE(&lp
->delay_var
.header
);
356 /* TE_LINK_SUBTLV_PKT_LOSS */
357 if (ntohs(lp
->pkt_loss
.header
.type
) != 0)
358 length
+= TLV_SIZE(&lp
->pkt_loss
.header
);
360 /* TE_LINK_SUBTLV_RES_BW */
361 if (ntohs(lp
->res_bw
.header
.type
) != 0)
362 length
+= TLV_SIZE(&lp
->res_bw
.header
);
364 /* TE_LINK_SUBTLV_AVA_BW */
365 if (ntohs(lp
->ava_bw
.header
.type
) != 0)
366 length
+= TLV_SIZE(&lp
->ava_bw
.header
);
368 /* TE_LINK_SUBTLV_USE_BW */
369 if (ntohs(lp
->use_bw
.header
.type
) != 0)
370 length
+= TLV_SIZE(&lp
->use_bw
.header
);
372 lp
->link_header
.header
.type
= htons(TE_TLV_LINK
);
373 lp
->link_header
.header
.length
= htons(length
);
378 static void set_linkparams_link_type(struct ospf_interface
*oi
,
379 struct mpls_te_link
*lp
)
381 lp
->link_type
.header
.type
= htons(TE_LINK_SUBTLV_LINK_TYPE
);
382 lp
->link_type
.header
.length
= htons(TE_LINK_SUBTLV_TYPE_SIZE
);
385 case OSPF_IFTYPE_POINTOPOINT
:
386 lp
->link_type
.link_type
.value
= LINK_TYPE_SUBTLV_VALUE_PTP
;
388 case OSPF_IFTYPE_BROADCAST
:
389 case OSPF_IFTYPE_NBMA
:
390 lp
->link_type
.link_type
.value
= LINK_TYPE_SUBTLV_VALUE_MA
;
393 /* Not supported yet. */ /* XXX */
394 lp
->link_type
.header
.type
= htons(0);
400 static void set_linkparams_link_id(struct mpls_te_link
*lp
,
401 struct in_addr link_id
)
404 lp
->link_id
.header
.type
= htons(TE_LINK_SUBTLV_LINK_ID
);
405 lp
->link_id
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
406 lp
->link_id
.value
= link_id
;
410 static void set_linkparams_lclif_ipaddr(struct mpls_te_link
*lp
,
411 struct in_addr lclif
)
414 lp
->lclif_ipaddr
.header
.type
= htons(TE_LINK_SUBTLV_LCLIF_IPADDR
);
415 lp
->lclif_ipaddr
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
416 lp
->lclif_ipaddr
.value
[0] = lclif
;
420 static void set_linkparams_rmtif_ipaddr(struct mpls_te_link
*lp
,
421 struct in_addr rmtif
)
424 lp
->rmtif_ipaddr
.header
.type
= htons(TE_LINK_SUBTLV_RMTIF_IPADDR
);
425 lp
->rmtif_ipaddr
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
426 lp
->rmtif_ipaddr
.value
[0] = rmtif
;
430 static void set_linkparams_te_metric(struct mpls_te_link
*lp
,
433 lp
->te_metric
.header
.type
= htons(TE_LINK_SUBTLV_TE_METRIC
);
434 lp
->te_metric
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
435 lp
->te_metric
.value
= htonl(te_metric
);
439 static void set_linkparams_max_bw(struct mpls_te_link
*lp
, float fp
)
441 lp
->max_bw
.header
.type
= htons(TE_LINK_SUBTLV_MAX_BW
);
442 lp
->max_bw
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
443 lp
->max_bw
.value
= htonf(fp
);
447 static void set_linkparams_max_rsv_bw(struct mpls_te_link
*lp
, float fp
)
449 lp
->max_rsv_bw
.header
.type
= htons(TE_LINK_SUBTLV_MAX_RSV_BW
);
450 lp
->max_rsv_bw
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
451 lp
->max_rsv_bw
.value
= htonf(fp
);
455 static void set_linkparams_unrsv_bw(struct mpls_te_link
*lp
, int priority
,
458 /* Note that TLV-length field is the size of array. */
459 lp
->unrsv_bw
.header
.type
= htons(TE_LINK_SUBTLV_UNRSV_BW
);
460 lp
->unrsv_bw
.header
.length
= htons(TE_LINK_SUBTLV_UNRSV_SIZE
);
461 lp
->unrsv_bw
.value
[priority
] = htonf(fp
);
465 static void set_linkparams_rsc_clsclr(struct mpls_te_link
*lp
,
468 lp
->rsc_clsclr
.header
.type
= htons(TE_LINK_SUBTLV_RSC_CLSCLR
);
469 lp
->rsc_clsclr
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
470 lp
->rsc_clsclr
.value
= htonl(classcolor
);
474 static void set_linkparams_inter_as(struct mpls_te_link
*lp
,
475 struct in_addr addr
, uint32_t as
)
478 /* Set the Remote ASBR IP address and then the associated AS number */
479 lp
->rip
.header
.type
= htons(TE_LINK_SUBTLV_RIP
);
480 lp
->rip
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
481 lp
->rip
.value
= addr
;
483 lp
->ras
.header
.type
= htons(TE_LINK_SUBTLV_RAS
);
484 lp
->ras
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
485 lp
->ras
.value
= htonl(as
);
488 static void unset_linkparams_inter_as(struct mpls_te_link
*lp
)
491 /* Reset the Remote ASBR IP address and then the associated AS number */
492 lp
->rip
.header
.type
= htons(0);
493 lp
->rip
.header
.length
= htons(0);
494 lp
->rip
.value
.s_addr
= htonl(0);
496 lp
->ras
.header
.type
= htons(0);
497 lp
->ras
.header
.length
= htons(0);
498 lp
->ras
.value
= htonl(0);
501 void set_linkparams_llri(struct mpls_te_link
*lp
, uint32_t local
,
505 lp
->llri
.header
.type
= htons(TE_LINK_SUBTLV_LLRI
);
506 lp
->llri
.header
.length
= htons(TE_LINK_SUBTLV_LLRI_SIZE
);
507 lp
->llri
.local
= htonl(local
);
508 lp
->llri
.remote
= htonl(remote
);
511 void set_linkparams_lrrid(struct mpls_te_link
*lp
, struct in_addr local
,
512 struct in_addr remote
)
515 lp
->lrrid
.header
.type
= htons(TE_LINK_SUBTLV_LRRID
);
516 lp
->lrrid
.header
.length
= htons(TE_LINK_SUBTLV_LRRID_SIZE
);
517 lp
->lrrid
.local
.s_addr
= local
.s_addr
;
518 lp
->lrrid
.remote
.s_addr
= remote
.s_addr
;
521 static void set_linkparams_av_delay(struct mpls_te_link
*lp
, uint32_t delay
,
525 /* Note that TLV-length field is the size of array. */
526 lp
->av_delay
.header
.type
= htons(TE_LINK_SUBTLV_AV_DELAY
);
527 lp
->av_delay
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
528 tmp
= delay
& TE_EXT_MASK
;
530 tmp
|= TE_EXT_ANORMAL
;
531 lp
->av_delay
.value
= htonl(tmp
);
535 static void set_linkparams_mm_delay(struct mpls_te_link
*lp
, uint32_t low
,
536 uint32_t high
, uint8_t anormal
)
539 /* Note that TLV-length field is the size of array. */
540 lp
->mm_delay
.header
.type
= htons(TE_LINK_SUBTLV_MM_DELAY
);
541 lp
->mm_delay
.header
.length
= htons(TE_LINK_SUBTLV_MM_DELAY_SIZE
);
542 tmp
= low
& TE_EXT_MASK
;
544 tmp
|= TE_EXT_ANORMAL
;
545 lp
->mm_delay
.low
= htonl(tmp
);
546 lp
->mm_delay
.high
= htonl(high
);
550 static void set_linkparams_delay_var(struct mpls_te_link
*lp
, uint32_t jitter
)
552 /* Note that TLV-length field is the size of array. */
553 lp
->delay_var
.header
.type
= htons(TE_LINK_SUBTLV_DELAY_VAR
);
554 lp
->delay_var
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
555 lp
->delay_var
.value
= htonl(jitter
& TE_EXT_MASK
);
559 static void set_linkparams_pkt_loss(struct mpls_te_link
*lp
, uint32_t loss
,
563 /* Note that TLV-length field is the size of array. */
564 lp
->pkt_loss
.header
.type
= htons(TE_LINK_SUBTLV_PKT_LOSS
);
565 lp
->pkt_loss
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
566 tmp
= loss
& TE_EXT_MASK
;
568 tmp
|= TE_EXT_ANORMAL
;
569 lp
->pkt_loss
.value
= htonl(tmp
);
573 static void set_linkparams_res_bw(struct mpls_te_link
*lp
, float fp
)
575 /* Note that TLV-length field is the size of array. */
576 lp
->res_bw
.header
.type
= htons(TE_LINK_SUBTLV_RES_BW
);
577 lp
->res_bw
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
578 lp
->res_bw
.value
= htonf(fp
);
582 static void set_linkparams_ava_bw(struct mpls_te_link
*lp
, float fp
)
584 /* Note that TLV-length field is the size of array. */
585 lp
->ava_bw
.header
.type
= htons(TE_LINK_SUBTLV_AVA_BW
);
586 lp
->ava_bw
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
587 lp
->ava_bw
.value
= htonf(fp
);
591 static void set_linkparams_use_bw(struct mpls_te_link
*lp
, float fp
)
593 /* Note that TLV-length field is the size of array. */
594 lp
->use_bw
.header
.type
= htons(TE_LINK_SUBTLV_USE_BW
);
595 lp
->use_bw
.header
.length
= htons(TE_LINK_SUBTLV_DEF_SIZE
);
596 lp
->use_bw
.value
= htonf(fp
);
600 /* Update TE parameters from Interface */
601 static void update_linkparams(struct mpls_te_link
*lp
)
604 struct interface
*ifp
;
606 /* Get the Interface structure */
607 if ((ifp
= lp
->ifp
) == NULL
) {
608 if (IS_DEBUG_OSPF_TE
)
610 "OSPF MPLS-TE: Abort update TE parameters: no interface associated to Link Parameters");
613 if (!HAS_LINK_PARAMS(ifp
)) {
614 if (IS_DEBUG_OSPF_TE
)
616 "OSPF MPLS-TE: Abort update TE parameters: no Link Parameters for interface");
620 /* RFC3630 metrics */
621 if (IS_PARAM_SET(ifp
->link_params
, LP_ADM_GRP
))
622 set_linkparams_rsc_clsclr(lp
, ifp
->link_params
->admin_grp
);
624 TLV_TYPE(lp
->rsc_clsclr
) = 0;
626 if (IS_PARAM_SET(ifp
->link_params
, LP_MAX_BW
))
627 set_linkparams_max_bw(lp
, ifp
->link_params
->max_bw
);
629 TLV_TYPE(lp
->max_bw
) = 0;
631 if (IS_PARAM_SET(ifp
->link_params
, LP_MAX_RSV_BW
))
632 set_linkparams_max_rsv_bw(lp
, ifp
->link_params
->max_rsv_bw
);
634 TLV_TYPE(lp
->max_rsv_bw
) = 0;
636 if (IS_PARAM_SET(ifp
->link_params
, LP_UNRSV_BW
))
637 for (i
= 0; i
< MAX_CLASS_TYPE
; i
++)
638 set_linkparams_unrsv_bw(lp
, i
,
639 ifp
->link_params
->unrsv_bw
[i
]);
641 TLV_TYPE(lp
->unrsv_bw
) = 0;
643 if (IS_PARAM_SET(ifp
->link_params
, LP_TE_METRIC
))
644 set_linkparams_te_metric(lp
, ifp
->link_params
->te_metric
);
646 TLV_TYPE(lp
->te_metric
) = 0;
648 /* TE metric Extensions */
649 if (IS_PARAM_SET(ifp
->link_params
, LP_DELAY
))
650 set_linkparams_av_delay(lp
, ifp
->link_params
->av_delay
, 0);
652 TLV_TYPE(lp
->av_delay
) = 0;
654 if (IS_PARAM_SET(ifp
->link_params
, LP_MM_DELAY
))
655 set_linkparams_mm_delay(lp
, ifp
->link_params
->min_delay
,
656 ifp
->link_params
->max_delay
, 0);
658 TLV_TYPE(lp
->mm_delay
) = 0;
660 if (IS_PARAM_SET(ifp
->link_params
, LP_DELAY_VAR
))
661 set_linkparams_delay_var(lp
, ifp
->link_params
->delay_var
);
663 TLV_TYPE(lp
->delay_var
) = 0;
665 if (IS_PARAM_SET(ifp
->link_params
, LP_PKT_LOSS
))
666 set_linkparams_pkt_loss(lp
, ifp
->link_params
->pkt_loss
, 0);
668 TLV_TYPE(lp
->pkt_loss
) = 0;
670 if (IS_PARAM_SET(ifp
->link_params
, LP_RES_BW
))
671 set_linkparams_res_bw(lp
, ifp
->link_params
->res_bw
);
673 TLV_TYPE(lp
->res_bw
) = 0;
675 if (IS_PARAM_SET(ifp
->link_params
, LP_AVA_BW
))
676 set_linkparams_ava_bw(lp
, ifp
->link_params
->ava_bw
);
678 TLV_TYPE(lp
->ava_bw
) = 0;
680 if (IS_PARAM_SET(ifp
->link_params
, LP_USE_BW
))
681 set_linkparams_use_bw(lp
, ifp
->link_params
->use_bw
);
683 TLV_TYPE(lp
->use_bw
) = 0;
686 if (IS_PARAM_SET(ifp
->link_params
, LP_RMT_AS
)) {
687 /* Flush LSA if it engaged and was previously a STD_TE one */
688 if (IS_STD_TE(lp
->type
)
689 && CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
)) {
690 if (IS_DEBUG_OSPF_TE
)
692 "OSPF MPLS-TE Update IF: Switch from Standard LSA to INTER-AS for %s[%d/%d]",
693 ifp
->name
, lp
->flags
, lp
->type
);
695 ospf_mpls_te_lsa_schedule(lp
, FLUSH_THIS_LSA
);
696 /* Then, switch it to INTER-AS */
697 if (OspfMplsTE
.inter_as
== AS
)
698 lp
->flags
= INTER_AS
| FLOOD_AS
;
700 lp
->flags
= INTER_AS
| FLOOD_AREA
;
701 lp
->area
= ospf_area_lookup_by_area_id(
702 ospf_lookup_by_vrf_id(VRF_DEFAULT
),
703 OspfMplsTE
.interas_areaid
);
706 set_linkparams_inter_as(lp
, ifp
->link_params
->rmt_ip
,
707 ifp
->link_params
->rmt_as
);
709 if (IS_DEBUG_OSPF_TE
)
711 "OSPF MPLS-TE Update IF: Switch from INTER-AS LSA to Standard for %s[%d/%d]",
712 ifp
->name
, lp
->flags
, lp
->type
);
714 /* reset inter-as TE params */
715 /* Flush LSA if it engaged and was previously an INTER_AS one */
716 if (IS_INTER_AS(lp
->type
)
717 && CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
)) {
718 ospf_mpls_te_lsa_schedule(lp
, FLUSH_THIS_LSA
);
719 /* Then, switch it to Standard TE */
720 lp
->flags
= STD_TE
| FLOOD_AREA
;
722 unset_linkparams_inter_as(lp
);
726 static void initialize_linkparams(struct mpls_te_link
*lp
)
728 struct interface
*ifp
= lp
->ifp
;
729 struct ospf_interface
*oi
= NULL
;
730 struct route_node
*rn
;
732 if (IS_DEBUG_OSPF_TE
)
734 "MPLS-TE(initialize_linkparams) Initialize Link Parameters for interface %s",
737 /* Search OSPF Interface parameters for this interface */
738 for (rn
= route_top(IF_OIFS(ifp
)); rn
; rn
= route_next(rn
)) {
740 if ((oi
= rn
->info
) == NULL
)
747 if ((oi
== NULL
) || (oi
->ifp
!= ifp
)) {
748 if (IS_DEBUG_OSPF_TE
)
750 "MPLS-TE(initialize_linkparams) Could not find corresponding OSPF Interface for %s",
756 * Try to set initial values those can be derived from
757 * zebra-interface information.
759 set_linkparams_link_type(oi
, lp
);
761 /* Set local IP addr */
762 set_linkparams_lclif_ipaddr(lp
, oi
->address
->u
.prefix4
);
764 /* Set Remote IP addr if Point to Point Interface */
765 if (oi
->type
== OSPF_IFTYPE_POINTOPOINT
) {
766 struct prefix
*pref
= CONNECTED_PREFIX(oi
->connected
);
768 set_linkparams_rmtif_ipaddr(lp
, pref
->u
.prefix4
);
771 /* Keep Area information in combination with link parameters. */
777 static int is_mandated_params_set(struct mpls_te_link
*lp
)
781 if (ntohs(OspfMplsTE
.router_addr
.header
.type
) == 0) {
783 EC_OSPF_TE_UNEXPECTED
,
784 "MPLS-TE(is_mandated_params_set) Missing Router Address");
788 if (ntohs(lp
->link_type
.header
.type
) == 0) {
789 flog_warn(EC_OSPF_TE_UNEXPECTED
,
790 "MPLS-TE(is_mandated_params_set) Missing Link Type");
794 if (!IS_INTER_AS(lp
->type
) && (ntohs(lp
->link_id
.header
.type
) == 0)) {
795 flog_warn(EC_OSPF_TE_UNEXPECTED
,
796 "MPLS-TE(is_mandated_params_set) Missing Link ID");
804 /*------------------------------------------------------------------------*
805 * Followings are callback functions against generic Opaque-LSAs handling.
806 *------------------------------------------------------------------------*/
808 static int ospf_mpls_te_new_if(struct interface
*ifp
)
810 struct mpls_te_link
*new;
812 if (IS_DEBUG_OSPF_TE
)
814 "MPLS-TE(ospf_mpls_te_new_if) Add new %s interface %s to MPLS-TE list",
815 ifp
->link_params
? "Active" : "Inactive", ifp
->name
);
817 if (lookup_linkparams_by_ifp(ifp
) != NULL
)
820 new = XCALLOC(MTYPE_OSPF_MPLS_TE
, sizeof(struct mpls_te_link
));
822 new->instance
= get_mpls_te_instance_value();
824 /* By default TE-Link is RFC3630 compatible flooding in Area and not
826 /* This default behavior will be adapted with call to
827 * ospf_mpls_te_update_if() */
828 new->type
= STD_TE
| FLOOD_AREA
;
829 new->flags
= LPFLG_LSA_INACTIVE
;
831 /* Initialize Link Parameters from Interface */
832 initialize_linkparams(new);
834 /* Set TE Parameters from Interface */
835 update_linkparams(new);
837 /* Add Link Parameters structure to the list */
838 listnode_add(OspfMplsTE
.iflist
, new);
840 if (IS_DEBUG_OSPF_TE
)
842 "OSPF MPLS-TE New IF: Add new LP context for %s[%d/%d]",
843 ifp
->name
, new->flags
, new->type
);
845 /* Schedule Opaque-LSA refresh. */ /* XXX */
849 static int ospf_mpls_te_del_if(struct interface
*ifp
)
851 struct mpls_te_link
*lp
;
854 if ((lp
= lookup_linkparams_by_ifp(ifp
)) != NULL
) {
855 struct list
*iflist
= OspfMplsTE
.iflist
;
857 /* Dequeue listnode entry from the list. */
858 listnode_delete(iflist
, lp
);
860 XFREE(MTYPE_OSPF_MPLS_TE
, lp
);
863 /* Schedule Opaque-LSA refresh. */ /* XXX */
869 /* Main initialization / update function of the MPLS TE Link context */
871 /* Call when interface TE Link parameters are modified */
872 void ospf_mpls_te_update_if(struct interface
*ifp
)
874 struct mpls_te_link
*lp
;
876 if (IS_DEBUG_OSPF_TE
)
878 "OSPF MPLS-TE: Update LSA parameters for interface %s [%s]",
879 ifp
->name
, HAS_LINK_PARAMS(ifp
) ? "ON" : "OFF");
881 /* Get Link context from interface */
882 if ((lp
= lookup_linkparams_by_ifp(ifp
)) == NULL
) {
884 EC_OSPF_TE_UNEXPECTED
,
885 "OSPF MPLS-TE Update: Did not find Link Parameters context for interface %s",
890 /* Fulfill MPLS-TE Link TLV from Interface TE Link parameters */
891 if (HAS_LINK_PARAMS(ifp
)) {
892 SET_FLAG(lp
->flags
, LPFLG_LSA_ACTIVE
);
894 /* Update TE parameters */
895 update_linkparams(lp
);
897 /* Finally Re-Originate or Refresh Opaque LSA if MPLS_TE is
899 if (OspfMplsTE
.enabled
)
900 if (lp
->area
!= NULL
) {
901 if (CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
))
902 ospf_mpls_te_lsa_schedule(
903 lp
, REFRESH_THIS_LSA
);
905 ospf_mpls_te_lsa_schedule(
906 lp
, REORIGINATE_THIS_LSA
);
909 /* If MPLS TE is disable on this interface, flush LSA if it is
911 if (CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
))
912 ospf_mpls_te_lsa_schedule(lp
, FLUSH_THIS_LSA
);
914 /* Reset Activity flag */
915 lp
->flags
= LPFLG_LSA_INACTIVE
;
922 * Just add interface and set available information. Other information
923 * and flooding of LSA will be done later when adjacency will be up
924 * See ospf_mpls_te_nsm_change() after
926 static void ospf_mpls_te_ism_change(struct ospf_interface
*oi
, int old_state
)
929 struct mpls_te_link
*lp
;
931 lp
= lookup_linkparams_by_ifp(oi
->ifp
);
934 EC_OSPF_TE_UNEXPECTED
,
935 "MPLS-TE (%s): Cannot get linkparams from OI(%s)?",
936 __func__
, IF_NAME(oi
));
940 if (oi
->area
== NULL
|| oi
->area
->ospf
== NULL
) {
942 EC_OSPF_TE_UNEXPECTED
,
943 "MPLS-TE (%s): Cannot refer to OSPF from OI(%s)?",
944 __func__
, IF_NAME(oi
));
948 /* Keep Area information in combination with linkparams. */
951 /* Keep interface MPLS-TE status */
952 lp
->flags
= HAS_LINK_PARAMS(oi
->ifp
);
955 case ISM_PointToPoint
:
959 /* Set Link type and Local IP addr */
960 set_linkparams_link_type(oi
, lp
);
961 set_linkparams_lclif_ipaddr(lp
, oi
->address
->u
.prefix4
);
965 /* State is undefined: Flush LSA if engaged */
966 if (CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
))
967 ospf_mpls_te_lsa_schedule(lp
, FLUSH_THIS_LSA
);
971 if (IS_DEBUG_OSPF_TE
)
973 "MPLS-TE(%s): Update Link parameters for interface %s",
974 __func__
, IF_NAME(oi
));
980 * Complete TE info and schedule LSA flooding
981 * Link-ID and Remote IP address must be set with neighbor info
982 * which are only valid once NSM state is FULL
984 static void ospf_mpls_te_nsm_change(struct ospf_neighbor
*nbr
, int old_state
)
986 struct ospf_interface
*oi
= nbr
->oi
;
987 struct mpls_te_link
*lp
;
989 /* Process Neighbor only when its state is NSM Full */
990 if (nbr
->state
!= NSM_Full
)
993 /* Get interface information for Traffic Engineering */
994 lp
= lookup_linkparams_by_ifp(oi
->ifp
);
997 EC_OSPF_TE_UNEXPECTED
,
998 "MPLS-TE (%s): Cannot get linkparams from OI(%s)?",
999 __func__
, IF_NAME(oi
));
1003 if (oi
->area
== NULL
|| oi
->area
->ospf
== NULL
) {
1005 EC_OSPF_TE_UNEXPECTED
,
1006 "MPLS-TE (%s): Cannot refer to OSPF from OI(%s)?",
1007 __func__
, IF_NAME(oi
));
1011 /* Keep Area information in combination with SR info. */
1012 lp
->area
= oi
->area
;
1014 /* Keep interface MPLS-TE status */
1015 lp
->flags
= HAS_LINK_PARAMS(oi
->ifp
);
1018 * The Link ID is identical to the contents of the Link ID field
1019 * in the Router LSA for these link types.
1021 switch (oi
->state
) {
1022 case ISM_PointToPoint
:
1023 /* Set Link ID with neighbor Router ID */
1024 set_linkparams_link_id(lp
, nbr
->router_id
);
1025 /* Set Remote IP address */
1026 set_linkparams_rmtif_ipaddr(lp
, nbr
->address
.u
.prefix4
);
1032 /* Set Link ID with the Designated Router ID */
1033 set_linkparams_link_id(lp
, DR(oi
));
1037 /* State is undefined: Flush LSA if engaged */
1038 if (OspfMplsTE
.enabled
&&
1039 CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
))
1040 ospf_mpls_te_lsa_schedule(lp
, FLUSH_THIS_LSA
);
1044 if (IS_DEBUG_OSPF_TE
)
1046 "MPLS-TE (%s): Add Link-ID %s for interface %s ",
1047 __func__
, inet_ntoa(lp
->link_id
.value
), oi
->ifp
->name
);
1049 /* Try to Schedule LSA */
1050 if (OspfMplsTE
.enabled
) {
1051 if (CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
))
1052 ospf_mpls_te_lsa_schedule(lp
, REFRESH_THIS_LSA
);
1054 ospf_mpls_te_lsa_schedule(lp
, REORIGINATE_THIS_LSA
);
1059 /*------------------------------------------------------------------------*
1060 * Followings are OSPF protocol processing functions for MPLS-TE.
1061 *------------------------------------------------------------------------*/
1063 static void build_tlv_header(struct stream
*s
, struct tlv_header
*tlvh
)
1065 stream_put(s
, tlvh
, sizeof(struct tlv_header
));
1069 static void build_router_tlv(struct stream
*s
)
1071 struct tlv_header
*tlvh
= &OspfMplsTE
.router_addr
.header
;
1072 if (ntohs(tlvh
->type
) != 0) {
1073 build_tlv_header(s
, tlvh
);
1074 stream_put(s
, TLV_DATA(tlvh
), TLV_BODY_SIZE(tlvh
));
1079 static void build_link_subtlv(struct stream
*s
, struct tlv_header
*tlvh
)
1082 if ((tlvh
!= NULL
) && (ntohs(tlvh
->type
) != 0)) {
1083 build_tlv_header(s
, tlvh
);
1084 stream_put(s
, TLV_DATA(tlvh
), TLV_BODY_SIZE(tlvh
));
1089 static void build_link_tlv(struct stream
*s
, struct mpls_te_link
*lp
)
1091 set_linkparams_link_header(lp
);
1092 build_tlv_header(s
, &lp
->link_header
.header
);
1094 build_link_subtlv(s
, &lp
->link_type
.header
);
1095 build_link_subtlv(s
, &lp
->link_id
.header
);
1096 build_link_subtlv(s
, &lp
->lclif_ipaddr
.header
);
1097 build_link_subtlv(s
, &lp
->rmtif_ipaddr
.header
);
1098 build_link_subtlv(s
, &lp
->te_metric
.header
);
1099 build_link_subtlv(s
, &lp
->max_bw
.header
);
1100 build_link_subtlv(s
, &lp
->max_rsv_bw
.header
);
1101 build_link_subtlv(s
, &lp
->unrsv_bw
.header
);
1102 build_link_subtlv(s
, &lp
->rsc_clsclr
.header
);
1103 build_link_subtlv(s
, &lp
->lrrid
.header
);
1104 build_link_subtlv(s
, &lp
->llri
.header
);
1105 build_link_subtlv(s
, &lp
->rip
.header
);
1106 build_link_subtlv(s
, &lp
->ras
.header
);
1107 build_link_subtlv(s
, &lp
->av_delay
.header
);
1108 build_link_subtlv(s
, &lp
->mm_delay
.header
);
1109 build_link_subtlv(s
, &lp
->delay_var
.header
);
1110 build_link_subtlv(s
, &lp
->pkt_loss
.header
);
1111 build_link_subtlv(s
, &lp
->res_bw
.header
);
1112 build_link_subtlv(s
, &lp
->ava_bw
.header
);
1113 build_link_subtlv(s
, &lp
->use_bw
.header
);
1118 static void ospf_mpls_te_lsa_body_set(struct stream
*s
, struct mpls_te_link
*lp
)
1121 * The router address TLV is type 1, and ...
1122 * It must appear in exactly one
1123 * Traffic Engineering LSA originated by a router.
1125 build_router_tlv(s
);
1128 * Only one Link TLV shall be carried in each LSA, allowing for fine
1129 * granularity changes in topology.
1131 build_link_tlv(s
, lp
);
1135 /* Create new opaque-LSA. */
1136 static struct ospf_lsa
*ospf_mpls_te_lsa_new(struct ospf
*ospf
,
1137 struct ospf_area
*area
,
1138 struct mpls_te_link
*lp
)
1141 struct lsa_header
*lsah
;
1142 struct ospf_lsa
*new = NULL
;
1143 uint8_t options
, lsa_type
= 0;
1144 struct in_addr lsa_id
;
1148 /* Create a stream for LSA. */
1149 s
= stream_new(OSPF_MAX_LSA_SIZE
);
1150 lsah
= (struct lsa_header
*)STREAM_DATA(s
);
1152 options
= OSPF_OPTION_O
; /* Don't forget this :-) */
1154 /* Set opaque-LSA header fields depending of the type of RFC */
1155 if (IS_INTER_AS(lp
->type
)) {
1156 if (IS_FLOOD_AS(lp
->type
)) {
1157 /* Enable AS external as we flood Inter-AS with Opaque
1160 options
|= OSPF_OPTION_E
;
1161 lsa_type
= OSPF_OPAQUE_AS_LSA
;
1163 options
|= LSA_OPTIONS_GET(
1164 area
); /* Get area default option */
1165 options
|= LSA_OPTIONS_NSSA_GET(area
);
1166 lsa_type
= OSPF_OPAQUE_AREA_LSA
;
1168 tmp
= SET_OPAQUE_LSID(OPAQUE_TYPE_INTER_AS_LSA
, lp
->instance
);
1169 lsa_id
.s_addr
= htonl(tmp
);
1176 lsa_header_set(s
, options
, lsa_type
, lsa_id
, ospf
->router_id
);
1178 options
|= LSA_OPTIONS_GET(area
); /* Get area default option */
1179 options
|= LSA_OPTIONS_NSSA_GET(area
);
1180 lsa_type
= OSPF_OPAQUE_AREA_LSA
;
1181 tmp
= SET_OPAQUE_LSID(OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA
,
1183 lsa_id
.s_addr
= htonl(tmp
);
1184 lsa_header_set(s
, options
, lsa_type
, lsa_id
,
1185 area
->ospf
->router_id
);
1188 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
))
1190 "LSA[Type%d:%s]: Create an Opaque-LSA/MPLS-TE instance",
1191 lsa_type
, inet_ntoa(lsa_id
));
1193 /* Set opaque-LSA body fields. */
1194 ospf_mpls_te_lsa_body_set(s
, lp
);
1197 length
= stream_get_endp(s
);
1198 lsah
->length
= htons(length
);
1200 /* Now, create an OSPF LSA instance. */
1201 new = ospf_lsa_new_and_data(length
);
1203 new->vrf_id
= ospf
->vrf_id
;
1204 if (area
&& area
->ospf
)
1205 new->vrf_id
= area
->ospf
->vrf_id
;
1207 SET_FLAG(new->flags
, OSPF_LSA_SELF
);
1208 memcpy(new->data
, lsah
, length
);
1214 static int ospf_mpls_te_lsa_originate1(struct ospf_area
*area
,
1215 struct mpls_te_link
*lp
)
1217 struct ospf_lsa
*new = NULL
;
1220 /* Create new Opaque-LSA/MPLS-TE instance. */
1221 new = ospf_mpls_te_lsa_new(area
->ospf
, area
, lp
);
1224 EC_OSPF_TE_UNEXPECTED
,
1225 "ospf_mpls_te_lsa_originate1: ospf_mpls_te_lsa_new() ?");
1229 /* Install this LSA into LSDB. */
1230 if (ospf_lsa_install(area
->ospf
, NULL
/*oi*/, new) == NULL
) {
1231 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE
,
1232 "ospf_mpls_te_lsa_originate1: ospf_lsa_install() ?");
1233 ospf_lsa_unlock(&new);
1237 /* Now this link-parameter entry has associated LSA. */
1238 SET_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
);
1239 /* Update new LSA origination count. */
1240 area
->ospf
->lsa_originate_count
++;
1242 /* Flood new LSA through area. */
1243 ospf_flood_through_area(area
, NULL
/*nbr*/, new);
1245 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1246 char area_id
[INET_ADDRSTRLEN
];
1247 strlcpy(area_id
, inet_ntoa(area
->area_id
), sizeof(area_id
));
1249 "LSA[Type%d:%s]: Originate Opaque-LSA/MPLS-TE: Area(%s), Link(%s)",
1250 new->data
->type
, inet_ntoa(new->data
->id
), area_id
,
1252 ospf_lsa_header_dump(new->data
);
1259 static int ospf_mpls_te_lsa_originate_area(void *arg
)
1261 struct ospf_area
*area
= (struct ospf_area
*)arg
;
1262 struct listnode
*node
, *nnode
;
1263 struct mpls_te_link
*lp
;
1266 if (!OspfMplsTE
.enabled
) {
1268 "ospf_mpls_te_lsa_originate_area: MPLS-TE is disabled now.");
1269 rc
= 0; /* This is not an error case. */
1273 for (ALL_LIST_ELEMENTS(OspfMplsTE
.iflist
, node
, nnode
, lp
)) {
1274 /* Process only enabled LSA with area scope flooding */
1275 if (!CHECK_FLAG(lp
->flags
, LPFLG_LSA_ACTIVE
)
1276 || IS_FLOOD_AS(lp
->type
))
1279 if (lp
->area
== NULL
)
1282 if (!IPV4_ADDR_SAME(&lp
->area
->area_id
, &area
->area_id
))
1285 if (CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
)) {
1286 if (CHECK_FLAG(lp
->flags
, LPFLG_LSA_FORCED_REFRESH
)) {
1287 UNSET_FLAG(lp
->flags
, LPFLG_LSA_FORCED_REFRESH
);
1289 "OSPF MPLS-TE (ospf_mpls_te_lsa_originate_area): Refresh instead of Originate");
1290 ospf_mpls_te_lsa_schedule(lp
, REFRESH_THIS_LSA
);
1295 if (!is_mandated_params_set(lp
)) {
1297 "ospf_mpls_te_lsa_originate_area: Link(%s) lacks some mandated MPLS-TE parameters.",
1298 lp
->ifp
? lp
->ifp
->name
: "?");
1302 /* Ok, let's try to originate an LSA for this area and Link. */
1303 if (IS_DEBUG_OSPF_TE
)
1305 "MPLS-TE(ospf_mpls_te_lsa_originate_area) Let's finally reoriginate the LSA %d through the Area %s for Link %s",
1306 lp
->instance
, inet_ntoa(area
->area_id
),
1307 lp
->ifp
? lp
->ifp
->name
: "?");
1308 if (ospf_mpls_te_lsa_originate1(area
, lp
) != 0)
1316 static int ospf_mpls_te_lsa_originate2(struct ospf
*top
,
1317 struct mpls_te_link
*lp
)
1319 struct ospf_lsa
*new;
1322 /* Create new Opaque-LSA/Inter-AS instance. */
1323 new = ospf_mpls_te_lsa_new(top
, NULL
, lp
);
1326 EC_OSPF_LSA_UNEXPECTED
,
1327 "ospf_mpls_te_lsa_originate2: ospf_router_info_lsa_new() ?");
1330 new->vrf_id
= top
->vrf_id
;
1332 /* Install this LSA into LSDB. */
1333 if (ospf_lsa_install(top
, NULL
/*oi */, new) == NULL
) {
1334 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE
,
1335 "ospf_mpls_te_lsa_originate2: ospf_lsa_install() ?");
1336 ospf_lsa_unlock(&new);
1340 /* Now this Router Info parameter entry has associated LSA. */
1341 SET_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
);
1342 /* Update new LSA origination count. */
1343 top
->lsa_originate_count
++;
1345 /* Flood new LSA through AS. */
1346 ospf_flood_through_as(top
, NULL
/*nbr */, new);
1348 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1350 "LSA[Type%d:%s]: Originate Opaque-LSA/MPLS-TE Inter-AS",
1351 new->data
->type
, inet_ntoa(new->data
->id
));
1352 ospf_lsa_header_dump(new->data
);
1359 static int ospf_mpls_te_lsa_originate_as(void *arg
)
1362 struct ospf_area
*area
;
1363 struct listnode
*node
, *nnode
;
1364 struct mpls_te_link
*lp
;
1367 if ((!OspfMplsTE
.enabled
) || (OspfMplsTE
.inter_as
== Off
)) {
1369 "ospf_mpls_te_lsa_originate_as: MPLS-TE Inter-AS is disabled for now.");
1370 rc
= 0; /* This is not an error case. */
1374 for (ALL_LIST_ELEMENTS(OspfMplsTE
.iflist
, node
, nnode
, lp
)) {
1375 /* Process only enabled INTER_AS Links or Pseudo-Links */
1376 if (!CHECK_FLAG(lp
->flags
, LPFLG_LSA_ACTIVE
)
1377 || !IS_INTER_AS(lp
->type
))
1380 if (CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
)) {
1381 if (CHECK_FLAG(lp
->flags
, LPFLG_LSA_FORCED_REFRESH
)) {
1382 UNSET_FLAG(lp
->flags
, LPFLG_LSA_FORCED_REFRESH
);
1383 ospf_mpls_te_lsa_schedule(lp
, REFRESH_THIS_LSA
);
1388 if (!is_mandated_params_set(lp
)) {
1390 EC_OSPF_TE_UNEXPECTED
,
1391 "ospf_mpls_te_lsa_originate_as: Link(%s) lacks some mandated MPLS-TE parameters.",
1392 lp
->ifp
? lp
->ifp
->name
: "?");
1396 /* Ok, let's try to originate an LSA for this AS and Link. */
1397 if (IS_DEBUG_OSPF_TE
)
1399 "MPLS-TE(ospf_mpls_te_lsa_originate_as) Let's finally re-originate the Inter-AS LSA %d through the %s for Link %s",
1401 IS_FLOOD_AS(lp
->type
) ? "AS" : "Area",
1402 lp
->ifp
? lp
->ifp
->name
: "Unknown");
1404 if (IS_FLOOD_AS(lp
->type
)) {
1405 top
= (struct ospf
*)arg
;
1406 ospf_mpls_te_lsa_originate2(top
, lp
);
1408 area
= (struct ospf_area
*)arg
;
1409 ospf_mpls_te_lsa_originate1(area
, lp
);
1417 static struct ospf_lsa
*ospf_mpls_te_lsa_refresh(struct ospf_lsa
*lsa
)
1419 struct mpls_te_link
*lp
;
1420 struct ospf_area
*area
= lsa
->area
;
1422 struct ospf_lsa
*new = NULL
;
1424 if (!OspfMplsTE
.enabled
) {
1426 * This LSA must have flushed before due to MPLS-TE status
1428 * It seems a slip among routers in the routing domain.
1430 zlog_info("ospf_mpls_te_lsa_refresh: MPLS-TE is disabled now.");
1432 htons(OSPF_LSA_MAXAGE
); /* Flush it anyway. */
1435 /* At first, resolve lsa/lp relationship. */
1436 if ((lp
= lookup_linkparams_by_instance(lsa
)) == NULL
) {
1437 flog_warn(EC_OSPF_TE_UNEXPECTED
,
1438 "ospf_mpls_te_lsa_refresh: Invalid parameter?");
1440 htons(OSPF_LSA_MAXAGE
); /* Flush it anyway. */
1441 ospf_opaque_lsa_flush_schedule(lsa
);
1445 /* Check if lp was not disable in the interval */
1446 if (!CHECK_FLAG(lp
->flags
, LPFLG_LSA_ACTIVE
)) {
1448 EC_OSPF_TE_UNEXPECTED
,
1449 "ospf_mpls_te_lsa_refresh: lp was disabled: Flush it!");
1451 htons(OSPF_LSA_MAXAGE
); /* Flush it anyway. */
1454 /* If the lsa's age reached to MaxAge, start flushing procedure. */
1455 if (IS_LSA_MAXAGE(lsa
)) {
1456 UNSET_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
);
1457 ospf_opaque_lsa_flush_schedule(lsa
);
1460 top
= ospf_lookup_by_vrf_id(lsa
->vrf_id
);
1461 /* Create new Opaque-LSA/MPLS-TE instance. */
1462 new = ospf_mpls_te_lsa_new(top
, area
, lp
);
1464 flog_warn(EC_OSPF_TE_UNEXPECTED
,
1465 "ospf_mpls_te_lsa_refresh: ospf_mpls_te_lsa_new() ?");
1468 new->data
->ls_seqnum
= lsa_seqnum_increment(lsa
);
1470 /* Install this LSA into LSDB. */
1471 /* Given "lsa" will be freed in the next function. */
1472 /* As area could be NULL i.e. when using OPAQUE_LSA_AS, we prefer to use
1473 * ospf_lookup() to get ospf instance */
1477 if (ospf_lsa_install(top
, NULL
/*oi */, new) == NULL
) {
1478 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE
,
1479 "ospf_mpls_te_lsa_refresh: ospf_lsa_install() ?");
1480 ospf_lsa_unlock(&new);
1484 /* Flood updated LSA through AS or Area depending of the RFC of the link
1486 if (IS_FLOOD_AS(lp
->type
))
1487 ospf_flood_through_as(top
, NULL
, new);
1489 ospf_flood_through_area(area
, NULL
/*nbr*/, new);
1491 /* Debug logging. */
1492 if (IS_DEBUG_OSPF(lsa
, LSA_GENERATE
)) {
1493 zlog_debug("LSA[Type%d:%s]: Refresh Opaque-LSA/MPLS-TE",
1494 new->data
->type
, inet_ntoa(new->data
->id
));
1495 ospf_lsa_header_dump(new->data
);
1501 void ospf_mpls_te_lsa_schedule(struct mpls_te_link
*lp
, enum lsa_opcode opcode
)
1503 struct ospf_lsa lsa
;
1504 struct lsa_header lsah
;
1508 memset(&lsa
, 0, sizeof(lsa
));
1509 memset(&lsah
, 0, sizeof(lsah
));
1510 top
= ospf_lookup_by_vrf_id(VRF_DEFAULT
);
1512 /* Check if the pseudo link is ready to flood */
1513 if (!(CHECK_FLAG(lp
->flags
, LPFLG_LSA_ACTIVE
))
1514 || !(IS_FLOOD_AREA(lp
->type
) || IS_FLOOD_AS(lp
->type
))) {
1518 lsa
.area
= lp
->area
;
1520 if (IS_FLOOD_AS(lp
->type
)) {
1521 lsah
.type
= OSPF_OPAQUE_AS_LSA
;
1522 tmp
= SET_OPAQUE_LSID(OPAQUE_TYPE_INTER_AS_LSA
, lp
->instance
);
1523 lsah
.id
.s_addr
= htonl(tmp
);
1525 lsah
.type
= OSPF_OPAQUE_AREA_LSA
;
1526 if (IS_INTER_AS(lp
->type
)) {
1527 /* Set the area context if not know */
1528 if (lp
->area
== NULL
)
1529 lp
->area
= ospf_area_lookup_by_area_id(
1530 top
, OspfMplsTE
.interas_areaid
);
1531 /* Unable to set the area context. Abort! */
1532 if (lp
->area
== NULL
) {
1534 EC_OSPF_TE_UNEXPECTED
,
1535 "MPLS-TE(ospf_mpls_te_lsa_schedule) Area context is null. Abort !");
1538 tmp
= SET_OPAQUE_LSID(OPAQUE_TYPE_INTER_AS_LSA
,
1541 tmp
= SET_OPAQUE_LSID(
1542 OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA
,
1544 lsah
.id
.s_addr
= htonl(tmp
);
1548 case REORIGINATE_THIS_LSA
:
1549 if (IS_FLOOD_AS(lp
->type
)) {
1550 ospf_opaque_lsa_reoriginate_schedule(
1551 (void *)top
, OSPF_OPAQUE_AS_LSA
,
1552 OPAQUE_TYPE_INTER_AS_LSA
);
1556 if (IS_FLOOD_AREA(lp
->type
)) {
1557 if (IS_INTER_AS(lp
->type
))
1558 ospf_opaque_lsa_reoriginate_schedule(
1559 (void *)lp
->area
, OSPF_OPAQUE_AREA_LSA
,
1560 OPAQUE_TYPE_INTER_AS_LSA
);
1562 ospf_opaque_lsa_reoriginate_schedule(
1563 (void *)lp
->area
, OSPF_OPAQUE_AREA_LSA
,
1564 OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA
);
1568 case REFRESH_THIS_LSA
:
1569 ospf_opaque_lsa_refresh_schedule(&lsa
);
1571 case FLUSH_THIS_LSA
:
1572 /* Reset Activity flag */
1573 lp
->flags
= LPFLG_LSA_INACTIVE
;
1574 ospf_opaque_lsa_flush_schedule(&lsa
);
1577 flog_warn(EC_OSPF_TE_UNEXPECTED
,
1578 "ospf_mpls_te_lsa_schedule: Unknown opcode (%u)",
1587 /*------------------------------------------------------------------------*
1588 * Followings are vty session control functions.
1589 *------------------------------------------------------------------------*/
1591 static uint16_t show_vty_router_addr(struct vty
*vty
, struct tlv_header
*tlvh
)
1593 struct te_tlv_router_addr
*top
= (struct te_tlv_router_addr
*)tlvh
;
1596 vty_out(vty
, " Router-Address: %s\n", inet_ntoa(top
->value
));
1598 zlog_debug(" Router-Address: %s", inet_ntoa(top
->value
));
1600 return TLV_SIZE(tlvh
);
1603 static uint16_t show_vty_link_header(struct vty
*vty
, struct tlv_header
*tlvh
)
1605 struct te_tlv_link
*top
= (struct te_tlv_link
*)tlvh
;
1608 vty_out(vty
, " Link: %u octets of data\n",
1609 ntohs(top
->header
.length
));
1611 zlog_debug(" Link: %u octets of data",
1612 ntohs(top
->header
.length
));
1614 return TLV_HDR_SIZE
; /* Here is special, not "TLV_SIZE". */
1617 static uint16_t show_vty_link_subtlv_link_type(struct vty
*vty
,
1618 struct tlv_header
*tlvh
)
1620 struct te_link_subtlv_link_type
*top
;
1621 const char *cp
= "Unknown";
1623 top
= (struct te_link_subtlv_link_type
*)tlvh
;
1624 switch (top
->link_type
.value
) {
1625 case LINK_TYPE_SUBTLV_VALUE_PTP
:
1626 cp
= "Point-to-point";
1628 case LINK_TYPE_SUBTLV_VALUE_MA
:
1636 vty_out(vty
, " Link-Type: %s (%u)\n", cp
,
1637 top
->link_type
.value
);
1639 zlog_debug(" Link-Type: %s (%u)", cp
, top
->link_type
.value
);
1641 return TLV_SIZE(tlvh
);
1644 static uint16_t show_vty_link_subtlv_link_id(struct vty
*vty
,
1645 struct tlv_header
*tlvh
)
1647 struct te_link_subtlv_link_id
*top
;
1649 top
= (struct te_link_subtlv_link_id
*)tlvh
;
1651 vty_out(vty
, " Link-ID: %s\n", inet_ntoa(top
->value
));
1653 zlog_debug(" Link-ID: %s", inet_ntoa(top
->value
));
1655 return TLV_SIZE(tlvh
);
1658 static uint16_t show_vty_link_subtlv_lclif_ipaddr(struct vty
*vty
,
1659 struct tlv_header
*tlvh
)
1661 struct te_link_subtlv_lclif_ipaddr
*top
;
1664 top
= (struct te_link_subtlv_lclif_ipaddr
*)tlvh
;
1665 n
= ntohs(tlvh
->length
) / sizeof(top
->value
[0]);
1668 vty_out(vty
, " Local Interface IP Address(es): %d\n", n
);
1670 zlog_debug(" Local Interface IP Address(es): %d", n
);
1672 for (i
= 0; i
< n
; i
++) {
1674 vty_out(vty
, " #%d: %s\n", i
,
1675 inet_ntoa(top
->value
[i
]));
1677 zlog_debug(" #%d: %s", i
,
1678 inet_ntoa(top
->value
[i
]));
1680 return TLV_SIZE(tlvh
);
1683 static uint16_t show_vty_link_subtlv_rmtif_ipaddr(struct vty
*vty
,
1684 struct tlv_header
*tlvh
)
1686 struct te_link_subtlv_rmtif_ipaddr
*top
;
1689 top
= (struct te_link_subtlv_rmtif_ipaddr
*)tlvh
;
1690 n
= ntohs(tlvh
->length
) / sizeof(top
->value
[0]);
1692 vty_out(vty
, " Remote Interface IP Address(es): %d\n", n
);
1694 zlog_debug(" Remote Interface IP Address(es): %d", n
);
1696 for (i
= 0; i
< n
; i
++) {
1698 vty_out(vty
, " #%d: %s\n", i
,
1699 inet_ntoa(top
->value
[i
]));
1701 zlog_debug(" #%d: %s", i
,
1702 inet_ntoa(top
->value
[i
]));
1704 return TLV_SIZE(tlvh
);
1707 static uint16_t show_vty_link_subtlv_te_metric(struct vty
*vty
,
1708 struct tlv_header
*tlvh
)
1710 struct te_link_subtlv_te_metric
*top
;
1712 top
= (struct te_link_subtlv_te_metric
*)tlvh
;
1714 vty_out(vty
, " Traffic Engineering Metric: %u\n",
1715 (uint32_t)ntohl(top
->value
));
1717 zlog_debug(" Traffic Engineering Metric: %u",
1718 (uint32_t)ntohl(top
->value
));
1720 return TLV_SIZE(tlvh
);
1723 static uint16_t show_vty_link_subtlv_max_bw(struct vty
*vty
,
1724 struct tlv_header
*tlvh
)
1726 struct te_link_subtlv_max_bw
*top
;
1729 top
= (struct te_link_subtlv_max_bw
*)tlvh
;
1730 fval
= ntohf(top
->value
);
1733 vty_out(vty
, " Maximum Bandwidth: %g (Bytes/sec)\n", fval
);
1735 zlog_debug(" Maximum Bandwidth: %g (Bytes/sec)", fval
);
1737 return TLV_SIZE(tlvh
);
1740 static uint16_t show_vty_link_subtlv_max_rsv_bw(struct vty
*vty
,
1741 struct tlv_header
*tlvh
)
1743 struct te_link_subtlv_max_rsv_bw
*top
;
1746 top
= (struct te_link_subtlv_max_rsv_bw
*)tlvh
;
1747 fval
= ntohf(top
->value
);
1750 vty_out(vty
, " Maximum Reservable Bandwidth: %g (Bytes/sec)\n",
1753 zlog_debug(" Maximum Reservable Bandwidth: %g (Bytes/sec)",
1756 return TLV_SIZE(tlvh
);
1759 static uint16_t show_vty_link_subtlv_unrsv_bw(struct vty
*vty
,
1760 struct tlv_header
*tlvh
)
1762 struct te_link_subtlv_unrsv_bw
*top
;
1766 top
= (struct te_link_subtlv_unrsv_bw
*)tlvh
;
1769 " Unreserved Bandwidth per Class Type in Byte/s:\n");
1772 " Unreserved Bandwidth per Class Type in Byte/s:");
1773 for (i
= 0; i
< MAX_CLASS_TYPE
; i
+= 2) {
1774 fval1
= ntohf(top
->value
[i
]);
1775 fval2
= ntohf(top
->value
[i
+ 1]);
1779 " [%d]: %g (Bytes/sec),\t[%d]: %g (Bytes/sec)\n",
1780 i
, fval1
, i
+ 1, fval2
);
1783 " [%d]: %g (Bytes/sec), [%d]: %g (Bytes/sec)",
1784 i
, fval1
, i
+ 1, fval2
);
1787 return TLV_SIZE(tlvh
);
1790 static uint16_t show_vty_link_subtlv_rsc_clsclr(struct vty
*vty
,
1791 struct tlv_header
*tlvh
)
1793 struct te_link_subtlv_rsc_clsclr
*top
;
1795 top
= (struct te_link_subtlv_rsc_clsclr
*)tlvh
;
1797 vty_out(vty
, " Resource class/color: 0x%x\n",
1798 (uint32_t)ntohl(top
->value
));
1800 zlog_debug(" Resource Class/Color: 0x%x",
1801 (uint32_t)ntohl(top
->value
));
1803 return TLV_SIZE(tlvh
);
1806 static uint16_t show_vty_link_subtlv_lrrid(struct vty
*vty
,
1807 struct tlv_header
*tlvh
)
1809 struct te_link_subtlv_lrrid
*top
;
1811 top
= (struct te_link_subtlv_lrrid
*)tlvh
;
1814 vty_out(vty
, " Local TE Router ID: %s\n",
1815 inet_ntoa(top
->local
));
1816 vty_out(vty
, " Remote TE Router ID: %s\n",
1817 inet_ntoa(top
->remote
));
1819 zlog_debug(" Local TE Router ID: %s",
1820 inet_ntoa(top
->local
));
1821 zlog_debug(" Remote TE Router ID: %s",
1822 inet_ntoa(top
->remote
));
1825 return TLV_SIZE(tlvh
);
1828 static uint16_t show_vty_link_subtlv_llri(struct vty
*vty
,
1829 struct tlv_header
*tlvh
)
1831 struct te_link_subtlv_llri
*top
;
1833 top
= (struct te_link_subtlv_llri
*)tlvh
;
1836 vty_out(vty
, " Link Local ID: %d\n",
1837 (uint32_t)ntohl(top
->local
));
1838 vty_out(vty
, " Link Remote ID: %d\n",
1839 (uint32_t)ntohl(top
->remote
));
1841 zlog_debug(" Link Local ID: %d",
1842 (uint32_t)ntohl(top
->local
));
1843 zlog_debug(" Link Remote ID: %d",
1844 (uint32_t)ntohl(top
->remote
));
1847 return TLV_SIZE(tlvh
);
1850 static uint16_t show_vty_link_subtlv_rip(struct vty
*vty
,
1851 struct tlv_header
*tlvh
)
1853 struct te_link_subtlv_rip
*top
;
1855 top
= (struct te_link_subtlv_rip
*)tlvh
;
1858 vty_out(vty
, " Inter-AS TE Remote ASBR IP address: %s\n",
1859 inet_ntoa(top
->value
));
1861 zlog_debug(" Inter-AS TE Remote ASBR IP address: %s",
1862 inet_ntoa(top
->value
));
1864 return TLV_SIZE(tlvh
);
1867 static uint16_t show_vty_link_subtlv_ras(struct vty
*vty
,
1868 struct tlv_header
*tlvh
)
1870 struct te_link_subtlv_ras
*top
;
1872 top
= (struct te_link_subtlv_ras
*)tlvh
;
1875 vty_out(vty
, " Inter-AS TE Remote AS number: %u\n",
1878 zlog_debug(" Inter-AS TE Remote AS number: %u",
1881 return TLV_SIZE(tlvh
);
1884 static uint16_t show_vty_link_subtlv_av_delay(struct vty
*vty
,
1885 struct tlv_header
*tlvh
)
1887 struct te_link_subtlv_av_delay
*top
;
1891 top
= (struct te_link_subtlv_av_delay
*)tlvh
;
1892 delay
= (uint32_t)ntohl(top
->value
) & TE_EXT_MASK
;
1893 anomalous
= (uint32_t)ntohl(top
->value
) & TE_EXT_ANORMAL
;
1896 vty_out(vty
, " %s Average Link Delay: %d (micro-sec)\n",
1897 anomalous
? "Anomalous" : "Normal", delay
);
1899 zlog_debug(" %s Average Link Delay: %d (micro-sec)",
1900 anomalous
? "Anomalous" : "Normal", delay
);
1902 return TLV_SIZE(tlvh
);
1905 static uint16_t show_vty_link_subtlv_mm_delay(struct vty
*vty
,
1906 struct tlv_header
*tlvh
)
1908 struct te_link_subtlv_mm_delay
*top
;
1912 top
= (struct te_link_subtlv_mm_delay
*)tlvh
;
1913 low
= (uint32_t)ntohl(top
->low
) & TE_EXT_MASK
;
1914 anomalous
= (uint32_t)ntohl(top
->low
) & TE_EXT_ANORMAL
;
1915 high
= (uint32_t)ntohl(top
->high
);
1918 vty_out(vty
, " %s Min/Max Link Delay: %d/%d (micro-sec)\n",
1919 anomalous
? "Anomalous" : "Normal", low
, high
);
1921 zlog_debug(" %s Min/Max Link Delay: %d/%d (micro-sec)",
1922 anomalous
? "Anomalous" : "Normal", low
, high
);
1924 return TLV_SIZE(tlvh
);
1927 static uint16_t show_vty_link_subtlv_delay_var(struct vty
*vty
,
1928 struct tlv_header
*tlvh
)
1930 struct te_link_subtlv_delay_var
*top
;
1933 top
= (struct te_link_subtlv_delay_var
*)tlvh
;
1934 jitter
= (uint32_t)ntohl(top
->value
) & TE_EXT_MASK
;
1937 vty_out(vty
, " Delay Variation: %d (micro-sec)\n", jitter
);
1939 zlog_debug(" Delay Variation: %d (micro-sec)", jitter
);
1941 return TLV_SIZE(tlvh
);
1944 static uint16_t show_vty_link_subtlv_pkt_loss(struct vty
*vty
,
1945 struct tlv_header
*tlvh
)
1947 struct te_link_subtlv_pkt_loss
*top
;
1952 top
= (struct te_link_subtlv_pkt_loss
*)tlvh
;
1953 loss
= (uint32_t)ntohl(top
->value
) & TE_EXT_MASK
;
1954 fval
= (float)(loss
* LOSS_PRECISION
);
1955 anomalous
= (uint32_t)ntohl(top
->value
) & TE_EXT_ANORMAL
;
1958 vty_out(vty
, " %s Link Loss: %g (%%)\n",
1959 anomalous
? "Anomalous" : "Normal", fval
);
1961 zlog_debug(" %s Link Loss: %g (%%)",
1962 anomalous
? "Anomalous" : "Normal", fval
);
1964 return TLV_SIZE(tlvh
);
1967 static uint16_t show_vty_link_subtlv_res_bw(struct vty
*vty
,
1968 struct tlv_header
*tlvh
)
1970 struct te_link_subtlv_res_bw
*top
;
1973 top
= (struct te_link_subtlv_res_bw
*)tlvh
;
1974 fval
= ntohf(top
->value
);
1978 " Unidirectional Residual Bandwidth: %g (Bytes/sec)\n",
1982 " Unidirectional Residual Bandwidth: %g (Bytes/sec)",
1985 return TLV_SIZE(tlvh
);
1988 static uint16_t show_vty_link_subtlv_ava_bw(struct vty
*vty
,
1989 struct tlv_header
*tlvh
)
1991 struct te_link_subtlv_ava_bw
*top
;
1994 top
= (struct te_link_subtlv_ava_bw
*)tlvh
;
1995 fval
= ntohf(top
->value
);
1999 " Unidirectional Available Bandwidth: %g (Bytes/sec)\n",
2003 " Unidirectional Available Bandwidth: %g (Bytes/sec)",
2006 return TLV_SIZE(tlvh
);
2009 static uint16_t show_vty_link_subtlv_use_bw(struct vty
*vty
,
2010 struct tlv_header
*tlvh
)
2012 struct te_link_subtlv_use_bw
*top
;
2015 top
= (struct te_link_subtlv_use_bw
*)tlvh
;
2016 fval
= ntohf(top
->value
);
2020 " Unidirectional Utilized Bandwidth: %g (Bytes/sec)\n",
2024 " Unidirectional Utilized Bandwidth: %g (Bytes/sec)",
2027 return TLV_SIZE(tlvh
);
2030 static uint16_t show_vty_unknown_tlv(struct vty
*vty
, struct tlv_header
*tlvh
)
2033 vty_out(vty
, " Unknown TLV: [type(0x%x), length(0x%x)]\n",
2034 ntohs(tlvh
->type
), ntohs(tlvh
->length
));
2036 zlog_debug(" Unknown TLV: [type(0x%x), length(0x%x)]",
2037 ntohs(tlvh
->type
), ntohs(tlvh
->length
));
2039 return TLV_SIZE(tlvh
);
2042 static uint16_t ospf_mpls_te_show_link_subtlv(struct vty
*vty
,
2043 struct tlv_header
*tlvh0
,
2044 uint16_t subtotal
, uint16_t total
)
2046 struct tlv_header
*tlvh
;
2047 uint16_t sum
= subtotal
;
2049 for (tlvh
= tlvh0
; sum
< total
;
2050 tlvh
= TLV_HDR_NEXT(tlvh
)) {
2051 switch (ntohs(tlvh
->type
)) {
2052 case TE_LINK_SUBTLV_LINK_TYPE
:
2053 sum
+= show_vty_link_subtlv_link_type(vty
, tlvh
);
2055 case TE_LINK_SUBTLV_LINK_ID
:
2056 sum
+= show_vty_link_subtlv_link_id(vty
, tlvh
);
2058 case TE_LINK_SUBTLV_LCLIF_IPADDR
:
2059 sum
+= show_vty_link_subtlv_lclif_ipaddr(vty
, tlvh
);
2061 case TE_LINK_SUBTLV_RMTIF_IPADDR
:
2062 sum
+= show_vty_link_subtlv_rmtif_ipaddr(vty
, tlvh
);
2064 case TE_LINK_SUBTLV_TE_METRIC
:
2065 sum
+= show_vty_link_subtlv_te_metric(vty
, tlvh
);
2067 case TE_LINK_SUBTLV_MAX_BW
:
2068 sum
+= show_vty_link_subtlv_max_bw(vty
, tlvh
);
2070 case TE_LINK_SUBTLV_MAX_RSV_BW
:
2071 sum
+= show_vty_link_subtlv_max_rsv_bw(vty
, tlvh
);
2073 case TE_LINK_SUBTLV_UNRSV_BW
:
2074 sum
+= show_vty_link_subtlv_unrsv_bw(vty
, tlvh
);
2076 case TE_LINK_SUBTLV_RSC_CLSCLR
:
2077 sum
+= show_vty_link_subtlv_rsc_clsclr(vty
, tlvh
);
2079 case TE_LINK_SUBTLV_LRRID
:
2080 sum
+= show_vty_link_subtlv_lrrid(vty
, tlvh
);
2082 case TE_LINK_SUBTLV_LLRI
:
2083 sum
+= show_vty_link_subtlv_llri(vty
, tlvh
);
2085 case TE_LINK_SUBTLV_RIP
:
2086 sum
+= show_vty_link_subtlv_rip(vty
, tlvh
);
2088 case TE_LINK_SUBTLV_RAS
:
2089 sum
+= show_vty_link_subtlv_ras(vty
, tlvh
);
2091 case TE_LINK_SUBTLV_AV_DELAY
:
2092 sum
+= show_vty_link_subtlv_av_delay(vty
, tlvh
);
2094 case TE_LINK_SUBTLV_MM_DELAY
:
2095 sum
+= show_vty_link_subtlv_mm_delay(vty
, tlvh
);
2097 case TE_LINK_SUBTLV_DELAY_VAR
:
2098 sum
+= show_vty_link_subtlv_delay_var(vty
, tlvh
);
2100 case TE_LINK_SUBTLV_PKT_LOSS
:
2101 sum
+= show_vty_link_subtlv_pkt_loss(vty
, tlvh
);
2103 case TE_LINK_SUBTLV_RES_BW
:
2104 sum
+= show_vty_link_subtlv_res_bw(vty
, tlvh
);
2106 case TE_LINK_SUBTLV_AVA_BW
:
2107 sum
+= show_vty_link_subtlv_ava_bw(vty
, tlvh
);
2109 case TE_LINK_SUBTLV_USE_BW
:
2110 sum
+= show_vty_link_subtlv_use_bw(vty
, tlvh
);
2113 sum
+= show_vty_unknown_tlv(vty
, tlvh
);
2120 static void ospf_mpls_te_show_info(struct vty
*vty
, struct ospf_lsa
*lsa
)
2122 struct lsa_header
*lsah
= lsa
->data
;
2123 struct tlv_header
*tlvh
, *next
;
2124 uint16_t sum
, total
;
2125 uint16_t (*subfunc
)(struct vty
* vty
, struct tlv_header
* tlvh
,
2126 uint16_t subtotal
, uint16_t total
) = NULL
;
2129 total
= ntohs(lsah
->length
) - OSPF_LSA_HEADER_SIZE
;
2131 for (tlvh
= TLV_HDR_TOP(lsah
); sum
< total
;
2132 tlvh
= (next
? next
: TLV_HDR_NEXT(tlvh
))) {
2133 if (subfunc
!= NULL
) {
2134 sum
= (*subfunc
)(vty
, tlvh
, sum
, total
);
2135 next
= (struct tlv_header
*)((char *)tlvh
+ sum
);
2141 switch (ntohs(tlvh
->type
)) {
2142 case TE_TLV_ROUTER_ADDR
:
2143 sum
+= show_vty_router_addr(vty
, tlvh
);
2146 sum
+= show_vty_link_header(vty
, tlvh
);
2147 subfunc
= ospf_mpls_te_show_link_subtlv
;
2148 next
= TLV_DATA(tlvh
);
2151 sum
+= show_vty_unknown_tlv(vty
, tlvh
);
2158 static void ospf_mpls_te_config_write_router(struct vty
*vty
)
2161 if (OspfMplsTE
.enabled
) {
2162 vty_out(vty
, " mpls-te on\n");
2163 vty_out(vty
, " mpls-te router-address %s\n",
2164 inet_ntoa(OspfMplsTE
.router_addr
.value
));
2167 if (OspfMplsTE
.inter_as
== AS
)
2168 vty_out(vty
, " mpls-te inter-as as\n");
2169 if (OspfMplsTE
.inter_as
== Area
)
2170 vty_out(vty
, " mpls-te inter-as area %s \n",
2171 inet_ntoa(OspfMplsTE
.interas_areaid
));
2176 /*------------------------------------------------------------------------*
2177 * Followings are vty command functions.
2178 *------------------------------------------------------------------------*/
2180 DEFUN (ospf_mpls_te_on
,
2181 ospf_mpls_te_on_cmd
,
2184 "Enable the MPLS-TE functionality\n")
2186 VTY_DECLVAR_INSTANCE_CONTEXT(ospf
, ospf
);
2187 struct listnode
*node
;
2188 struct mpls_te_link
*lp
;
2190 if (OspfMplsTE
.enabled
)
2193 if (IS_DEBUG_OSPF_EVENT
)
2194 zlog_debug("MPLS-TE: OFF -> ON");
2196 OspfMplsTE
.enabled
= true;
2198 /* Reoriginate RFC3630 & RFC6827 Links */
2199 ospf_mpls_te_foreach_area(ospf_mpls_te_lsa_schedule
,
2200 REORIGINATE_THIS_LSA
);
2202 /* Reoriginate LSA if INTER-AS is always on */
2203 if (OspfMplsTE
.inter_as
!= Off
) {
2204 for (ALL_LIST_ELEMENTS_RO(OspfMplsTE
.iflist
, node
, lp
)) {
2205 if (IS_INTER_AS(lp
->type
)) {
2206 ospf_mpls_te_lsa_schedule(lp
,
2207 REORIGINATE_THIS_LSA
);
2215 DEFUN (no_ospf_mpls_te
,
2216 no_ospf_mpls_te_cmd
,
2220 "Disable the MPLS-TE functionality\n")
2222 VTY_DECLVAR_INSTANCE_CONTEXT(ospf
, ospf
);
2223 struct listnode
*node
, *nnode
;
2224 struct mpls_te_link
*lp
;
2226 if (!OspfMplsTE
.enabled
)
2229 if (IS_DEBUG_OSPF_EVENT
)
2230 zlog_debug("MPLS-TE: ON -> OFF");
2232 OspfMplsTE
.enabled
= false;
2234 for (ALL_LIST_ELEMENTS(OspfMplsTE
.iflist
, node
, nnode
, lp
))
2235 if (CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
))
2236 ospf_mpls_te_lsa_schedule(lp
, FLUSH_THIS_LSA
);
2242 DEFUN (ospf_mpls_te_router_addr
,
2243 ospf_mpls_te_router_addr_cmd
,
2244 "mpls-te router-address A.B.C.D",
2246 "Stable IP address of the advertising router\n"
2247 "MPLS-TE router address in IPv4 address format\n")
2249 VTY_DECLVAR_INSTANCE_CONTEXT(ospf
, ospf
);
2251 struct te_tlv_router_addr
*ra
= &OspfMplsTE
.router_addr
;
2252 struct in_addr value
;
2254 if (!inet_aton(argv
[idx_ipv4
]->arg
, &value
)) {
2255 vty_out(vty
, "Please specify Router-Addr by A.B.C.D\n");
2259 if (ntohs(ra
->header
.type
) == 0
2260 || ntohl(ra
->value
.s_addr
) != ntohl(value
.s_addr
)) {
2261 struct listnode
*node
, *nnode
;
2262 struct mpls_te_link
*lp
;
2263 int need_to_reoriginate
= 0;
2265 set_mpls_te_router_addr(value
);
2267 if (!OspfMplsTE
.enabled
)
2270 for (ALL_LIST_ELEMENTS(OspfMplsTE
.iflist
, node
, nnode
, lp
)) {
2271 if ((lp
->area
== NULL
) || IS_FLOOD_AS(lp
->type
))
2274 if (!CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
)) {
2275 need_to_reoriginate
= 1;
2280 for (ALL_LIST_ELEMENTS(OspfMplsTE
.iflist
, node
, nnode
, lp
)) {
2281 if ((lp
->area
== NULL
) || IS_FLOOD_AS(lp
->type
))
2284 if (need_to_reoriginate
)
2285 SET_FLAG(lp
->flags
, LPFLG_LSA_FORCED_REFRESH
);
2287 ospf_mpls_te_lsa_schedule(lp
, REFRESH_THIS_LSA
);
2290 if (need_to_reoriginate
)
2291 ospf_mpls_te_foreach_area(ospf_mpls_te_lsa_schedule
,
2292 REORIGINATE_THIS_LSA
);
2298 static int set_inter_as_mode(struct vty
*vty
, const char *mode_name
,
2299 const char *area_id
)
2301 enum inter_as_mode mode
;
2302 struct listnode
*node
;
2303 struct mpls_te_link
*lp
;
2306 if (OspfMplsTE
.enabled
) {
2308 /* Read and Check inter_as mode */
2309 if (strcmp(mode_name
, "as") == 0)
2311 else if (strcmp(mode_name
, "area") == 0) {
2313 VTY_GET_OSPF_AREA_ID(OspfMplsTE
.interas_areaid
, format
,
2317 "Unknown mode. Please choose between as or area\n");
2321 if (IS_DEBUG_OSPF_EVENT
)
2323 "MPLS-TE: Inter-AS enable with %s flooding support",
2326 /* Register new callbacks regarding the flooding scope (AS or
2328 if (ospf_mpls_te_register(mode
) < 0) {
2330 "Internal error: Unable to register Inter-AS functions\n");
2334 /* Enable mode and re-originate LSA if needed */
2335 if ((OspfMplsTE
.inter_as
== Off
)
2336 && (mode
!= OspfMplsTE
.inter_as
)) {
2337 OspfMplsTE
.inter_as
= mode
;
2338 /* Re-originate all InterAS-TEv2 LSA */
2339 for (ALL_LIST_ELEMENTS_RO(OspfMplsTE
.iflist
, node
,
2341 if (IS_INTER_AS(lp
->type
)) {
2343 lp
->type
|= FLOOD_AS
;
2345 lp
->type
|= FLOOD_AREA
;
2346 ospf_mpls_te_lsa_schedule(
2347 lp
, REORIGINATE_THIS_LSA
);
2352 "Please change Inter-AS support to disable first before going to mode %s\n",
2357 vty_out(vty
, "mpls-te has not been turned on\n");
2364 DEFUN (ospf_mpls_te_inter_as_as
,
2365 ospf_mpls_te_inter_as_cmd
,
2366 "mpls-te inter-as as",
2368 "Configure MPLS-TE Inter-AS support\n"
2369 "AS native mode self originate INTER_AS LSA with Type 11 (as flooding scope)\n")
2371 return set_inter_as_mode(vty
, "as", "");
2374 DEFUN (ospf_mpls_te_inter_as_area
,
2375 ospf_mpls_te_inter_as_area_cmd
,
2376 "mpls-te inter-as area <A.B.C.D|(0-4294967295)>",
2378 "Configure MPLS-TE Inter-AS support\n"
2379 "AREA native mode self originate INTER_AS LSA with Type 10 (area flooding scope)\n"
2380 "OSPF area ID in IP format\n"
2381 "OSPF area ID as decimal value\n")
2383 int idx_ipv4_number
= 3;
2384 return set_inter_as_mode(vty
, "area", argv
[idx_ipv4_number
]->arg
);
2387 DEFUN (no_ospf_mpls_te_inter_as
,
2388 no_ospf_mpls_te_inter_as_cmd
,
2389 "no mpls-te inter-as",
2392 "Disable MPLS-TE Inter-AS support\n")
2395 struct listnode
*node
, *nnode
;
2396 struct mpls_te_link
*lp
;
2398 if (IS_DEBUG_OSPF_EVENT
)
2399 zlog_debug("MPLS-TE: Inter-AS support OFF");
2401 if ((OspfMplsTE
.enabled
) && (OspfMplsTE
.inter_as
!= Off
)) {
2402 /* Flush all Inter-AS LSA */
2403 for (ALL_LIST_ELEMENTS(OspfMplsTE
.iflist
, node
, nnode
, lp
))
2404 if (IS_INTER_AS(lp
->type
)
2405 && CHECK_FLAG(lp
->flags
, LPFLG_LSA_ENGAGED
))
2406 ospf_mpls_te_lsa_schedule(lp
, FLUSH_THIS_LSA
);
2408 /* Deregister the Callbacks for Inter-AS support */
2409 ospf_mpls_te_unregister();
2410 OspfMplsTE
.inter_as
= Off
;
2416 DEFUN (show_ip_ospf_mpls_te_router
,
2417 show_ip_ospf_mpls_te_router_cmd
,
2418 "show ip ospf mpls-te router",
2422 "MPLS-TE information\n"
2423 "MPLS-TE Router parameters\n")
2425 if (OspfMplsTE
.enabled
) {
2426 vty_out(vty
, "--- MPLS-TE router parameters ---\n");
2428 if (ntohs(OspfMplsTE
.router_addr
.header
.type
) != 0)
2429 show_vty_router_addr(vty
,
2430 &OspfMplsTE
.router_addr
.header
);
2432 vty_out(vty
, " N/A\n");
2437 static void show_mpls_te_link_sub(struct vty
*vty
, struct interface
*ifp
)
2439 struct mpls_te_link
*lp
;
2441 if ((OspfMplsTE
.enabled
) && HAS_LINK_PARAMS(ifp
) && !if_is_loopback(ifp
)
2443 && ((lp
= lookup_linkparams_by_ifp(ifp
)) != NULL
)) {
2444 /* Continue only if interface is not passive or support Inter-AS
2446 if (!(ospf_oi_count(ifp
) > 0)) {
2447 if (IS_INTER_AS(lp
->type
)) {
2449 "-- Inter-AS TEv2 link parameters for %s --\n",
2452 /* MPLS-TE is not activate on this interface */
2453 /* or this interface is passive and Inter-AS
2454 * TEv2 is not activate */
2456 " %s: MPLS-TE is disabled on this interface\n",
2461 vty_out(vty
, "-- MPLS-TE link parameters for %s --\n",
2465 if (TLV_TYPE(lp
->link_type
) != 0)
2466 show_vty_link_subtlv_link_type(vty
,
2467 &lp
->link_type
.header
);
2468 if (TLV_TYPE(lp
->link_id
) != 0)
2469 show_vty_link_subtlv_link_id(vty
, &lp
->link_id
.header
);
2470 if (TLV_TYPE(lp
->lclif_ipaddr
) != 0)
2471 show_vty_link_subtlv_lclif_ipaddr(
2472 vty
, &lp
->lclif_ipaddr
.header
);
2473 if (TLV_TYPE(lp
->rmtif_ipaddr
) != 0)
2474 show_vty_link_subtlv_rmtif_ipaddr(
2475 vty
, &lp
->rmtif_ipaddr
.header
);
2476 if (TLV_TYPE(lp
->rip
) != 0)
2477 show_vty_link_subtlv_rip(vty
, &lp
->rip
.header
);
2478 if (TLV_TYPE(lp
->ras
) != 0)
2479 show_vty_link_subtlv_ras(vty
, &lp
->ras
.header
);
2480 if (TLV_TYPE(lp
->te_metric
) != 0)
2481 show_vty_link_subtlv_te_metric(vty
,
2482 &lp
->te_metric
.header
);
2483 if (TLV_TYPE(lp
->max_bw
) != 0)
2484 show_vty_link_subtlv_max_bw(vty
, &lp
->max_bw
.header
);
2485 if (TLV_TYPE(lp
->max_rsv_bw
) != 0)
2486 show_vty_link_subtlv_max_rsv_bw(vty
,
2487 &lp
->max_rsv_bw
.header
);
2488 if (TLV_TYPE(lp
->unrsv_bw
) != 0)
2489 show_vty_link_subtlv_unrsv_bw(vty
,
2490 &lp
->unrsv_bw
.header
);
2491 if (TLV_TYPE(lp
->rsc_clsclr
) != 0)
2492 show_vty_link_subtlv_rsc_clsclr(vty
,
2493 &lp
->rsc_clsclr
.header
);
2494 if (TLV_TYPE(lp
->av_delay
) != 0)
2495 show_vty_link_subtlv_av_delay(vty
,
2496 &lp
->av_delay
.header
);
2497 if (TLV_TYPE(lp
->mm_delay
) != 0)
2498 show_vty_link_subtlv_mm_delay(vty
,
2499 &lp
->mm_delay
.header
);
2500 if (TLV_TYPE(lp
->delay_var
) != 0)
2501 show_vty_link_subtlv_delay_var(vty
,
2502 &lp
->delay_var
.header
);
2503 if (TLV_TYPE(lp
->pkt_loss
) != 0)
2504 show_vty_link_subtlv_pkt_loss(vty
,
2505 &lp
->pkt_loss
.header
);
2506 if (TLV_TYPE(lp
->res_bw
) != 0)
2507 show_vty_link_subtlv_res_bw(vty
, &lp
->res_bw
.header
);
2508 if (TLV_TYPE(lp
->ava_bw
) != 0)
2509 show_vty_link_subtlv_ava_bw(vty
, &lp
->ava_bw
.header
);
2510 if (TLV_TYPE(lp
->use_bw
) != 0)
2511 show_vty_link_subtlv_use_bw(vty
, &lp
->use_bw
.header
);
2512 vty_out(vty
, "---------------\n\n");
2514 vty_out(vty
, " %s: MPLS-TE is disabled on this interface\n",
2521 DEFUN (show_ip_ospf_mpls_te_link
,
2522 show_ip_ospf_mpls_te_link_cmd
,
2523 "show ip ospf [vrf <NAME|all>] mpls-te interface [INTERFACE]",
2529 "MPLS-TE information\n"
2530 "Interface information\n"
2534 int idx_interface
= 0;
2535 struct interface
*ifp
= NULL
;
2536 struct listnode
*node
;
2537 char *vrf_name
= NULL
;
2538 bool all_vrf
= false;
2541 struct ospf
*ospf
= NULL
;
2543 if (argv_find(argv
, argc
, "vrf", &idx_vrf
)) {
2544 vrf_name
= argv
[idx_vrf
+ 1]->arg
;
2545 all_vrf
= strmatch(vrf_name
, "all");
2547 argv_find(argv
, argc
, "INTERFACE", &idx_interface
);
2548 /* vrf input is provided could be all or specific vrf*/
2551 for (ALL_LIST_ELEMENTS_RO(om
->ospf
, node
, ospf
)) {
2552 if (!ospf
->oi_running
)
2554 vrf
= vrf_lookup_by_id(ospf
->vrf_id
);
2555 FOR_ALL_INTERFACES (vrf
, ifp
)
2556 show_mpls_te_link_sub(vty
, ifp
);
2560 ospf
= ospf_lookup_by_inst_name(inst
, vrf_name
);
2562 ospf
= ospf_lookup_by_vrf_id(VRF_DEFAULT
);
2563 if (ospf
== NULL
|| !ospf
->oi_running
)
2566 vrf
= vrf_lookup_by_id(ospf
->vrf_id
);
2569 if (idx_interface
) {
2570 ifp
= if_lookup_by_name(
2571 argv
[idx_interface
]->arg
,
2574 vty_out(vty
, "No such interface name in vrf %s\n",
2580 FOR_ALL_INTERFACES (vrf
, ifp
)
2581 show_mpls_te_link_sub(vty
, ifp
);
2585 show_mpls_te_link_sub(vty
, ifp
);
2589 static void ospf_mpls_te_register_vty(void)
2591 install_element(VIEW_NODE
, &show_ip_ospf_mpls_te_router_cmd
);
2592 install_element(VIEW_NODE
, &show_ip_ospf_mpls_te_link_cmd
);
2594 install_element(OSPF_NODE
, &ospf_mpls_te_on_cmd
);
2595 install_element(OSPF_NODE
, &no_ospf_mpls_te_cmd
);
2596 install_element(OSPF_NODE
, &ospf_mpls_te_router_addr_cmd
);
2597 install_element(OSPF_NODE
, &ospf_mpls_te_inter_as_cmd
);
2598 install_element(OSPF_NODE
, &ospf_mpls_te_inter_as_area_cmd
);
2599 install_element(OSPF_NODE
, &no_ospf_mpls_te_inter_as_cmd
);