]> git.proxmox.com Git - mirror_frr.git/blame - ospfd/ospf_te.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ospfd: Update TE to new Link State Edge key
[mirror_frr.git] / ospfd / ospf_te.c
CommitLineData
acddc0ed 1// SPDX-License-Identifier: GPL-2.0-or-later
718e3744 2/*
16f1b9ee 3 * This is an implementation of RFC3630
718e3744 4 * Copyright (C) 2001 KDD R&D Laboratories, Inc.
5 * http://www.kddlabs.co.jp/
6 *
16f1b9ee
OD		 7 * Copyright (C) 2012 Orange Labs
8 * http://www.orange.com
718e3744 9 */
10
16f1b9ee
OD		 11/* Add support of RFC7471 */
12/* Add support of RFC5392, RFC6827 */
718e3744 13
14#include <zebra.h>
16f1b9ee 15#include <math.h>
718e3744 16
718e3744 17#include "linklist.h"
18#include "prefix.h"
b2d7c082 19#include "vrf.h"
718e3744 20#include "if.h"
21#include "table.h"
22#include "memory.h"
23#include "command.h"
24#include "vty.h"
25#include "stream.h"
26#include "log.h"
24a58196 27#include "frrevent.h"
718e3744 28#include "hash.h"
d62a17ae 29#include "sockunion.h" /* for inet_aton() */
16f1b9ee 30#include "network.h"
f173deb3
OD		 31#include "link_state.h"
32#include "zclient.h"
33#include "printfrr.h"
718e3744 34
35#include "ospfd/ospfd.h"
36#include "ospfd/ospf_interface.h"
37#include "ospfd/ospf_ism.h"
38#include "ospfd/ospf_asbr.h"
39#include "ospfd/ospf_lsa.h"
40#include "ospfd/ospf_lsdb.h"
41#include "ospfd/ospf_neighbor.h"
42#include "ospfd/ospf_nsm.h"
43#include "ospfd/ospf_flood.h"
44#include "ospfd/ospf_packet.h"
45#include "ospfd/ospf_spf.h"
46#include "ospfd/ospf_dump.h"
47#include "ospfd/ospf_route.h"
48#include "ospfd/ospf_ase.h"
49#include "ospfd/ospf_zebra.h"
50#include "ospfd/ospf_te.h"
f173deb3
OD		 51#include "ospfd/ospf_sr.h"
52#include "ospfd/ospf_ri.h"
53#include "ospfd/ospf_ext.h"
16f1b9ee 54#include "ospfd/ospf_vty.h"
85c9b439 55#include "ospfd/ospf_errors.h"
718e3744 56
57/*
58 * Global variable to manage Opaque-LSA/MPLS-TE on this node.
59 * Note that all parameter values are stored in network byte order.
60 */
16f1b9ee 61struct ospf_mpls_te OspfMplsTE;
718e3744 62
2b64873d 63static const char *const mode2text[] = {"Off", "AS", "Area"};
718e3744 64
f173deb3 65
718e3744 66/*------------------------------------------------------------------------*
78dfa0c7 67 * Following are initialize/terminate functions for MPLS-TE handling.
718e3744 68 *------------------------------------------------------------------------*/
69
d62a17ae 70static int ospf_mpls_te_new_if(struct interface *ifp);
71static int ospf_mpls_te_del_if(struct interface *ifp);
72static void ospf_mpls_te_ism_change(struct ospf_interface *oi, int old_status);
73static void ospf_mpls_te_nsm_change(struct ospf_neighbor *nbr, int old_status);
74static void ospf_mpls_te_config_write_router(struct vty *vty);
3e63092b
RW		 75static void ospf_mpls_te_show_info(struct vty *vty, struct json_object *json,
76 struct ospf_lsa *lsa);
d62a17ae 77static int ospf_mpls_te_lsa_originate_area(void *arg);
2efd7e2b
OD		 78static int ospf_mpls_te_lsa_inter_as_as(void *arg);
79static int ospf_mpls_te_lsa_inter_as_area(void *arg);
d62a17ae 80static struct ospf_lsa *ospf_mpls_te_lsa_refresh(struct ospf_lsa *lsa);
f173deb3
OD		 81static int ospf_mpls_te_lsa_update(struct ospf_lsa *lsa);
82static int ospf_mpls_te_lsa_delete(struct ospf_lsa *lsa);
d62a17ae 83
84static void del_mpls_te_link(void *val);
85static void ospf_mpls_te_register_vty(void);
86
87int ospf_mpls_te_init(void)
88{
89 int rc;
90
2efd7e2b 91 /* Register Opaque AREA LSA Type 1 for Traffic Engineering */
d62a17ae 92 rc = ospf_register_opaque_functab(
f173deb3
OD		 93 OSPF_OPAQUE_AREA_LSA,
94 OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA,
95 ospf_mpls_te_new_if,
96 ospf_mpls_te_del_if,
97 ospf_mpls_te_ism_change,
98 ospf_mpls_te_nsm_change,
718e3744 99 ospf_mpls_te_config_write_router,
f173deb3 100 NULL, /* ospf_mpls_te_config_write_if */
d62a17ae 101 NULL, /* ospf_mpls_te_config_write_debug */
102 ospf_mpls_te_show_info, ospf_mpls_te_lsa_originate_area,
f173deb3
OD		 103 ospf_mpls_te_lsa_refresh,
104 ospf_mpls_te_lsa_update, /* ospf_mpls_te_new_lsa_hook */
105 ospf_mpls_te_lsa_delete /* ospf_mpls_te_del_lsa_hook */);
d62a17ae 106 if (rc != 0) {
ade6974d 107 flog_warn(
cf444bcf 108 EC_OSPF_OPAQUE_REGISTRATION,
fd3c7692
OD		 109 "MPLS-TE (%s): Failed to register Traffic Engineering functions",
110 __func__);
ead99d5f 111 return rc;
d62a17ae 112 }
718e3744 113
2efd7e2b
OD		 114 /*
115 * Wee need also to register Opaque LSA Type 6 i.e. Inter-AS RFC5392 for
116 * both AREA and AS at least to have the possibility to call the show()
117 * function when looking to the opaque LSA of the OSPF database.
118 */
119 rc = ospf_register_opaque_functab(OSPF_OPAQUE_AREA_LSA,
120 OPAQUE_TYPE_INTER_AS_LSA, NULL,
121 NULL, NULL, NULL, NULL, NULL, NULL,
122 ospf_mpls_te_show_info,
123 ospf_mpls_te_lsa_inter_as_area,
124 ospf_mpls_te_lsa_refresh, NULL, NULL);
125 if (rc != 0) {
126 flog_warn(
127 EC_OSPF_OPAQUE_REGISTRATION,
128 "MPLS-TE (%s): Failed to register Inter-AS with Area scope",
129 __func__);
ead99d5f 130 return rc;
2efd7e2b 131 }
16f1b9ee 132
2efd7e2b
OD		 133 rc = ospf_register_opaque_functab(OSPF_OPAQUE_AS_LSA,
134 OPAQUE_TYPE_INTER_AS_LSA, NULL,
d62a17ae 135 NULL, NULL, NULL, NULL, NULL, NULL,
136 ospf_mpls_te_show_info,
2efd7e2b 137 ospf_mpls_te_lsa_inter_as_as,
d62a17ae 138 ospf_mpls_te_lsa_refresh, NULL, NULL);
d62a17ae 139 if (rc != 0) {
2efd7e2b
OD		 140 flog_warn(
141 EC_OSPF_OPAQUE_REGISTRATION,
142 "MPLS-TE (%s): Failed to register Inter-AS with AS scope",
143 __func__);
d62a17ae 144 return rc;
145 }
16f1b9ee 146
6006b807 147 memset(&OspfMplsTE, 0, sizeof(OspfMplsTE));
2efd7e2b
OD		 148 OspfMplsTE.enabled = false;
149 OspfMplsTE.export = false;
150 OspfMplsTE.inter_as = Off;
151 OspfMplsTE.iflist = list_new();
152 OspfMplsTE.iflist->del = del_mpls_te_link;
bcf4475e 153
2efd7e2b 154 ospf_mpls_te_register_vty();
bcf4475e 155
2efd7e2b 156 return rc;
bcf4475e
OD		 157}
158
d62a17ae 159void ospf_mpls_te_term(void)
718e3744 160{
6a154c88 161 list_delete(&OspfMplsTE.iflist);
718e3744 162
bcf4475e
OD		 163 ospf_delete_opaque_functab(OSPF_OPAQUE_AREA_LSA,
164 OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA);
2efd7e2b
OD		 165 ospf_delete_opaque_functab(OSPF_OPAQUE_AREA_LSA,
166 OPAQUE_TYPE_INTER_AS_LSA);
167 ospf_delete_opaque_functab(OSPF_OPAQUE_AS_LSA,
168 OPAQUE_TYPE_INTER_AS_LSA);
bcf4475e 169
32ab5cf4 170 OspfMplsTE.enabled = false;
ead99d5f 171 OspfMplsTE.inter_as = Off;
f173deb3 172 OspfMplsTE.export = false;
16f1b9ee 173
d62a17ae 174 return;
718e3744 175}
176
bcf4475e
OD		 177void ospf_mpls_te_finish(void)
178{
bcf4475e
OD		 179 OspfMplsTE.enabled = false;
180 OspfMplsTE.inter_as = Off;
f173deb3 181 OspfMplsTE.export = false;
bcf4475e
OD		 182}
183
718e3744 184/*------------------------------------------------------------------------*
78dfa0c7 185 * Following are control functions for MPLS-TE parameters management.
718e3744 186 *------------------------------------------------------------------------*/
d62a17ae 187static void del_mpls_te_link(void *val)
718e3744 188{
d62a17ae 189 XFREE(MTYPE_OSPF_MPLS_TE, val);
190 return;
718e3744 191}
192
d7c0a89a 193static uint32_t get_mpls_te_instance_value(void)
718e3744 194{
d7c0a89a 195 static uint32_t seqno = 0;
718e3744 196
d62a17ae 197 if (seqno < MAX_LEGAL_TE_INSTANCE_NUM)
198 seqno += 1;
199 else
200 seqno = 1; /* Avoid zero. */
718e3744 201
d62a17ae 202 return seqno;
718e3744 203}
204
d62a17ae 205static struct mpls_te_link *lookup_linkparams_by_ifp(struct interface *ifp)
718e3744 206{
d62a17ae 207 struct listnode *node, *nnode;
208 struct mpls_te_link *lp;
718e3744 209
d62a17ae 210 for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp))
211 if (lp->ifp == ifp)
212 return lp;
718e3744 213
d62a17ae 214 return NULL;
718e3744 215}
216
d62a17ae 217static struct mpls_te_link *lookup_linkparams_by_instance(struct ospf_lsa *lsa)
718e3744 218{
d62a17ae 219 struct listnode *node;
220 struct mpls_te_link *lp;
221 unsigned int key = GET_OPAQUE_ID(ntohl(lsa->data->id.s_addr));
718e3744 222
d62a17ae 223 for (ALL_LIST_ELEMENTS_RO(OspfMplsTE.iflist, node, lp))
224 if (lp->instance == key)
225 return lp;
718e3744 226
fd3c7692 227 ote_debug("MPLS-TE (%s): Entry not found: key(%x)", __func__, key);
d62a17ae 228 return NULL;
718e3744 229}
230
996c9314
LB		 231static void ospf_mpls_te_foreach_area(
232 void (*func)(struct mpls_te_link *lp, enum lsa_opcode sched_opcode),
233 enum lsa_opcode sched_opcode)
718e3744 234{
d62a17ae 235 struct listnode *node, *nnode;
236 struct listnode *node2;
237 struct mpls_te_link *lp;
238 struct ospf_area *area;
718e3744 239
d62a17ae 240 for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp)) {
241 /* Skip Inter-AS TEv2 Links */
242 if (IS_INTER_AS(lp->type))
243 continue;
244 if ((area = lp->area) == NULL)
245 continue;
32ab5cf4
OD		 246 if (CHECK_FLAG(lp->flags, LPFLG_LOOKUP_DONE))
247 continue;
718e3744 248
d62a17ae 249 if (func != NULL)
250 (*func)(lp, sched_opcode);
718e3744 251
d62a17ae 252 for (node2 = listnextnode(node); node2;
253 node2 = listnextnode(node2))
254 if ((lp = listgetdata(node2)) != NULL)
255 if (lp->area != NULL)
256 if (IPV4_ADDR_SAME(&lp->area->area_id,
257 &area->area_id))
258 SET_FLAG(lp->flags,
259 LPFLG_LOOKUP_DONE);
260 }
718e3744 261
d62a17ae 262 for (ALL_LIST_ELEMENTS_RO(OspfMplsTE.iflist, node, lp))
263 if (lp->area != NULL)
264 UNSET_FLAG(lp->flags, LPFLG_LOOKUP_DONE);
718e3744 265
d62a17ae 266 return;
718e3744 267}
268
d62a17ae 269static void set_mpls_te_router_addr(struct in_addr ipv4)
718e3744 270{
d62a17ae 271 OspfMplsTE.router_addr.header.type = htons(TE_TLV_ROUTER_ADDR);
272 OspfMplsTE.router_addr.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
273 OspfMplsTE.router_addr.value = ipv4;
274 return;
718e3744 275}
276
d62a17ae 277static void set_linkparams_link_header(struct mpls_te_link *lp)
718e3744 278{
d7c0a89a 279 uint16_t length = 0;
718e3744 280
d62a17ae 281 /* TE_LINK_SUBTLV_LINK_TYPE */
282 if (ntohs(lp->link_type.header.type) != 0)
283 length += TLV_SIZE(&lp->link_type.header);
718e3744 284
d62a17ae 285 /* TE_LINK_SUBTLV_LINK_ID */
286 if (ntohs(lp->link_id.header.type) != 0)
287 length += TLV_SIZE(&lp->link_id.header);
718e3744 288
d62a17ae 289 /* TE_LINK_SUBTLV_LCLIF_IPADDR */
290 if (lp->lclif_ipaddr.header.type != 0)
291 length += TLV_SIZE(&lp->lclif_ipaddr.header);
718e3744 292
d62a17ae 293 /* TE_LINK_SUBTLV_RMTIF_IPADDR */
294 if (lp->rmtif_ipaddr.header.type != 0)
295 length += TLV_SIZE(&lp->rmtif_ipaddr.header);
718e3744 296
d62a17ae 297 /* TE_LINK_SUBTLV_TE_METRIC */
298 if (ntohs(lp->te_metric.header.type) != 0)
299 length += TLV_SIZE(&lp->te_metric.header);
718e3744 300
d62a17ae 301 /* TE_LINK_SUBTLV_MAX_BW */
302 if (ntohs(lp->max_bw.header.type) != 0)
303 length += TLV_SIZE(&lp->max_bw.header);
718e3744 304
d62a17ae 305 /* TE_LINK_SUBTLV_MAX_RSV_BW */
306 if (ntohs(lp->max_rsv_bw.header.type) != 0)
307 length += TLV_SIZE(&lp->max_rsv_bw.header);
718e3744 308
d62a17ae 309 /* TE_LINK_SUBTLV_UNRSV_BW */
310 if (ntohs(lp->unrsv_bw.header.type) != 0)
311 length += TLV_SIZE(&lp->unrsv_bw.header);
718e3744 312
d62a17ae 313 /* TE_LINK_SUBTLV_RSC_CLSCLR */
314 if (ntohs(lp->rsc_clsclr.header.type) != 0)
315 length += TLV_SIZE(&lp->rsc_clsclr.header);
316
317 /* TE_LINK_SUBTLV_LLRI */
318 if (ntohs(lp->llri.header.type) != 0)
319 length += TLV_SIZE(&lp->llri.header);
320
321 /* TE_LINK_SUBTLV_RIP */
322 if (ntohs(lp->rip.header.type) != 0)
323 length += TLV_SIZE(&lp->rip.header);
324
325 /* TE_LINK_SUBTLV_RAS */
326 if (ntohs(lp->ras.header.type) != 0)
327 length += TLV_SIZE(&lp->ras.header);
328
329 /* TE_LINK_SUBTLV_LRRID */
330 if (ntohs(lp->lrrid.header.type) != 0)
331 length += TLV_SIZE(&lp->lrrid.header);
332
333 /* TE_LINK_SUBTLV_AV_DELAY */
334 if (ntohs(lp->av_delay.header.type) != 0)
335 length += TLV_SIZE(&lp->av_delay.header);
336
337 /* TE_LINK_SUBTLV_MM_DELAY */
338 if (ntohs(lp->mm_delay.header.type) != 0)
339 length += TLV_SIZE(&lp->mm_delay.header);
340
341 /* TE_LINK_SUBTLV_DELAY_VAR */
342 if (ntohs(lp->delay_var.header.type) != 0)
343 length += TLV_SIZE(&lp->delay_var.header);
344
345 /* TE_LINK_SUBTLV_PKT_LOSS */
346 if (ntohs(lp->pkt_loss.header.type) != 0)
347 length += TLV_SIZE(&lp->pkt_loss.header);
348
349 /* TE_LINK_SUBTLV_RES_BW */
350 if (ntohs(lp->res_bw.header.type) != 0)
351 length += TLV_SIZE(&lp->res_bw.header);
352
353 /* TE_LINK_SUBTLV_AVA_BW */
354 if (ntohs(lp->ava_bw.header.type) != 0)
355 length += TLV_SIZE(&lp->ava_bw.header);
356
357 /* TE_LINK_SUBTLV_USE_BW */
358 if (ntohs(lp->use_bw.header.type) != 0)
359 length += TLV_SIZE(&lp->use_bw.header);
718e3744 360
d62a17ae 361 lp->link_header.header.type = htons(TE_TLV_LINK);
362 lp->link_header.header.length = htons(length);
363
364 return;
718e3744 365}
d62a17ae 366
367static void set_linkparams_link_type(struct ospf_interface *oi,
368 struct mpls_te_link *lp)
369{
370 lp->link_type.header.type = htons(TE_LINK_SUBTLV_LINK_TYPE);
371 lp->link_type.header.length = htons(TE_LINK_SUBTLV_TYPE_SIZE);
372
373 switch (oi->type) {
374 case OSPF_IFTYPE_POINTOPOINT:
375 lp->link_type.link_type.value = LINK_TYPE_SUBTLV_VALUE_PTP;
376 break;
377 case OSPF_IFTYPE_BROADCAST:
378 case OSPF_IFTYPE_NBMA:
379 lp->link_type.link_type.value = LINK_TYPE_SUBTLV_VALUE_MA;
380 break;
381 default:
382 /* Not supported yet. */ /* XXX */
383 lp->link_type.header.type = htons(0);
384 break;
385 }
386 return;
718e3744 387}
d62a17ae 388
01c9b80a
OD		 389static void set_linkparams_link_id(struct mpls_te_link *lp,
390 struct in_addr link_id)
718e3744 391{
718e3744 392
d62a17ae 393 lp->link_id.header.type = htons(TE_LINK_SUBTLV_LINK_ID);
394 lp->link_id.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
01c9b80a 395 lp->link_id.value = link_id;
d62a17ae 396 return;
718e3744 397}
398
d62a17ae 399static void set_linkparams_lclif_ipaddr(struct mpls_te_link *lp,
400 struct in_addr lclif)
16f1b9ee
OD		 401{
402
d62a17ae 403 lp->lclif_ipaddr.header.type = htons(TE_LINK_SUBTLV_LCLIF_IPADDR);
404 lp->lclif_ipaddr.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
405 lp->lclif_ipaddr.value[0] = lclif;
406 return;
16f1b9ee
OD		 407}
408
d62a17ae 409static void set_linkparams_rmtif_ipaddr(struct mpls_te_link *lp,
410 struct in_addr rmtif)
16f1b9ee
OD		 411{
412
d62a17ae 413 lp->rmtif_ipaddr.header.type = htons(TE_LINK_SUBTLV_RMTIF_IPADDR);
414 lp->rmtif_ipaddr.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
415 lp->rmtif_ipaddr.value[0] = rmtif;
416 return;
16f1b9ee
OD		 417}
418
d62a17ae 419static void set_linkparams_te_metric(struct mpls_te_link *lp,
d7c0a89a 420 uint32_t te_metric)
718e3744 421{
d62a17ae 422 lp->te_metric.header.type = htons(TE_LINK_SUBTLV_TE_METRIC);
423 lp->te_metric.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
424 lp->te_metric.value = htonl(te_metric);
425 return;
718e3744 426}
427
d62a17ae 428static void set_linkparams_max_bw(struct mpls_te_link *lp, float fp)
718e3744 429{
d62a17ae 430 lp->max_bw.header.type = htons(TE_LINK_SUBTLV_MAX_BW);
431 lp->max_bw.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
432 lp->max_bw.value = htonf(fp);
433 return;
718e3744 434}
435
d62a17ae 436static void set_linkparams_max_rsv_bw(struct mpls_te_link *lp, float fp)
718e3744 437{
d62a17ae 438 lp->max_rsv_bw.header.type = htons(TE_LINK_SUBTLV_MAX_RSV_BW);
439 lp->max_rsv_bw.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
440 lp->max_rsv_bw.value = htonf(fp);
441 return;
718e3744 442}
443
d62a17ae 444static void set_linkparams_unrsv_bw(struct mpls_te_link *lp, int priority,
445 float fp)
718e3744 446{
d62a17ae 447 /* Note that TLV-length field is the size of array. */
448 lp->unrsv_bw.header.type = htons(TE_LINK_SUBTLV_UNRSV_BW);
449 lp->unrsv_bw.header.length = htons(TE_LINK_SUBTLV_UNRSV_SIZE);
450 lp->unrsv_bw.value[priority] = htonf(fp);
451 return;
718e3744 452}
453
d62a17ae 454static void set_linkparams_rsc_clsclr(struct mpls_te_link *lp,
d7c0a89a 455 uint32_t classcolor)
718e3744 456{
d62a17ae 457 lp->rsc_clsclr.header.type = htons(TE_LINK_SUBTLV_RSC_CLSCLR);
458 lp->rsc_clsclr.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
459 lp->rsc_clsclr.value = htonl(classcolor);
460 return;
718e3744 461}
462
d62a17ae 463static void set_linkparams_inter_as(struct mpls_te_link *lp,
d7c0a89a 464 struct in_addr addr, uint32_t as)
16f1b9ee
OD		 465{
466
d62a17ae 467 /* Set the Remote ASBR IP address and then the associated AS number */
468 lp->rip.header.type = htons(TE_LINK_SUBTLV_RIP);
469 lp->rip.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
470 lp->rip.value = addr;
16f1b9ee 471
d62a17ae 472 lp->ras.header.type = htons(TE_LINK_SUBTLV_RAS);
473 lp->ras.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
474 lp->ras.value = htonl(as);
2efd7e2b
OD		 475
476 /* Set Type & Flooding flag accordingly */
477 lp->type = INTER_AS;
478 if (OspfMplsTE.inter_as == AS)
479 SET_FLAG(lp->flags, LPFLG_LSA_FLOOD_AS);
480 else
481 UNSET_FLAG(lp->flags, LPFLG_LSA_FLOOD_AS);
16f1b9ee
OD		 482}
483
d62a17ae 484static void unset_linkparams_inter_as(struct mpls_te_link *lp)
16f1b9ee
OD		 485{
486
d62a17ae 487 /* Reset the Remote ASBR IP address and then the associated AS number */
488 lp->rip.header.type = htons(0);
489 lp->rip.header.length = htons(0);
490 lp->rip.value.s_addr = htonl(0);
16f1b9ee 491
d62a17ae 492 lp->ras.header.type = htons(0);
493 lp->ras.header.length = htons(0);
494 lp->ras.value = htonl(0);
2efd7e2b
OD		 495
496 /* Reset Type & Flooding flag accordingly */
497 lp->type = STD_TE;
498 UNSET_FLAG(lp->flags, LPFLG_LSA_FLOOD_AS);
16f1b9ee
OD		 499}
500
d7c0a89a
QY		 501void set_linkparams_llri(struct mpls_te_link *lp, uint32_t local,
502 uint32_t remote)
16f1b9ee
OD		 503{
504
d62a17ae 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);
16f1b9ee
OD		 509}
510
d62a17ae 511void set_linkparams_lrrid(struct mpls_te_link *lp, struct in_addr local,
512 struct in_addr remote)
16f1b9ee
OD		 513{
514
d62a17ae 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;
16f1b9ee
OD		 519}
520
d7c0a89a
QY		 521static void set_linkparams_av_delay(struct mpls_te_link *lp, uint32_t delay,
522 uint8_t anormal)
16f1b9ee 523{
d7c0a89a 524 uint32_t tmp;
d62a17ae 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;
529 if (anormal)
530 tmp |= TE_EXT_ANORMAL;
531 lp->av_delay.value = htonl(tmp);
532 return;
16f1b9ee
OD		 533}
534
d7c0a89a
QY		 535static void set_linkparams_mm_delay(struct mpls_te_link *lp, uint32_t low,
536 uint32_t high, uint8_t anormal)
16f1b9ee 537{
d7c0a89a 538 uint32_t tmp;
d62a17ae 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;
543 if (anormal)
544 tmp |= TE_EXT_ANORMAL;
545 lp->mm_delay.low = htonl(tmp);
546 lp->mm_delay.high = htonl(high);
547 return;
16f1b9ee
OD		 548}
549
d7c0a89a 550static void set_linkparams_delay_var(struct mpls_te_link *lp, uint32_t jitter)
16f1b9ee 551{
d62a17ae 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);
556 return;
16f1b9ee
OD		 557}
558
d7c0a89a
QY		 559static void set_linkparams_pkt_loss(struct mpls_te_link *lp, uint32_t loss,
560 uint8_t anormal)
16f1b9ee 561{
d7c0a89a 562 uint32_t tmp;
d62a17ae 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;
567 if (anormal)
568 tmp |= TE_EXT_ANORMAL;
569 lp->pkt_loss.value = htonl(tmp);
570 return;
16f1b9ee
OD		 571}
572
d62a17ae 573static void set_linkparams_res_bw(struct mpls_te_link *lp, float fp)
16f1b9ee 574{
d62a17ae 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);
579 return;
16f1b9ee
OD		 580}
581
d62a17ae 582static void set_linkparams_ava_bw(struct mpls_te_link *lp, float fp)
16f1b9ee 583{
d62a17ae 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);
588 return;
16f1b9ee
OD		 589}
590
d62a17ae 591static void set_linkparams_use_bw(struct mpls_te_link *lp, float fp)
16f1b9ee 592{
d62a17ae 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);
597 return;
16f1b9ee
OD		 598}
599
600/* Update TE parameters from Interface */
d62a17ae 601static void update_linkparams(struct mpls_te_link *lp)
602{
603 int i;
604 struct interface *ifp;
605
606 /* Get the Interface structure */
607 if ((ifp = lp->ifp) == NULL) {
fd3c7692
OD		 608 ote_debug(
609 "MPLS-TE (%s): Abort update TE parameters: no interface associated to Link Parameters",
610 __func__);
d62a17ae 611 return;
612 }
613 if (!HAS_LINK_PARAMS(ifp)) {
fd3c7692
OD		 614 ote_debug(
615 "MPLS-TE (%s): Abort update TE parameters: no Link Parameters for interface",
616 __func__);
d62a17ae 617 return;
618 }
619
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);
623 else
624 TLV_TYPE(lp->rsc_clsclr) = 0;
625
626 if (IS_PARAM_SET(ifp->link_params, LP_MAX_BW))
627 set_linkparams_max_bw(lp, ifp->link_params->max_bw);
628 else
629 TLV_TYPE(lp->max_bw) = 0;
630
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);
633 else
634 TLV_TYPE(lp->max_rsv_bw) = 0;
635
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]);
640 else
641 TLV_TYPE(lp->unrsv_bw) = 0;
642
643 if (IS_PARAM_SET(ifp->link_params, LP_TE_METRIC))
644 set_linkparams_te_metric(lp, ifp->link_params->te_metric);
645 else
646 TLV_TYPE(lp->te_metric) = 0;
647
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);
651 else
652 TLV_TYPE(lp->av_delay) = 0;
653
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);
657 else
658 TLV_TYPE(lp->mm_delay) = 0;
659
660 if (IS_PARAM_SET(ifp->link_params, LP_DELAY_VAR))
661 set_linkparams_delay_var(lp, ifp->link_params->delay_var);
662 else
663 TLV_TYPE(lp->delay_var) = 0;
664
665 if (IS_PARAM_SET(ifp->link_params, LP_PKT_LOSS))
666 set_linkparams_pkt_loss(lp, ifp->link_params->pkt_loss, 0);
667 else
668 TLV_TYPE(lp->pkt_loss) = 0;
669
670 if (IS_PARAM_SET(ifp->link_params, LP_RES_BW))
671 set_linkparams_res_bw(lp, ifp->link_params->res_bw);
672 else
673 TLV_TYPE(lp->res_bw) = 0;
674
675 if (IS_PARAM_SET(ifp->link_params, LP_AVA_BW))
676 set_linkparams_ava_bw(lp, ifp->link_params->ava_bw);
677 else
678 TLV_TYPE(lp->ava_bw) = 0;
679
680 if (IS_PARAM_SET(ifp->link_params, LP_USE_BW))
681 set_linkparams_use_bw(lp, ifp->link_params->use_bw);
682 else
683 TLV_TYPE(lp->use_bw) = 0;
684
685 /* RFC5392 */
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)) {
fd3c7692
OD		 690 ote_debug(
691 "MPLS-TE (%s): Update IF: Switch from Standard LSA to INTER-AS for %s[%d/%d]",
692 __func__, ifp->name, lp->flags, lp->type);
d62a17ae 693
694 ospf_mpls_te_lsa_schedule(lp, FLUSH_THIS_LSA);
695 /* Then, switch it to INTER-AS */
2efd7e2b
OD		 696 if (OspfMplsTE.inter_as == AS) {
697 lp->type = INTER_AS;
698 SET_FLAG(lp->flags, LPFLG_LSA_FLOOD_AS);
699 } else {
700 lp->type = INTER_AS;
701 UNSET_FLAG(lp->flags, LPFLG_LSA_FLOOD_AS);
d62a17ae 702 lp->area = ospf_area_lookup_by_area_id(
b5a8894d 703 ospf_lookup_by_vrf_id(VRF_DEFAULT),
d62a17ae 704 OspfMplsTE.interas_areaid);
705 }
706 }
707 set_linkparams_inter_as(lp, ifp->link_params->rmt_ip,
708 ifp->link_params->rmt_as);
709 } else {
fd3c7692
OD		 710 ote_debug(
711 "MPLS-TE (%s): Update IF: Switch from INTER-AS LSA to Standard for %s[%d/%d]",
712 __func__, ifp->name, lp->flags, lp->type);
d62a17ae 713
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 */
2efd7e2b
OD		 720 lp->flags = STD_TE;
721 UNSET_FLAG(lp->flags, LPFLG_LSA_FLOOD_AS);
d62a17ae 722 }
723 unset_linkparams_inter_as(lp);
724 }
725}
726
727static void initialize_linkparams(struct mpls_te_link *lp)
728{
729 struct interface *ifp = lp->ifp;
ead99d5f
OD		 730 struct ospf_interface *oi = NULL;
731 struct route_node *rn;
d62a17ae 732
f173deb3
OD		 733 ote_debug("MPLS-TE (%s): Initialize Link Parameters for interface %s",
734 __func__, ifp->name);
d62a17ae 735
ead99d5f 736 /* Search OSPF Interface parameters for this interface */
996c9314 737 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
ead99d5f
OD		 738
739 if ((oi = rn->info) == NULL)
740 continue;
741
742 if (oi->ifp == ifp)
743 break;
744 }
745
746 if ((oi == NULL) || (oi->ifp != ifp)) {
fd3c7692
OD		 747 ote_debug(
748 "MPLS-TE (%s): Could not find corresponding OSPF Interface for %s",
749 __func__, ifp->name);
d62a17ae 750 return;
751 }
752
753 /*
754 * Try to set initial values those can be derived from
755 * zebra-interface information.
756 */
757 set_linkparams_link_type(oi, lp);
758
759 /* Set local IP addr */
760 set_linkparams_lclif_ipaddr(lp, oi->address->u.prefix4);
761
762 /* Set Remote IP addr if Point to Point Interface */
ead99d5f 763 if (oi->type == OSPF_IFTYPE_POINTOPOINT) {
d62a17ae 764 struct prefix *pref = CONNECTED_PREFIX(oi->connected);
765 if (pref != NULL)
766 set_linkparams_rmtif_ipaddr(lp, pref->u.prefix4);
767 }
768
769 /* Keep Area information in combination with link parameters. */
770 lp->area = oi->area;
771
772 return;
773}
774
775static int is_mandated_params_set(struct mpls_te_link *lp)
776{
777 int rc = 0;
778
779 if (ntohs(OspfMplsTE.router_addr.header.type) == 0) {
fd3c7692
OD		 780 flog_warn(EC_OSPF_TE_UNEXPECTED,
781 "MPLS-TE (%s): Missing Router Address", __func__);
ead99d5f 782 return rc;
d62a17ae 783 }
784
785 if (ntohs(lp->link_type.header.type) == 0) {
cf444bcf 786 flog_warn(EC_OSPF_TE_UNEXPECTED,
fd3c7692 787 "MPLS-TE (%s): Missing Link Type", __func__);
ead99d5f 788 return rc;
d62a17ae 789 }
790
791 if (!IS_INTER_AS(lp->type) && (ntohs(lp->link_id.header.type) == 0)) {
f173deb3
OD		 792 flog_warn(EC_OSPF_TE_UNEXPECTED, "MPLS-TE (%s) Missing Link ID",
793 __func__);
ead99d5f 794 return rc;
d62a17ae 795 }
796
797 rc = 1;
d62a17ae 798 return rc;
718e3744 799}
800
801/*------------------------------------------------------------------------*
78dfa0c7 802 * Following are callback functions against generic Opaque-LSAs handling.
718e3744 803 *------------------------------------------------------------------------*/
804
d62a17ae 805static int ospf_mpls_te_new_if(struct interface *ifp)
718e3744 806{
d62a17ae 807 struct mpls_te_link *new;
718e3744 808
fd3c7692
OD		 809 ote_debug("MPLS-TE (%s): Add new %s interface %s to MPLS-TE list",
810 __func__, ifp->link_params ? "Active" : "Inactive",
811 ifp->name);
16f1b9ee 812
2c72cf2a
DS		 813 if (lookup_linkparams_by_ifp(ifp) != NULL)
814 return 0;
718e3744 815
d62a17ae 816 new = XCALLOC(MTYPE_OSPF_MPLS_TE, sizeof(struct mpls_te_link));
718e3744 817
d62a17ae 818 new->instance = get_mpls_te_instance_value();
819 new->ifp = ifp;
820 /* By default TE-Link is RFC3630 compatible flooding in Area and not
821 * active */
822 /* This default behavior will be adapted with call to
823 * ospf_mpls_te_update_if() */
2efd7e2b 824 new->type = STD_TE;
d62a17ae 825 new->flags = LPFLG_LSA_INACTIVE;
16f1b9ee 826
d62a17ae 827 /* Initialize Link Parameters from Interface */
828 initialize_linkparams(new);
718e3744 829
d62a17ae 830 /* Set TE Parameters from Interface */
831 update_linkparams(new);
718e3744 832
d62a17ae 833 /* Add Link Parameters structure to the list */
834 listnode_add(OspfMplsTE.iflist, new);
718e3744 835
fd3c7692
OD		 836 ote_debug("MPLS-TE (%s): Add new LP context for %s[%d/%d]", __func__,
837 ifp->name, new->flags, new->type);
16f1b9ee 838
d62a17ae 839 /* Schedule Opaque-LSA refresh. */ /* XXX */
2c72cf2a 840 return 0;
718e3744 841}
842
d62a17ae 843static int ospf_mpls_te_del_if(struct interface *ifp)
718e3744 844{
d62a17ae 845 struct mpls_te_link *lp;
846 int rc = -1;
718e3744 847
d62a17ae 848 if ((lp = lookup_linkparams_by_ifp(ifp)) != NULL) {
849 struct list *iflist = OspfMplsTE.iflist;
718e3744 850
d62a17ae 851 /* Dequeue listnode entry from the list. */
852 listnode_delete(iflist, lp);
718e3744 853
d62a17ae 854 XFREE(MTYPE_OSPF_MPLS_TE, lp);
855 }
718e3744 856
d62a17ae 857 /* Schedule Opaque-LSA refresh. */ /* XXX */
718e3744 858
d62a17ae 859 rc = 0;
d62a17ae 860 return rc;
718e3744 861}
862
16f1b9ee
OD		 863/* Main initialization / update function of the MPLS TE Link context */
864
865/* Call when interface TE Link parameters are modified */
d62a17ae 866void ospf_mpls_te_update_if(struct interface *ifp)
867{
868 struct mpls_te_link *lp;
869
fd3c7692
OD		 870 ote_debug("MPLS-TE (%s): Update LSA parameters for interface %s [%s]",
871 __func__, ifp->name, HAS_LINK_PARAMS(ifp) ? "ON" : "OFF");
d62a17ae 872
873 /* Get Link context from interface */
874 if ((lp = lookup_linkparams_by_ifp(ifp)) == NULL) {
ade6974d 875 flog_warn(
cf444bcf 876 EC_OSPF_TE_UNEXPECTED,
fd3c7692
OD		 877 "MPLS-TE (%s): Did not find Link Parameters context for interface %s",
878 __func__, ifp->name);
d62a17ae 879 return;
880 }
881
882 /* Fulfill MPLS-TE Link TLV from Interface TE Link parameters */
883 if (HAS_LINK_PARAMS(ifp)) {
884 SET_FLAG(lp->flags, LPFLG_LSA_ACTIVE);
885
886 /* Update TE parameters */
887 update_linkparams(lp);
888
889 /* Finally Re-Originate or Refresh Opaque LSA if MPLS_TE is
890 * enabled */
32ab5cf4 891 if (OspfMplsTE.enabled)
d62a17ae 892 if (lp->area != NULL) {
32ab5cf4 893 if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED))
996c9314
LB		 894 ospf_mpls_te_lsa_schedule(
895 lp, REFRESH_THIS_LSA);
32ab5cf4 896 else
996c9314
LB		 897 ospf_mpls_te_lsa_schedule(
898 lp, REORIGINATE_THIS_LSA);
d62a17ae 899 }
900 } else {
901 /* If MPLS TE is disable on this interface, flush LSA if it is
902 * already engaged */
32ab5cf4
OD		 903 if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED))
904 ospf_mpls_te_lsa_schedule(lp, FLUSH_THIS_LSA);
d62a17ae 905 else
906 /* Reset Activity flag */
907 lp->flags = LPFLG_LSA_INACTIVE;
908 }
909
910 return;
911}
912
01c9b80a
OD		 913/*
914 * Just add interface and set available information. Other information
915 * and flooding of LSA will be done later when adjacency will be up
916 * See ospf_mpls_te_nsm_change() after
917 */
d62a17ae 918static void ospf_mpls_te_ism_change(struct ospf_interface *oi, int old_state)
919{
01c9b80a 920
d62a17ae 921 struct mpls_te_link *lp;
922
01c9b80a
OD		 923 lp = lookup_linkparams_by_ifp(oi->ifp);
924 if (lp == NULL) {
ade6974d 925 flog_warn(
cf444bcf 926 EC_OSPF_TE_UNEXPECTED,
01c9b80a
OD		 927 "MPLS-TE (%s): Cannot get linkparams from OI(%s)?",
928 __func__, IF_NAME(oi));
ead99d5f 929 return;
d62a17ae 930 }
931
932 if (oi->area == NULL || oi->area->ospf == NULL) {
ade6974d 933 flog_warn(
cf444bcf 934 EC_OSPF_TE_UNEXPECTED,
01c9b80a
OD		 935 "MPLS-TE (%s): Cannot refer to OSPF from OI(%s)?",
936 __func__, IF_NAME(oi));
ead99d5f 937 return;
d62a17ae 938 }
01c9b80a 939
d62a17ae 940 /* Keep Area information in combination with linkparams. */
941 lp->area = oi->area;
942
d62a17ae 943 switch (oi->state) {
944 case ISM_PointToPoint:
945 case ISM_DROther:
946 case ISM_Backup:
947 case ISM_DR:
01c9b80a 948 /* Set Link type and Local IP addr */
d62a17ae 949 set_linkparams_link_type(oi, lp);
d62a17ae 950 set_linkparams_lclif_ipaddr(lp, oi->address->u.prefix4);
951
d62a17ae 952 break;
50ec09db
OD		 953 case ISM_Down:
954 /* Interface goes Down: Flush LSA if engaged */
955 if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED)) {
956 ote_debug(
957 "MPLS-TE (%s): Interface %s goes down: flush LSA",
958 __func__, IF_NAME(oi));
32ab5cf4 959 ospf_mpls_te_lsa_schedule(lp, FLUSH_THIS_LSA);
50ec09db
OD		 960 return;
961 }
962 break;
963 default:
d62a17ae 964 break;
965 }
718e3744 966
fd3c7692
OD		 967 ote_debug("MPLS-TE (%s): Update Link parameters for interface %s",
968 __func__, IF_NAME(oi));
01c9b80a 969
d62a17ae 970 return;
718e3744 971}
972
01c9b80a
OD		 973/*
974 * Complete TE info and schedule LSA flooding
975 * Link-ID and Remote IP address must be set with neighbor info
976 * which are only valid once NSM state is FULL
977 */
d62a17ae 978static void ospf_mpls_te_nsm_change(struct ospf_neighbor *nbr, int old_state)
718e3744 979{
01c9b80a
OD		 980 struct ospf_interface *oi = nbr->oi;
981 struct mpls_te_link *lp;
982
983 /* Process Neighbor only when its state is NSM Full */
984 if (nbr->state != NSM_Full)
985 return;
986
987 /* Get interface information for Traffic Engineering */
988 lp = lookup_linkparams_by_ifp(oi->ifp);
989 if (lp == NULL) {
990 flog_warn(
991 EC_OSPF_TE_UNEXPECTED,
992 "MPLS-TE (%s): Cannot get linkparams from OI(%s)?",
993 __func__, IF_NAME(oi));
994 return;
995 }
996
997 if (oi->area == NULL || oi->area->ospf == NULL) {
998 flog_warn(
999 EC_OSPF_TE_UNEXPECTED,
1000 "MPLS-TE (%s): Cannot refer to OSPF from OI(%s)?",
1001 __func__, IF_NAME(oi));
1002 return;
1003 }
1004
50ec09db
OD		 1005 /* Flush TE Opaque LSA if Neighbor State goes Down or Deleted */
1006 if (OspfMplsTE.enabled
1007 && (nbr->state == NSM_Down || nbr->state == NSM_Deleted)) {
1008 if (CHECK_FLAG(lp->flags, EXT_LPFLG_LSA_ENGAGED)) {
1009 ote_debug(
1010 "MPLS-TE (%s): Interface %s goes down: flush LSA",
1011 __func__, IF_NAME(oi));
1012 ospf_mpls_te_lsa_schedule(lp, FLUSH_THIS_LSA);
1013 }
1014 return;
1015 }
1016
01c9b80a
OD		 1017 /* Keep Area information in combination with SR info. */
1018 lp->area = oi->area;
1019
01c9b80a
OD		 1020 /*
1021 * The Link ID is identical to the contents of the Link ID field
1022 * in the Router LSA for these link types.
1023 */
1024 switch (oi->state) {
1025 case ISM_PointToPoint:
1026 /* Set Link ID with neighbor Router ID */
1027 set_linkparams_link_id(lp, nbr->router_id);
1028 /* Set Remote IP address */
1029 set_linkparams_rmtif_ipaddr(lp, nbr->address.u.prefix4);
1030 break;
1031
1032 case ISM_DR:
1033 case ISM_DROther:
1034 case ISM_Backup:
1035 /* Set Link ID with the Designated Router ID */
1036 set_linkparams_link_id(lp, DR(oi));
1037 break;
1038
50ec09db
OD		 1039 case ISM_Down:
1040 /* State goes Down: Flush LSA if engaged */
f173deb3
OD		 1041 if (OspfMplsTE.enabled
1042 && CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED)) {
50ec09db
OD		 1043 ote_debug(
1044 "MPLS-TE (%s): Interface %s goes down: flush LSA",
1045 __func__, IF_NAME(oi));
01c9b80a 1046 ospf_mpls_te_lsa_schedule(lp, FLUSH_THIS_LSA);
50ec09db 1047 }
01c9b80a 1048 return;
50ec09db
OD		 1049 default:
1050 break;
01c9b80a
OD		 1051 }
1052
fd3c7692
OD		 1053 ote_debug("MPLS-TE (%s): Add Link-ID %pI4 for interface %s ", __func__,
1054 &lp->link_id.value, oi->ifp->name);
01c9b80a
OD		 1055
1056 /* Try to Schedule LSA */
1057 if (OspfMplsTE.enabled) {
1058 if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED))
1059 ospf_mpls_te_lsa_schedule(lp, REFRESH_THIS_LSA);
1060 else
1061 ospf_mpls_te_lsa_schedule(lp, REORIGINATE_THIS_LSA);
1062 }
d62a17ae 1063 return;
718e3744 1064}
1065
1066/*------------------------------------------------------------------------*
78dfa0c7 1067 * Following are OSPF protocol processing functions for MPLS-TE LSA.
718e3744 1068 *------------------------------------------------------------------------*/
1069
ead99d5f 1070static void build_tlv_header(struct stream *s, struct tlv_header *tlvh)
d62a17ae 1071{
ead99d5f 1072 stream_put(s, tlvh, sizeof(struct tlv_header));
d62a17ae 1073 return;
1074}
1075
1076static void build_router_tlv(struct stream *s)
1077{
ead99d5f 1078 struct tlv_header *tlvh = &OspfMplsTE.router_addr.header;
d62a17ae 1079 if (ntohs(tlvh->type) != 0) {
1080 build_tlv_header(s, tlvh);
5d0df50f 1081 stream_put(s, TLV_DATA(tlvh), TLV_BODY_SIZE(tlvh));
d62a17ae 1082 }
1083 return;
1084}
1085
ead99d5f 1086static void build_link_subtlv(struct stream *s, struct tlv_header *tlvh)
d62a17ae 1087{
1088
1089 if ((tlvh != NULL) && (ntohs(tlvh->type) != 0)) {
1090 build_tlv_header(s, tlvh);
5d0df50f 1091 stream_put(s, TLV_DATA(tlvh), TLV_BODY_SIZE(tlvh));
d62a17ae 1092 }
1093 return;
1094}
1095
1096static void build_link_tlv(struct stream *s, struct mpls_te_link *lp)
1097{
1098 set_linkparams_link_header(lp);
1099 build_tlv_header(s, &lp->link_header.header);
1100
1101 build_link_subtlv(s, &lp->link_type.header);
1102 build_link_subtlv(s, &lp->link_id.header);
1103 build_link_subtlv(s, &lp->lclif_ipaddr.header);
1104 build_link_subtlv(s, &lp->rmtif_ipaddr.header);
1105 build_link_subtlv(s, &lp->te_metric.header);
1106 build_link_subtlv(s, &lp->max_bw.header);
1107 build_link_subtlv(s, &lp->max_rsv_bw.header);
1108 build_link_subtlv(s, &lp->unrsv_bw.header);
1109 build_link_subtlv(s, &lp->rsc_clsclr.header);
1110 build_link_subtlv(s, &lp->lrrid.header);
1111 build_link_subtlv(s, &lp->llri.header);
1112 build_link_subtlv(s, &lp->rip.header);
1113 build_link_subtlv(s, &lp->ras.header);
1114 build_link_subtlv(s, &lp->av_delay.header);
1115 build_link_subtlv(s, &lp->mm_delay.header);
1116 build_link_subtlv(s, &lp->delay_var.header);
1117 build_link_subtlv(s, &lp->pkt_loss.header);
1118 build_link_subtlv(s, &lp->res_bw.header);
1119 build_link_subtlv(s, &lp->ava_bw.header);
1120 build_link_subtlv(s, &lp->use_bw.header);
1121
1122 return;
1123}
1124
1125static void ospf_mpls_te_lsa_body_set(struct stream *s, struct mpls_te_link *lp)
1126{
1127 /*
2efd7e2b
OD		 1128 * The router address TLV is type 1, and ... It must appear in exactly
1129 * one Traffic Engineering LSA originated by a router but not in
1130 * Inter-AS TLV.
d62a17ae 1131 */
2efd7e2b
OD		 1132 if (!IS_INTER_AS(lp->type))
1133 build_router_tlv(s);
d62a17ae 1134
1135 /*
1136 * Only one Link TLV shall be carried in each LSA, allowing for fine
1137 * granularity changes in topology.
1138 */
1139 build_link_tlv(s, lp);
1140 return;
718e3744 1141}
1142
1143/* Create new opaque-LSA. */
b5a8894d
CS		 1144static struct ospf_lsa *ospf_mpls_te_lsa_new(struct ospf *ospf,
1145 struct ospf_area *area,
d62a17ae 1146 struct mpls_te_link *lp)
1147{
1148 struct stream *s;
1149 struct lsa_header *lsah;
1150 struct ospf_lsa *new = NULL;
d7c0a89a 1151 uint8_t options, lsa_type = 0;
d62a17ae 1152 struct in_addr lsa_id;
d7c0a89a
QY		 1153 uint32_t tmp;
1154 uint16_t length;
d62a17ae 1155
1156 /* Create a stream for LSA. */
266469eb 1157 s = stream_new(OSPF_MAX_LSA_SIZE);
d62a17ae 1158 lsah = (struct lsa_header *)STREAM_DATA(s);
1159
1160 options = OSPF_OPTION_O; /* Don't forget this :-) */
1161
1162 /* Set opaque-LSA header fields depending of the type of RFC */
1163 if (IS_INTER_AS(lp->type)) {
2efd7e2b 1164 if (IS_FLOOD_AS(lp->flags)) {
72c03801
QY		 1165 /* Enable AS external as we flood Inter-AS with Opaque
1166 * Type 11
1167 */
1168 options |= OSPF_OPTION_E;
1169 lsa_type = OSPF_OPAQUE_AS_LSA;
1170 } else {
d62a17ae 1171 options |= LSA_OPTIONS_GET(
1172 area); /* Get area default option */
1173 options |= LSA_OPTIONS_NSSA_GET(area);
1174 lsa_type = OSPF_OPAQUE_AREA_LSA;
1175 }
1176 tmp = SET_OPAQUE_LSID(OPAQUE_TYPE_INTER_AS_LSA, lp->instance);
1177 lsa_id.s_addr = htonl(tmp);
1178
0760d3c9
DS		 1179 if (!ospf) {
1180 stream_free(s);
b5a8894d 1181 return NULL;
0760d3c9 1182 }
d62a17ae 1183
b5a8894d 1184 lsa_header_set(s, options, lsa_type, lsa_id, ospf->router_id);
d62a17ae 1185 } else {
1186 options |= LSA_OPTIONS_GET(area); /* Get area default option */
1187 options |= LSA_OPTIONS_NSSA_GET(area);
1188 lsa_type = OSPF_OPAQUE_AREA_LSA;
1189 tmp = SET_OPAQUE_LSID(OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA,
1190 lp->instance);
1191 lsa_id.s_addr = htonl(tmp);
1192 lsa_header_set(s, options, lsa_type, lsa_id,
1193 area->ospf->router_id);
1194 }
1195
fd3c7692 1196 ote_debug(
50ec09db 1197 "MPLS-TE (%s): LSA[Type%d:%pI4]: Create an Opaque-LSA/MPLS-TE instance",
fd3c7692 1198 __func__, lsa_type, &lsa_id);
d62a17ae 1199
1200 /* Set opaque-LSA body fields. */
1201 ospf_mpls_te_lsa_body_set(s, lp);
1202
1203 /* Set length. */
1204 length = stream_get_endp(s);
1205 lsah->length = htons(length);
1206
1207 /* Now, create an OSPF LSA instance. */
5b3d4186 1208 new = ospf_lsa_new_and_data(length);
d62a17ae 1209
b5a8894d
CS		 1210 new->vrf_id = ospf->vrf_id;
1211 if (area && area->ospf)
1212 new->vrf_id = area->ospf->vrf_id;
d62a17ae 1213 new->area = area;
1214 SET_FLAG(new->flags, OSPF_LSA_SELF);
1215 memcpy(new->data, lsah, length);
1216 stream_free(s);
718e3744 1217
d62a17ae 1218 return new;
1219}
1220
1221static int ospf_mpls_te_lsa_originate1(struct ospf_area *area,
1222 struct mpls_te_link *lp)
1223{
b5a8894d 1224 struct ospf_lsa *new = NULL;
d62a17ae 1225 int rc = -1;
1226
1227 /* Create new Opaque-LSA/MPLS-TE instance. */
b5a8894d
CS		 1228 new = ospf_mpls_te_lsa_new(area->ospf, area, lp);
1229 if (new == NULL) {
fd3c7692
OD		 1230 flog_warn(EC_OSPF_TE_UNEXPECTED,
1231 "MPLS-TE (%s): ospf_mpls_te_lsa_new() ?", __func__);
ead99d5f 1232 return rc;
d62a17ae 1233 }
1234
1235 /* Install this LSA into LSDB. */
1236 if (ospf_lsa_install(area->ospf, NULL /*oi*/, new) == NULL) {
cf444bcf 1237 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE,
fd3c7692 1238 "MPLS-TE (%s): ospf_lsa_install() ?", __func__);
d62a17ae 1239 ospf_lsa_unlock(&new);
ead99d5f 1240 return rc;
d62a17ae 1241 }
1242
1243 /* Now this link-parameter entry has associated LSA. */
1244 SET_FLAG(lp->flags, LPFLG_LSA_ENGAGED);
1245 /* Update new LSA origination count. */
1246 area->ospf->lsa_originate_count++;
1247
1248 /* Flood new LSA through area. */
1249 ospf_flood_through_area(area, NULL /*nbr*/, new);
1250
fd3c7692
OD		 1251 ote_debug(
1252 "MPLS-TE (%s): LSA[Type%d:%pI4]: Originate Opaque-LSA/MPLS-TE: Area(%pI4), Link(%s)",
1253 __func__, new->data->type, &new->data->id, &area->area_id,
1254 lp->ifp->name);
1255 if (IS_DEBUG_OSPF(lsa, LSA_GENERATE))
d62a17ae 1256 ospf_lsa_header_dump(new->data);
d62a17ae 1257
1258 rc = 0;
d62a17ae 1259 return rc;
1260}
1261
1262static int ospf_mpls_te_lsa_originate_area(void *arg)
1263{
1264 struct ospf_area *area = (struct ospf_area *)arg;
1265 struct listnode *node, *nnode;
1266 struct mpls_te_link *lp;
1267 int rc = -1;
1268
32ab5cf4 1269 if (!OspfMplsTE.enabled) {
fd3c7692 1270 ote_debug("MPLS-TE (%s): MPLS-TE is disabled now.", __func__);
d62a17ae 1271 rc = 0; /* This is not an error case. */
ead99d5f 1272 return rc;
d62a17ae 1273 }
1274
1275 for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp)) {
1276 /* Process only enabled LSA with area scope flooding */
1277 if (!CHECK_FLAG(lp->flags, LPFLG_LSA_ACTIVE)
2efd7e2b 1278 || IS_FLOOD_AS(lp->flags))
d62a17ae 1279 continue;
1280
1281 if (lp->area == NULL)
1282 continue;
1283
1284 if (!IPV4_ADDR_SAME(&lp->area->area_id, &area->area_id))
1285 continue;
1286
32ab5cf4
OD		 1287 if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED)) {
1288 if (CHECK_FLAG(lp->flags, LPFLG_LSA_FORCED_REFRESH)) {
1289 UNSET_FLAG(lp->flags, LPFLG_LSA_FORCED_REFRESH);
fd3c7692
OD		 1290 ote_debug(
1291 "MPLS-TE (%s): Refresh instead of Originate",
1292 __func__);
32ab5cf4 1293 ospf_mpls_te_lsa_schedule(lp, REFRESH_THIS_LSA);
d62a17ae 1294 }
32ab5cf4
OD		 1295 continue;
1296 }
1297
d62a17ae 1298 if (!is_mandated_params_set(lp)) {
fd3c7692
OD		 1299 ote_debug(
1300 "MPLS-TE (%s): Link(%s) lacks some mandated MPLS-TE parameters.",
1301 __func__, lp->ifp ? lp->ifp->name : "?");
d62a17ae 1302 continue;
1303 }
1304
1305 /* Ok, let's try to originate an LSA for this area and Link. */
fd3c7692
OD		 1306 ote_debug(
1307 "MPLS-TE (%s): Let's finally reoriginate the LSA %d through the Area %pI4 for Link %s",
1308 __func__, lp->instance, &area->area_id,
1309 lp->ifp ? lp->ifp->name : "?");
d62a17ae 1310 if (ospf_mpls_te_lsa_originate1(area, lp) != 0)
ead99d5f 1311 return rc;
d62a17ae 1312 }
1313
1314 rc = 0;
d62a17ae 1315 return rc;
1316}
718e3744 1317
d62a17ae 1318static int ospf_mpls_te_lsa_originate2(struct ospf *top,
1319 struct mpls_te_link *lp)
1320{
1321 struct ospf_lsa *new;
1322 int rc = -1;
1323
1324 /* Create new Opaque-LSA/Inter-AS instance. */
b5a8894d
CS		 1325 new = ospf_mpls_te_lsa_new(top, NULL, lp);
1326 if (new == NULL) {
fd3c7692
OD		 1327 flog_warn(EC_OSPF_LSA_UNEXPECTED,
1328 "MPLS-TE (%s): ospf_router_info_lsa_new() ?",
1329 __func__);
ead99d5f 1330 return rc;
d62a17ae 1331 }
b5a8894d 1332 new->vrf_id = top->vrf_id;
d62a17ae 1333
1334 /* Install this LSA into LSDB. */
1335 if (ospf_lsa_install(top, NULL /*oi */, new) == NULL) {
cf444bcf 1336 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE,
fd3c7692 1337 "MPLS-TE (%s): ospf_lsa_install() ?", __func__);
d62a17ae 1338 ospf_lsa_unlock(&new);
ead99d5f 1339 return rc;
d62a17ae 1340 }
1341
1342 /* Now this Router Info parameter entry has associated LSA. */
1343 SET_FLAG(lp->flags, LPFLG_LSA_ENGAGED);
1344 /* Update new LSA origination count. */
1345 top->lsa_originate_count++;
1346
1347 /* Flood new LSA through AS. */
1348 ospf_flood_through_as(top, NULL /*nbr */, new);
1349
fd3c7692
OD		 1350 ote_debug(
1351 "MPLS-TE (%s): LSA[Type%d:%pI4]: Originate Opaque-LSA/MPLS-TE Inter-AS",
1352 __func__, new->data->type, &new->data->id);
1353 if (IS_DEBUG_OSPF(lsa, LSA_GENERATE))
d62a17ae 1354 ospf_lsa_header_dump(new->data);
fd3c7692 1355
d62a17ae 1356
1357 rc = 0;
d62a17ae 1358 return rc;
1359}
1360
1361static int ospf_mpls_te_lsa_originate_as(void *arg)
1362{
1363 struct ospf *top;
1364 struct ospf_area *area;
1365 struct listnode *node, *nnode;
1366 struct mpls_te_link *lp;
1367 int rc = -1;
1368
996c9314 1369 if ((!OspfMplsTE.enabled) || (OspfMplsTE.inter_as == Off)) {
fd3c7692
OD		 1370 ote_debug("MPLS-TE (%s): Inter-AS is disabled for now",
1371 __func__);
d62a17ae 1372 rc = 0; /* This is not an error case. */
ead99d5f 1373 return rc;
d62a17ae 1374 }
1375
1376 for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp)) {
1377 /* Process only enabled INTER_AS Links or Pseudo-Links */
1378 if (!CHECK_FLAG(lp->flags, LPFLG_LSA_ACTIVE)
2efd7e2b 1379 || !CHECK_FLAG(lp->flags, LPFLG_LSA_FLOOD_AS)
d62a17ae 1380 || !IS_INTER_AS(lp->type))
1381 continue;
1382
32ab5cf4
OD		 1383 if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED)) {
1384 if (CHECK_FLAG(lp->flags, LPFLG_LSA_FORCED_REFRESH)) {
996c9314 1385 UNSET_FLAG(lp->flags, LPFLG_LSA_FORCED_REFRESH);
32ab5cf4 1386 ospf_mpls_te_lsa_schedule(lp, REFRESH_THIS_LSA);
d62a17ae 1387 }
32ab5cf4
OD		 1388 continue;
1389 }
1390
d62a17ae 1391 if (!is_mandated_params_set(lp)) {
ade6974d 1392 flog_warn(
cf444bcf 1393 EC_OSPF_TE_UNEXPECTED,
fd3c7692
OD		 1394 "MPLS-TE (%s): Link(%s) lacks some mandated MPLS-TE parameters.",
1395 __func__, lp->ifp ? lp->ifp->name : "?");
d62a17ae 1396 continue;
1397 }
1398
1399 /* Ok, let's try to originate an LSA for this AS and Link. */
fd3c7692
OD		 1400 ote_debug(
1401 "MPLS-TE (%s): Let's finally re-originate the Inter-AS LSA %d through the %s for Link %s",
1402 __func__, lp->instance,
2efd7e2b 1403 IS_FLOOD_AS(lp->flags) ? "AS" : "Area",
fd3c7692 1404 lp->ifp ? lp->ifp->name : "Unknown");
d62a17ae 1405
2efd7e2b 1406 if (IS_FLOOD_AS(lp->flags)) {
d62a17ae 1407 top = (struct ospf *)arg;
1408 ospf_mpls_te_lsa_originate2(top, lp);
1409 } else {
1410 area = (struct ospf_area *)arg;
1411 ospf_mpls_te_lsa_originate1(area, lp);
1412 }
1413 }
1414
1415 rc = 0;
d62a17ae 1416 return rc;
1417}
1418
2efd7e2b
OD		 1419/*
1420 * As Inter-AS LSA must be registered with both AREA and AS flooding, and
1421 * because all origination callback functions are call (disregarding the Opaque
1422 * LSA type and Flooding scope) it is necessary to determine which flooding
1423 * scope is associated with the LSA origination as parameter is of type void and
1424 * must be cast to struct *ospf for AS flooding and to struct *ospf_area for
1425 * Area flooding.
1426 */
1427static int ospf_mpls_te_lsa_inter_as_as(void *arg)
1428{
1429 if (OspfMplsTE.inter_as == AS)
1430 return ospf_mpls_te_lsa_originate_as(arg);
1431 else
1432 return 0;
1433}
1434
1435static int ospf_mpls_te_lsa_inter_as_area(void *arg)
1436{
1437 if (OspfMplsTE.inter_as == Area)
1438 return ospf_mpls_te_lsa_originate_area(arg);
1439 else
1440 return 0;
1441}
1442
d62a17ae 1443static struct ospf_lsa *ospf_mpls_te_lsa_refresh(struct ospf_lsa *lsa)
1444{
1445 struct mpls_te_link *lp;
1446 struct ospf_area *area = lsa->area;
1447 struct ospf *top;
1448 struct ospf_lsa *new = NULL;
1449
32ab5cf4 1450 if (!OspfMplsTE.enabled) {
d62a17ae 1451 /*
1452 * This LSA must have flushed before due to MPLS-TE status
1453 * change.
1454 * It seems a slip among routers in the routing domain.
1455 */
fd3c7692 1456 ote_debug("MPLS-TE (%s): MPLS-TE is disabled now", __func__);
d62a17ae 1457 lsa->data->ls_age =
1458 htons(OSPF_LSA_MAXAGE); /* Flush it anyway. */
1459 }
1460
1461 /* At first, resolve lsa/lp relationship. */
1462 if ((lp = lookup_linkparams_by_instance(lsa)) == NULL) {
cf444bcf 1463 flog_warn(EC_OSPF_TE_UNEXPECTED,
fd3c7692 1464 "MPLS-TE (%s): Invalid parameter?", __func__);
d62a17ae 1465 lsa->data->ls_age =
1466 htons(OSPF_LSA_MAXAGE); /* Flush it anyway. */
20a7c80c
DS		 1467 ospf_opaque_lsa_flush_schedule(lsa);
1468 return NULL;
d62a17ae 1469 }
1470
1471 /* Check if lp was not disable in the interval */
1472 if (!CHECK_FLAG(lp->flags, LPFLG_LSA_ACTIVE)) {
fd3c7692
OD		 1473 flog_warn(EC_OSPF_TE_UNEXPECTED,
1474 "MPLS-TE (%s): lp was disabled: Flush it!", __func__);
d62a17ae 1475 lsa->data->ls_age =
1476 htons(OSPF_LSA_MAXAGE); /* Flush it anyway. */
1477 }
1478
1479 /* If the lsa's age reached to MaxAge, start flushing procedure. */
1480 if (IS_LSA_MAXAGE(lsa)) {
20a7c80c 1481 UNSET_FLAG(lp->flags, LPFLG_LSA_ENGAGED);
d62a17ae 1482 ospf_opaque_lsa_flush_schedule(lsa);
ead99d5f 1483 return NULL;
d62a17ae 1484 }
b5a8894d 1485 top = ospf_lookup_by_vrf_id(lsa->vrf_id);
d62a17ae 1486 /* Create new Opaque-LSA/MPLS-TE instance. */
b5a8894d
CS		 1487 new = ospf_mpls_te_lsa_new(top, area, lp);
1488 if (new == NULL) {
cf444bcf 1489 flog_warn(EC_OSPF_TE_UNEXPECTED,
fd3c7692 1490 "MPLS-TE (%s): ospf_mpls_te_lsa_new() ?", __func__);
ead99d5f 1491 return NULL;
d62a17ae 1492 }
1493 new->data->ls_seqnum = lsa_seqnum_increment(lsa);
1494
1495 /* Install this LSA into LSDB. */
1496 /* Given "lsa" will be freed in the next function. */
1497 /* As area could be NULL i.e. when using OPAQUE_LSA_AS, we prefer to use
1498 * ospf_lookup() to get ospf instance */
1499 if (area)
1500 top = area->ospf;
d62a17ae 1501
1502 if (ospf_lsa_install(top, NULL /*oi */, new) == NULL) {
cf444bcf 1503 flog_warn(EC_OSPF_LSA_INSTALL_FAILURE,
fd3c7692 1504 "MPLS-TE (%s): ospf_lsa_install() ?", __func__);
d62a17ae 1505 ospf_lsa_unlock(&new);
ead99d5f 1506 return NULL;
d62a17ae 1507 }
1508
1509 /* Flood updated LSA through AS or Area depending of the RFC of the link
1510 */
2efd7e2b 1511 if (IS_FLOOD_AS(lp->flags))
d62a17ae 1512 ospf_flood_through_as(top, NULL, new);
1513 else
1514 ospf_flood_through_area(area, NULL /*nbr*/, new);
1515
1516 /* Debug logging. */
fd3c7692
OD		 1517 ote_debug("MPLS-TE (%s): LSA[Type%d:%pI4]: Refresh Opaque-LSA/MPLS-TE",
1518 __func__, new->data->type, &new->data->id);
1519 if (IS_DEBUG_OSPF(lsa, LSA_GENERATE))
d62a17ae 1520 ospf_lsa_header_dump(new->data);
d62a17ae 1521
d62a17ae 1522 return new;
1523}
1524
2a39170c 1525void ospf_mpls_te_lsa_schedule(struct mpls_te_link *lp, enum lsa_opcode opcode)
d62a17ae 1526{
1527 struct ospf_lsa lsa;
1528 struct lsa_header lsah;
1529 struct ospf *top;
d7c0a89a 1530 uint32_t tmp;
d62a17ae 1531
1532 memset(&lsa, 0, sizeof(lsa));
1533 memset(&lsah, 0, sizeof(lsah));
b5a8894d 1534 top = ospf_lookup_by_vrf_id(VRF_DEFAULT);
d62a17ae 1535
1536 /* Check if the pseudo link is ready to flood */
2efd7e2b 1537 if (!CHECK_FLAG(lp->flags, LPFLG_LSA_ACTIVE))
d62a17ae 1538 return;
d62a17ae 1539
f173deb3
OD		 1540 ote_debug("MPLS-TE (%s): Schedule %s%s%s LSA for interface %s",
1541 __func__,
fd3c7692
OD		 1542 opcode == REORIGINATE_THIS_LSA ? "Re-Originate" : "",
1543 opcode == REFRESH_THIS_LSA ? "Refresh" : "",
1544 opcode == FLUSH_THIS_LSA ? "Flush" : "",
1545 lp->ifp ? lp->ifp->name : "-");
1546
d62a17ae 1547 lsa.area = lp->area;
1548 lsa.data = &lsah;
2efd7e2b 1549 if (IS_FLOOD_AS(lp->flags)) {
d62a17ae 1550 lsah.type = OSPF_OPAQUE_AS_LSA;
1551 tmp = SET_OPAQUE_LSID(OPAQUE_TYPE_INTER_AS_LSA, lp->instance);
1552 lsah.id.s_addr = htonl(tmp);
1553 } else {
1554 lsah.type = OSPF_OPAQUE_AREA_LSA;
1555 if (IS_INTER_AS(lp->type)) {
1556 /* Set the area context if not know */
1557 if (lp->area == NULL)
1558 lp->area = ospf_area_lookup_by_area_id(
1559 top, OspfMplsTE.interas_areaid);
1560 /* Unable to set the area context. Abort! */
1561 if (lp->area == NULL) {
ade6974d 1562 flog_warn(
cf444bcf 1563 EC_OSPF_TE_UNEXPECTED,
fd3c7692
OD		 1564 "MPLS-TE (%s): Area context is null. Abort !",
1565 __func__);
d62a17ae 1566 return;
1567 }
1568 tmp = SET_OPAQUE_LSID(OPAQUE_TYPE_INTER_AS_LSA,
1569 lp->instance);
1570 } else
1571 tmp = SET_OPAQUE_LSID(
1572 OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA,
1573 lp->instance);
1574 lsah.id.s_addr = htonl(tmp);
1575 }
1576
1577 switch (opcode) {
1578 case REORIGINATE_THIS_LSA:
2efd7e2b 1579 if (IS_FLOOD_AS(lp->flags)) {
d62a17ae 1580 ospf_opaque_lsa_reoriginate_schedule(
1581 (void *)top, OSPF_OPAQUE_AS_LSA,
1582 OPAQUE_TYPE_INTER_AS_LSA);
2efd7e2b 1583 } else {
d62a17ae 1584 if (IS_INTER_AS(lp->type))
1585 ospf_opaque_lsa_reoriginate_schedule(
1586 (void *)lp->area, OSPF_OPAQUE_AREA_LSA,
1587 OPAQUE_TYPE_INTER_AS_LSA);
1588 else
1589 ospf_opaque_lsa_reoriginate_schedule(
1590 (void *)lp->area, OSPF_OPAQUE_AREA_LSA,
1591 OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA);
d62a17ae 1592 }
1593 break;
1594 case REFRESH_THIS_LSA:
1595 ospf_opaque_lsa_refresh_schedule(&lsa);
1596 break;
1597 case FLUSH_THIS_LSA:
1598 /* Reset Activity flag */
1599 lp->flags = LPFLG_LSA_INACTIVE;
1600 ospf_opaque_lsa_flush_schedule(&lsa);
1601 break;
1602 default:
cf444bcf 1603 flog_warn(EC_OSPF_TE_UNEXPECTED,
fd3c7692 1604 "MPLS-TE (%s): Unknown opcode (%u)", __func__,
d62a17ae 1605 opcode);
1606 break;
1607 }
718e3744 1608}
1609
f173deb3
OD		 1610/**
1611 * ------------------------------------------------------
78dfa0c7 1612 * Following are Link State Data Base control functions.
f173deb3
OD		 1613 * ------------------------------------------------------
1614 */
718e3744 1615
f173deb3
OD		 1616/**
1617 * Get Vertex from TED by the router which advertised the LSA. A new Vertex and
1618 * associated Link State Node are created if Vertex is not found.
1619 *
1620 * @param ted Link State Traffic Engineering Database
1621 * @param lsa OSPF Link State Advertisement
1622 *
1623 * @return Link State Vertex
1624 */
1625static struct ls_vertex *get_vertex(struct ls_ted *ted, struct ospf_lsa *lsa)
718e3744 1626{
f173deb3
OD		 1627 struct ls_node_id lnid;
1628 struct ls_node *lnode;
1629 struct ls_vertex *vertex;
718e3744 1630
f173deb3
OD		 1631 /* Sanity Check */
1632 if (!ted || !lsa || !lsa->data || !lsa->area)
1633 return NULL;
718e3744 1634
f173deb3
OD		 1635 /* Search if a Link State Vertex already exist */
1636 lnid.origin = OSPFv2;
1637 lnid.id.ip.addr = lsa->data->adv_router;
1638 lnid.id.ip.area_id = lsa->area->area_id;
1639 vertex = ls_find_vertex_by_id(ted, lnid);
1640
1641 /* Create Node & Vertex in the Link State Date Base if not found */
1642 if (!vertex) {
1643 const struct in_addr inaddr_any = {.s_addr = INADDR_ANY};
1644
1645 lnode = ls_node_new(lnid, inaddr_any, in6addr_any);
1646 snprintfrr(lnode->name, MAX_NAME_LENGTH, "%pI4",
1647 &lnid.id.ip.addr);
1648 vertex = ls_vertex_add(ted, lnode);
1649 }
1650
1651 if (IS_LSA_SELF(lsa))
1652 ted->self = vertex;
1653
1654 return vertex;
718e3744 1655}
1656
f173deb3
OD		 1657/**
1658 * Get Edge from TED by Link State Attribute ID. A new Edge and associated Link
1659 * State Attributes are created if not found.
1660 *
1661 * @param ted Link State Traffic Engineering Database
1662 * @param adv Link State Node ID of router which advertised Edge
1663 * @param link_id Link State Attribute ID
1664 *
1665 * @return Link State Edge
1666 */
1667static struct ls_edge *get_edge(struct ls_ted *ted, struct ls_node_id adv,
1668 struct in_addr link_id)
718e3744 1669{
dad17a21 1670 struct ls_edge_key key;
f173deb3
OD		 1671 struct ls_edge *edge;
1672 struct ls_attributes *attr;
1673
1674 /* Search Edge that corresponds to the Link ID */
dad17a21
OD		 1675 key.family = AF_INET;
1676 IPV4_ADDR_COPY(&key.k.addr, &link_id);
f173deb3
OD		 1677 edge = ls_find_edge_by_key(ted, key);
1678
1679 /* Create new one if not exist */
1680 if (!edge) {
1681 attr = ls_attributes_new(adv, link_id, in6addr_any, 0);
1682 edge = ls_edge_add(ted, attr);
1683 }
718e3744 1684
f173deb3 1685 return edge;
718e3744 1686}
1687
f173deb3
OD		 1688/**
1689 * Export Link State information to consumer daemon through ZAPI Link State
1690 * Opaque Message.
1691 *
1692 * @param type Type of Link State Element i.e. Vertex, Edge or Subnet
1693 * @param link_state Pointer to Link State Vertex, Edge or Subnet
1694 *
1695 * @return 0 if success, -1 otherwise
1696 */
1697static int ospf_te_export(uint8_t type, void *link_state)
718e3744 1698{
f173deb3
OD		 1699 struct ls_message msg = {};
1700 int rc = 0;
718e3744 1701
f173deb3
OD		 1702 if (!OspfMplsTE.export)
1703 return rc;
1704
1705 switch (type) {
1706 case LS_MSG_TYPE_NODE:
1707 ls_vertex2msg(&msg, (struct ls_vertex *)link_state);
1708 rc = ls_send_msg(zclient, &msg, NULL);
d62a17ae 1709 break;
f173deb3
OD		 1710 case LS_MSG_TYPE_ATTRIBUTES:
1711 ls_edge2msg(&msg, (struct ls_edge *)link_state);
1712 rc = ls_send_msg(zclient, &msg, NULL);
1713 break;
1714 case LS_MSG_TYPE_PREFIX:
1715 ls_subnet2msg(&msg, (struct ls_subnet *)link_state);
1716 rc = ls_send_msg(zclient, &msg, NULL);
d62a17ae 1717 break;
1718 default:
f173deb3 1719 rc = -1;
d62a17ae 1720 break;
1721 }
718e3744 1722
f173deb3 1723 return rc;
718e3744 1724}
1725
f173deb3
OD		 1726/**
1727 * Update Link State Edge & Attributes from the given Link State Attributes ID
1728 * and metric. This function is called when parsing Router LSA.
1729 *
1730 * @param ted Link State Traffic Engineering Database
1731 * @param vertex Vertex where the Edge is attached as source
1732 * @param link_data Link State Edge ID
1733 * @param metric Standard metric attached to this Edge
1734 */
1735static void ospf_te_update_link(struct ls_ted *ted, struct ls_vertex *vertex,
1736 struct in_addr link_data, uint8_t metric)
718e3744 1737{
f173deb3
OD		 1738 struct ls_edge *edge;
1739 struct ls_attributes *attr;
718e3744 1740
f173deb3
OD		 1741 /* Sanity check */
1742 if (!ted || !vertex || !vertex->node)
1743 return;
718e3744 1744
f173deb3
OD		 1745 /* Get Corresponding Edge from Link State Data Base */
1746 edge = get_edge(ted, vertex->node->adv, link_data);
1747 attr = edge->attributes;
718e3744 1748
f173deb3
OD		 1749 /* re-attached edge to vertex if needed */
1750 if (!edge->source)
1751 edge->source = vertex;
718e3744 1752
f173deb3
OD		 1753 /* Check if it is just an LSA refresh */
1754 if ((CHECK_FLAG(attr->flags, LS_ATTR_METRIC)
1755 && (attr->metric == metric))) {
1756 edge->status = SYNC;
1757 return;
1758 }
718e3744 1759
f173deb3
OD		 1760 /* Update metric value */
1761 attr->metric = metric;
1762 SET_FLAG(attr->flags, LS_ATTR_METRIC);
1763 if (edge->status != NEW)
1764 edge->status = UPDATE;
718e3744 1765
f173deb3
OD		 1766 ote_debug(" |- %s Edge %pI4 with metric %d",
1767 edge->status == NEW ? "Add" : "Update", &attr->standard.local,
1768 attr->metric);
1769
1770 /* Export Link State Edge */
1771 ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
1772 edge->status = SYNC;
718e3744 1773}
1774
f173deb3
OD		 1775/**
1776 * Update Link State Subnet & Prefix from the given prefix and metric. This
1777 * function is called when parsing Router LSA.
1778 *
1779 * @param ted Link State Traffic Engineering Database
1780 * @param vertex Vertex where the Edge is attached as source
1781 * @param p Prefix associated to the Subnet
1782 * @param metric Standard metric attached to this Edge
1783 */
1784static void ospf_te_update_subnet(struct ls_ted *ted, struct ls_vertex *vertex,
1785 struct prefix p, uint8_t metric)
718e3744 1786{
f173deb3
OD		 1787 struct ls_subnet *subnet;
1788 struct ls_prefix *ls_pref;
1789
1790 /* Search if there is a Subnet for this prefix */
1791 subnet = ls_find_subnet(ted, p);
1792
1793 /* If found a Subnet, check if it is attached to this Vertex */
1794 if (subnet) {
1795 /* Re-attach the subnet to the vertex if necessary */
1796 if (subnet->vertex != vertex) {
1797 subnet->vertex = vertex;
1798 listnode_add_sort_nodup(vertex->prefixes, subnet);
1799 }
1800 /* Check if it is a simple refresh */
1801 ls_pref = subnet->ls_pref;
1802 if ((CHECK_FLAG(ls_pref->flags, LS_PREF_METRIC))
1803 && (ls_pref->metric == metric)) {
1804 subnet->status = SYNC;
1805 return;
1806 }
1807 ls_pref->metric = metric;
1808 SET_FLAG(ls_pref->flags, LS_PREF_METRIC);
1809 subnet->status = UPDATE;
1810 } else {
1811 /* Create new Link State Prefix */
1812 ls_pref = ls_prefix_new(vertex->node->adv, p);
1813 ls_pref->metric = metric;
1814 SET_FLAG(ls_pref->flags, LS_PREF_METRIC);
1815 /* and add it to the TED */
1816 subnet = ls_subnet_add(ted, ls_pref);
1817 }
718e3744 1818
f173deb3
OD		 1819 ote_debug(" |- %s subnet %pFX with metric %d",
1820 subnet->status == NEW ? "Add" : "Update", &subnet->key,
1821 ls_pref->metric);
718e3744 1822
f173deb3
OD		 1823 /* Export Link State Subnet */
1824 ospf_te_export(LS_MSG_TYPE_PREFIX, subnet);
1825 subnet->status = SYNC;
718e3744 1826}
1827
f173deb3
OD		 1828/**
1829 * Delete Subnet that correspond to the given IPv4 address and export deletion
936fbaef 1830 * information before removal. Prefix length is fixed to IPV4_MAX_BITLEN.
f173deb3
OD		 1831 *
1832 * @param ted Links State Database
1833 * @param addr IPv4 address
1834 */
1835static void ospf_te_delete_subnet(struct ls_ted *ted, struct in_addr addr)
718e3744 1836{
f173deb3
OD		 1837 struct prefix p;
1838 struct ls_subnet *subnet;
1839
1840 /* Search subnet that correspond to the address/32 as prefix */
1841 p.family = AF_INET;
936fbaef 1842 p.prefixlen = IPV4_MAX_BITLEN;
f173deb3
OD		 1843 p.u.prefix4 = addr;
1844 subnet = ls_find_subnet(ted, p);
1845
1846 /* Remove subnet if found */
1847 if (subnet) {
1848 subnet->status = DELETE;
1849 ospf_te_export(LS_MSG_TYPE_PREFIX, subnet);
1850 ls_subnet_del_all(ted, subnet);
1851 }
718e3744 1852}
1853
f173deb3
OD		 1854/**
1855 * Parse Router LSA. This function will create or update corresponding Vertex,
1856 * Edge and Subnet. It also remove Edge and Subnet if they are marked as Orphan
1857 * once Router LSA is parsed.
1858 *
1859 * @param ted Link State Traffic Engineering Database
1860 * @param lsa OSPF Link State Advertisement
1861 *
1862 * @return 0 if success, -1 otherwise
1863 */
1864static int ospf_te_parse_router_lsa(struct ls_ted *ted, struct ospf_lsa *lsa)
718e3744 1865{
f173deb3
OD		 1866 struct router_lsa *rl;
1867 enum ls_node_type type;
1868 struct ls_vertex *vertex;
1869 struct ls_edge *edge;
1870 struct ls_subnet *subnet;
1871 struct listnode *node;
8db278b5 1872 int len, links;
f173deb3
OD		 1873
1874 /* Sanity Check */
1875 if (!ted || !lsa || !lsa->data)
1876 return -1;
1877
1878 ote_debug("MPLS-TE (%s): Parse Router LSA[%pI4] from Router[%pI4]",
1879 __func__, &lsa->data->id, &lsa->data->adv_router);
1880
1881 /* Get vertex from LSA Advertise Router ID */
1882 vertex = get_vertex(ted, lsa);
1883
1884 /* Set Node type information if it has changed */
1885 rl = (struct router_lsa *)lsa->data;
1886 if (IS_ROUTER_LSA_VIRTUAL(rl))
1887 type = PSEUDO;
1888 else if (IS_ROUTER_LSA_EXTERNAL(rl))
1889 type = ASBR;
1890 else if (IS_ROUTER_LSA_BORDER(rl))
1891 type = ABR;
1892 else
1893 type = STANDARD;
1894
1895 if (vertex->status == NEW) {
1896 vertex->node->type = type;
1897 SET_FLAG(vertex->node->flags, LS_NODE_TYPE);
1898 } else if (vertex->node->type != type) {
1899 vertex->node->type = type;
1900 vertex->status = UPDATE;
1901 }
718e3744 1902
f173deb3
OD		 1903 /* Check if Vertex has been modified */
1904 if (vertex->status != SYNC) {
1905 ote_debug(" |- %s Vertex %pI4",
1906 vertex->status == NEW ? "Add" : "Update",
1907 &vertex->node->router_id);
718e3744 1908
f173deb3
OD		 1909 /* Vertex is out of sync: export it */
1910 ospf_te_export(LS_MSG_TYPE_NODE, vertex);
1911 vertex->status = SYNC;
1912 }
1913
1914 /* Mark outgoing Edge and Subnet as ORPHAN to detect deletion */
1915 for (ALL_LIST_ELEMENTS_RO(vertex->outgoing_edges, node, edge))
1916 edge->status = ORPHAN;
1917
1918 for (ALL_LIST_ELEMENTS_RO(vertex->prefixes, node, subnet))
1919 subnet->status = ORPHAN;
1920
1921 /* Then, process Link Information */
8db278b5
OD		 1922 len = lsa->size - OSPF_LSA_HEADER_SIZE - OSPF_ROUTER_LSA_MIN_SIZE;
1923 links = ntohs(rl->links);
1924 for (int i = 0; i < links && len > 0; len -= 12, i++) {
f173deb3
OD		 1925 struct prefix p;
1926 uint32_t metric;
1927
1928 switch (rl->link[i].type) {
1929 case LSA_LINK_TYPE_POINTOPOINT:
1930 ospf_te_update_link(ted, vertex, rl->link[i].link_data,
1931 ntohs(rl->link[i].metric));
1932 /* Add corresponding subnet */
1933 p.family = AF_INET;
936fbaef 1934 p.prefixlen = IPV4_MAX_BITLEN;
f173deb3
OD		 1935 p.u.prefix4 = rl->link[i].link_data;
1936 metric = ntohs(rl->link[i].metric);
1937 ospf_te_update_subnet(ted, vertex, p, metric);
1938 break;
1939 case LSA_LINK_TYPE_STUB:
1940 /* Keep only /32 prefix */
1941 p.prefixlen = ip_masklen(rl->link[i].link_data);
936fbaef 1942 if (p.prefixlen == IPV4_MAX_BITLEN) {
f173deb3
OD		 1943 p.family = AF_INET;
1944 p.u.prefix4 = rl->link[i].link_id;
1945 metric = ntohs(rl->link[i].metric);
1946 ospf_te_update_subnet(ted, vertex, p, metric);
1947 }
1948 break;
1949 default:
1950 break;
1951 }
1952 }
1953 /* Clean remaining Orphan Edges or Subnets */
1954 if (OspfMplsTE.export)
1955 ls_vertex_clean(ted, vertex, zclient);
d62a17ae 1956 else
f173deb3 1957 ls_vertex_clean(ted, vertex, NULL);
718e3744 1958
f173deb3 1959 return 0;
718e3744 1960}
1961
f173deb3
OD		 1962/**
1963 * Delete Vertex, Edge and Subnet associated to this Router LSA. This function
1964 * is called when the router received such LSA with MAX_AGE (Flush) or when the
1965 * router stop OSPF.
1966 *
1967 * @param ted Link State Traffic Engineering Database
1968 * @param lsa OSPF Link State Advertisement
1969 *
1970 * @return 0 if success, -1 otherwise
1971 */
1972static int ospf_te_delete_router_lsa(struct ls_ted *ted, struct ospf_lsa *lsa)
718e3744 1973{
f173deb3
OD		 1974 struct ls_node_id lnid;
1975 struct ls_vertex *vertex;
718e3744 1976
f173deb3
OD		 1977 /* Sanity Check */
1978 if (!ted || !lsa || !lsa->data)
1979 return -1;
718e3744 1980
f173deb3
OD		 1981 /* Search Vertex that corresponds to this LSA */
1982 lnid.origin = OSPFv2;
1983 lnid.id.ip.addr = lsa->data->adv_router;
1984 lnid.id.ip.area_id = lsa->area->area_id;
1985 vertex = ls_find_vertex_by_id(ted, lnid);
1986 if (!vertex)
1987 return -1;
718e3744 1988
f173deb3
OD		 1989 ote_debug("MPLS-TE (%s): Delete Vertex %pI4 from Router LSA[%pI4]",
1990 __func__, &vertex->node->router_id, &lsa->data->id);
718e3744 1991
f173deb3
OD		 1992 /* Export deleted vertex ... */
1993 vertex->status = DELETE;
1994 ospf_te_export(LS_MSG_TYPE_NODE, vertex);
16f1b9ee 1995
f173deb3
OD		 1996 /* ... and remove Node & Vertex from Link State Date Base */
1997 ls_vertex_del_all(ted, vertex);
718e3744 1998
f173deb3 1999 return 0;
718e3744 2000}
2001
f173deb3
OD		 2002/**
2003 * Create or update Remote Vertex that corresponds to the remote ASBR of the
2004 * foreign network if Edge is associated to an Inter-AS LSA (Type 6).
2005 *
2006 * @param ted Link State Traffic Engineering Database
2007 * @param edge Link State Edge
2008 */
2009static void ospf_te_update_remote_asbr(struct ls_ted *ted, struct ls_edge *edge)
718e3744 2010{
f173deb3
OD		 2011 struct ls_node_id lnid;
2012 struct ls_vertex *vertex;
2013 struct ls_node *lnode;
2014 struct ls_attributes *attr;
2015 struct prefix p;
2016
2017 /* Sanity Check */
2018 if (!ted || !edge)
2019 return;
718e3744 2020
f173deb3
OD		 2021 /* Search if a Link State Vertex already exist */
2022 attr = edge->attributes;
2023 lnid.origin = OSPFv2;
2024 lnid.id.ip.addr = attr->standard.remote_addr;
2025 lnid.id.ip.area_id = attr->adv.id.ip.area_id;
2026 vertex = ls_find_vertex_by_id(ted, lnid);
2027
2028 /* Create Node & Vertex in the Link State Date Base if not found */
2029 if (!vertex) {
2030 const struct in_addr inaddr_any = {.s_addr = INADDR_ANY};
2031
2032 lnode = ls_node_new(lnid, inaddr_any, in6addr_any);
2033 snprintfrr(lnode->name, MAX_NAME_LENGTH, "%pI4",
2034 &lnid.id.ip.addr);
2035 vertex = ls_vertex_add(ted, lnode);
2036 }
16f1b9ee 2037
f173deb3
OD		 2038 /* Update Node information */
2039 lnode = vertex->node;
2040 if (CHECK_FLAG(lnode->flags, LS_NODE_TYPE)) {
2041 if (lnode->type != RMT_ASBR) {
2042 lnode->type = RMT_ASBR;
2043 if (vertex->status != NEW)
2044 vertex->status = UPDATE;
2045 }
2046 } else {
2047 lnode->type = RMT_ASBR;
2048 SET_FLAG(lnode->flags, LS_NODE_TYPE);
2049 if (vertex->status != NEW)
2050 vertex->status = UPDATE;
2051 }
2052 if (CHECK_FLAG(lnode->flags, LS_NODE_AS_NUMBER)) {
2053 if (lnode->as_number != attr->standard.remote_as) {
2054 lnode->as_number = attr->standard.remote_as;
2055 if (vertex->status != NEW)
2056 vertex->status = UPDATE;
2057 }
2058 } else {
2059 lnode->as_number = attr->standard.remote_as;
2060 SET_FLAG(lnode->flags, LS_NODE_AS_NUMBER);
2061 if (vertex->status != NEW)
2062 vertex->status = UPDATE;
2063 }
16f1b9ee 2064
f173deb3
OD		 2065 /* Export Link State Vertex if needed */
2066 if (vertex->status == NEW || vertex->status == UPDATE) {
2067 ote_debug(" |- %s Remote Vertex %pI4 for AS %u",
2068 vertex->status == NEW ? "Add" : "Update",
2069 &lnode->router_id, lnode->as_number);
2070 ospf_te_export(LS_MSG_TYPE_NODE, vertex);
2071 vertex->status = SYNC;
2072 }
16f1b9ee 2073
f173deb3
OD		 2074 /* Update corresponding Subnets */
2075 p.family = AF_INET;
936fbaef 2076 p.prefixlen = IPV4_MAX_BITLEN;
f173deb3
OD		 2077 p.u.prefix4 = attr->standard.local;
2078 ospf_te_update_subnet(ted, edge->source, p, attr->standard.te_metric);
2079
2080 p.family = AF_INET;
936fbaef 2081 p.prefixlen = IPV4_MAX_BITLEN;
f173deb3
OD		 2082 p.u.prefix4 = attr->standard.remote_addr;
2083 ospf_te_update_subnet(ted, vertex, p, attr->standard.te_metric);
2084
2085 /* Connect Edge to the remote Vertex */
2086 if (edge->destination == NULL) {
2087 edge->destination = vertex;
2088 listnode_add_sort_nodup(vertex->incoming_edges, edge);
2089 }
16f1b9ee 2090
f173deb3
OD		 2091 /* Finally set type to ASBR the node that advertised this Edge ... */
2092 vertex = edge->source;
2093 lnode = vertex->node;
2094 if (CHECK_FLAG(lnode->flags, LS_NODE_TYPE)) {
2095 if (lnode->type != ASBR) {
2096 lnode->type = ASBR;
2097 if (vertex->status != NEW)
2098 vertex->status = UPDATE;
2099 }
d62a17ae 2100 } else {
f173deb3
OD		 2101 lnode->type = ASBR;
2102 SET_FLAG(lnode->flags, LS_NODE_TYPE);
2103 if (vertex->status != NEW)
2104 vertex->status = UPDATE;
d62a17ae 2105 }
16f1b9ee 2106
f173deb3
OD		 2107 /* ... and Export it if needed */
2108 if (vertex->status == NEW || vertex->status == UPDATE) {
2109 ospf_te_export(LS_MSG_TYPE_NODE, vertex);
2110 vertex->status = SYNC;
2111 }
2112}
2113
2114/**
2115 * Parse Opaque Traffic Engineering LSA (Type 1) TLVs and create or update the
2116 * corresponding Link State Edge and Attributes. Vertex connections are also
2117 * updated if needed based on the remote IP address of the Edge and existing
2118 * reverse Edge.
2119 *
2120 * @param ted Link State Traffic Engineering Database
2121 * @param lsa OSPF Link State Advertisement
2122 *
2123 * @return 0 if success, -1 otherwise
2124 */
2125static int ospf_te_parse_te(struct ls_ted *ted, struct ospf_lsa *lsa)
2126{
2127 struct ls_edge *edge;
2128 struct ls_vertex *vertex;
2129 struct ls_attributes *old, attr = {};
2130 struct tlv_header *tlvh;
2131 void *value;
2132 uint16_t len, sum;
2133 uint8_t lsa_id;
2134
2135 /* Initialize Attribute */
2136 attr.adv.origin = OSPFv2;
2137 attr.adv.id.ip.addr = lsa->data->adv_router;
2138 if (lsa->data->type != OSPF_OPAQUE_AS_LSA)
2139 attr.adv.id.ip.area_id = lsa->area->area_id;
2140
2141 /* Initialize TLV browsing */
2142 tlvh = TLV_HDR_TOP(lsa->data);
8db278b5 2143 len = lsa->size - OSPF_LSA_HEADER_SIZE;
f173deb3 2144
8db278b5
OD		 2145 /* Check if TE Router-ID TLV is present */
2146 if (ntohs(tlvh->type) == TE_TLV_ROUTER_ADDR) {
2147 /* if TE Router-ID is alone, we are done ... */
2148 if (len == TE_LINK_SUBTLV_DEF_SIZE)
2149 return 0;
23508fff 2150
8db278b5
OD		 2151 /* ... otherwise, skip it */
2152 len -= TE_LINK_SUBTLV_DEF_SIZE + TLV_HDR_SIZE;
f173deb3 2153 tlvh = TLV_HDR_NEXT(tlvh);
8db278b5 2154 }
f173deb3 2155
8db278b5 2156 /* Check if we have a valid TE Link TLV */
f173deb3
OD		 2157 if ((len == 0) || (ntohs(tlvh->type) != TE_TLV_LINK))
2158 return 0;
2159
e3db39db 2160 sum = sizeof(struct tlv_header);
f173deb3
OD		 2161 /* Browse sub-TLV and fulfill Link State Attributes */
2162 for (tlvh = TLV_DATA(tlvh); sum < len; tlvh = TLV_HDR_NEXT(tlvh)) {
2163 uint32_t val32, tab32[2];
2164 float valf, tabf[8];
2165 struct in_addr addr;
2166
2167 value = TLV_DATA(tlvh);
2168 switch (ntohs(tlvh->type)) {
2169 case TE_LINK_SUBTLV_LCLIF_IPADDR:
2170 memcpy(&addr, value, TE_LINK_SUBTLV_DEF_SIZE);
2171 attr.standard.local = addr;
2172 SET_FLAG(attr.flags, LS_ATTR_LOCAL_ADDR);
2173 break;
2174 case TE_LINK_SUBTLV_RMTIF_IPADDR:
2175 memcpy(&addr, value, TE_LINK_SUBTLV_DEF_SIZE);
2176 attr.standard.remote = addr;
2177 SET_FLAG(attr.flags, LS_ATTR_NEIGH_ADDR);
2178 break;
2179 case TE_LINK_SUBTLV_TE_METRIC:
2180 memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
2181 attr.standard.te_metric = ntohl(val32);
2182 SET_FLAG(attr.flags, LS_ATTR_TE_METRIC);
2183 break;
2184 case TE_LINK_SUBTLV_MAX_BW:
2185 memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
2186 attr.standard.max_bw = ntohf(valf);
2187 SET_FLAG(attr.flags, LS_ATTR_MAX_BW);
2188 break;
2189 case TE_LINK_SUBTLV_MAX_RSV_BW:
2190 memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
2191 attr.standard.max_rsv_bw = ntohf(valf);
2192 SET_FLAG(attr.flags, LS_ATTR_MAX_RSV_BW);
2193 break;
2194 case TE_LINK_SUBTLV_UNRSV_BW:
2195 memcpy(tabf, value, TE_LINK_SUBTLV_UNRSV_SIZE);
2196 for (int i = 0; i < MAX_CLASS_TYPE; i++)
2197 attr.standard.unrsv_bw[i] = ntohf(tabf[i]);
2198 SET_FLAG(attr.flags, LS_ATTR_UNRSV_BW);
2199 break;
2200 case TE_LINK_SUBTLV_RSC_CLSCLR:
2201 memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
2202 attr.standard.admin_group = ntohl(val32);
2203 SET_FLAG(attr.flags, LS_ATTR_ADM_GRP);
2204 break;
2205 case TE_LINK_SUBTLV_LLRI:
2206 memcpy(tab32, value, TE_LINK_SUBTLV_LLRI_SIZE);
2207 attr.standard.local_id = ntohl(tab32[0]);
2208 attr.standard.remote_id = ntohl(tab32[1]);
2209 SET_FLAG(attr.flags, LS_ATTR_LOCAL_ID);
2210 SET_FLAG(attr.flags, LS_ATTR_NEIGH_ID);
2211 break;
2212 case TE_LINK_SUBTLV_RIP:
2213 memcpy(&addr, value, TE_LINK_SUBTLV_DEF_SIZE);
2214 attr.standard.remote_addr = addr;
2215 SET_FLAG(attr.flags, LS_ATTR_REMOTE_ADDR);
2216 break;
2217 case TE_LINK_SUBTLV_RAS:
2218 memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
2219 attr.standard.remote_as = ntohl(val32);
2220 SET_FLAG(attr.flags, LS_ATTR_REMOTE_AS);
2221 break;
2222 case TE_LINK_SUBTLV_AV_DELAY:
2223 memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
2224 attr.extended.delay = ntohl(val32);
2225 SET_FLAG(attr.flags, LS_ATTR_DELAY);
2226 break;
2227 case TE_LINK_SUBTLV_MM_DELAY:
2228 memcpy(tab32, value, TE_LINK_SUBTLV_MM_DELAY_SIZE);
2229 attr.extended.min_delay = ntohl(tab32[0]);
2230 attr.extended.max_delay = ntohl(tab32[1]);
2231 SET_FLAG(attr.flags, LS_ATTR_MIN_MAX_DELAY);
2232 break;
2233 case TE_LINK_SUBTLV_DELAY_VAR:
2234 memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
2235 attr.extended.jitter = ntohl(val32);
2236 SET_FLAG(attr.flags, LS_ATTR_JITTER);
2237 break;
2238 case TE_LINK_SUBTLV_PKT_LOSS:
2239 memcpy(&val32, value, TE_LINK_SUBTLV_DEF_SIZE);
2240 attr.extended.pkt_loss = ntohl(val32);
2241 SET_FLAG(attr.flags, LS_ATTR_PACKET_LOSS);
2242 break;
2243 case TE_LINK_SUBTLV_RES_BW:
2244 memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
2245 attr.extended.rsv_bw = ntohf(valf);
2246 SET_FLAG(attr.flags, LS_ATTR_RSV_BW);
2247 break;
2248 case TE_LINK_SUBTLV_AVA_BW:
2249 memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
2250 attr.extended.ava_bw = ntohf(valf);
2251 SET_FLAG(attr.flags, LS_ATTR_AVA_BW);
2252 break;
2253 case TE_LINK_SUBTLV_USE_BW:
2254 memcpy(&valf, value, TE_LINK_SUBTLV_DEF_SIZE);
2255 attr.extended.used_bw = ntohf(valf);
2256 SET_FLAG(attr.flags, LS_ATTR_USE_BW);
2257 break;
2258 default:
2259 break;
2260 }
2261 sum += TLV_SIZE(tlvh);
2262 }
2263
2264 /* Get corresponding Edge from Link State Data Base */
2265 edge = get_edge(ted, attr.adv, attr.standard.local);
2266 old = edge->attributes;
2267
2268 ote_debug(" |- Process Traffic Engineering LSA %pI4 for Edge %pI4",
2269 &lsa->data->id, &attr.standard.local);
2270
2271 /* Update standard fields */
2272 len = sizeof(struct ls_standard);
2273 if ((attr.flags & 0x0FFFF) == (old->flags & 0x0FFFF)) {
2274 if (memcmp(&attr.standard, &old->standard, len) != 0) {
2275 memcpy(&old->standard, &attr.standard, len);
2276 if (edge->status != NEW)
2277 edge->status = UPDATE;
2278 }
2279 } else {
2280 memcpy(&old->standard, &attr.standard, len);
2281 old->flags |= attr.flags & 0x0FFFF;
2282 if (edge->status != NEW)
2283 edge->status = UPDATE;
2284 }
2285 /* Update extended fields */
2286 len = sizeof(struct ls_extended);
2287 if ((attr.flags & 0x0FF0000) == (old->flags & 0x0FF0000)) {
2288 if (memcmp(&attr.extended, &old->extended, len) != 0) {
2289 memcpy(&old->extended, &attr.extended, len);
2290 if (edge->status != NEW)
2291 edge->status = UPDATE;
2292 }
2293 } else {
2294 memcpy(&old->extended, &attr.extended, len);
2295 old->flags |= attr.flags & 0x0FF0000;
2296 if (edge->status != NEW)
2297 edge->status = UPDATE;
2298 }
2299
2300 /* If LSA is an Opaque Inter-AS, Add Node and Subnet */
2301 lsa_id = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
2302 if (lsa_id == OPAQUE_TYPE_INTER_AS_LSA)
2303 ospf_te_update_remote_asbr(ted, edge);
2304
2305 /* Update remote Link if remote IP addr is known */
2306 if (CHECK_FLAG(old->flags, LS_ATTR_NEIGH_ADDR)) {
2307 struct ls_edge *dst;
2308
2309 dst = ls_find_edge_by_destination(ted, old);
2310 /* Attach remote link if not set */
2311 if (dst && edge->source && dst->destination == NULL) {
2312 vertex = edge->source;
2313 if (vertex->incoming_edges)
2314 listnode_add_sort_nodup(vertex->incoming_edges,
2315 dst);
2316 dst->destination = vertex;
2317 }
2318 /* and destination vertex to this edge */
2319 if (dst && dst->source && edge->destination == NULL) {
2320 vertex = dst->source;
2321 if (vertex->incoming_edges)
2322 listnode_add_sort_nodup(vertex->incoming_edges,
2323 edge);
2324 edge->destination = vertex;
2325 }
2326 }
2327
2328 /* Export Link State Edge if needed */
2329 if (edge->status == NEW || edge->status == UPDATE) {
2330 ote_debug(" |- %s TE info. for Edge %pI4",
2331 edge->status == NEW ? "Add" : "Update",
2332 &edge->attributes->standard.local);
2333
2334 ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
2335 edge->status = SYNC;
2336 }
2337
2338 return 0;
2339}
2340
2341/**
2342 * Delete Link State Attributes information that correspond to the Opaque
2343 * Traffic Engineering LSA (Type 1) TLVs. Note that the Edge is not removed.
2344 *
2345 * @param ted Link State Traffic Engineering Database
2346 * @param lsa OSPF Link State Advertisement
2347 *
2348 * @return 0 if success, -1 otherwise
2349 */
2350static int ospf_te_delete_te(struct ls_ted *ted, struct ospf_lsa *lsa)
2351{
2352 struct ls_edge *edge;
2353 struct ls_attributes *attr;
2354 struct tlv_header *tlvh;
2355 struct in_addr addr;
dad17a21 2356 struct ls_edge_key key = {.family = AF_UNSPEC};
f173deb3
OD		 2357 uint16_t len, sum;
2358 uint8_t lsa_id;
2359
2360 /* Initialize TLV browsing */
2361 tlvh = TLV_HDR_TOP(lsa->data);
2362 /* Skip Router TE ID if present */
2363 if (ntohs(tlvh->type) == TE_TLV_ROUTER_ADDR)
2364 tlvh = TLV_HDR_NEXT(tlvh);
2365 len = TLV_BODY_SIZE(tlvh);
e3db39db 2366 sum = sizeof(struct tlv_header);
f173deb3
OD		 2367
2368 /* Browse sub-TLV to find Link ID */
2369 for (tlvh = TLV_DATA(tlvh); sum < len; tlvh = TLV_HDR_NEXT(tlvh)) {
2370 if (ntohs(tlvh->type) == TE_LINK_SUBTLV_LCLIF_IPADDR) {
2371 memcpy(&addr, TLV_DATA(tlvh), TE_LINK_SUBTLV_DEF_SIZE);
dad17a21
OD		 2372 key.family = AF_INET;
2373 IPV4_ADDR_COPY(&key.k.addr, &addr);
f173deb3
OD		 2374 break;
2375 }
2376 sum += TLV_SIZE(tlvh);
2377 }
dad17a21 2378 if (key.family == AF_UNSPEC)
f173deb3
OD		 2379 return 0;
2380
2381 /* Search Edge that corresponds to the Link ID */
2382 edge = ls_find_edge_by_key(ted, key);
2383 if (!edge || !edge->attributes)
2384 return 0;
2385 attr = edge->attributes;
2386
2387 /* First, remove Remote ASBR and associated Edge & Subnet if any */
2388 lsa_id = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
2389 if (lsa_id == OPAQUE_TYPE_INTER_AS_LSA) {
2390 ote_debug(" |- Delete remote ASBR, Edge and Subnet");
2391
2392 if (edge->destination) {
2393 edge->destination->status = DELETE;
2394 ospf_te_export(LS_MSG_TYPE_NODE, edge->destination);
2395 ls_vertex_del_all(ted, edge->destination);
2396 }
2397
2398 ospf_te_delete_subnet(ted, attr->standard.local);
2399
2400 edge->status = DELETE;
2401 ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
2402 ls_edge_del_all(ted, edge);
2403
2404 return 0;
2405 }
2406
2407 ote_debug(" |- Delete TE info. for Edge %pI4",
2408 &edge->attributes->standard.local);
2409
2410 /* Remove Link State Attributes TE information */
2411 memset(&attr->standard, 0, sizeof(struct ls_standard));
2412 attr->flags &= 0x0FFFF;
2413 memset(&attr->extended, 0, sizeof(struct ls_extended));
2414 attr->flags &= 0x0FF0000;
2415 ls_attributes_srlg_del(attr);
2416
2417 /* Export Edge that has been updated */
2418 if (CHECK_FLAG(attr->flags, LS_ATTR_ADJ_SID)
2419 || CHECK_FLAG(attr->flags, LS_ATTR_BCK_ADJ_SID)) {
2420 edge->status = UPDATE;
2421 ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
2422 edge->status = SYNC;
2423 } else {
2424 /* Remove completely the Edge if Segment Routing is not set */
2425 ospf_te_delete_subnet(ted, attr->standard.local);
2426 edge->status = DELETE;
2427 ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
2428 ls_edge_del_all(ted, edge);
2429 }
2430
2431 return 0;
2432}
2433
2434/**
2435 * Parse Opaque Router Information LSA (Type 4) TLVs and update the
2436 * corresponding Link State Vertex with these information (Segment Routing).
2437 *
2438 * @param ted Link State Traffic Engineering Database
2439 * @param lsa OSPF Link State Advertisement
2440 *
2441 * @return 0 if success, -1 otherwise
2442 */
2443static int ospf_te_parse_ri(struct ls_ted *ted, struct ospf_lsa *lsa)
2444{
2445 struct ls_vertex *vertex;
2446 struct ls_node *node;
2447 struct lsa_header *lsah = lsa->data;
2448 struct tlv_header *tlvh;
2449 uint16_t len = 0, sum = 0;
2450
2451 /* Get vertex / Node from LSA Advertised Router ID */
2452 vertex = get_vertex(ted, lsa);
2453 node = vertex->node;
2454
2455 ote_debug(" |- Process Router Information LSA %pI4 for Vertex %pI4",
2456 &lsa->data->id, &node->router_id);
2457
2458 /* Initialize TLV browsing */
8db278b5
OD		 2459 len = lsa->size - OSPF_LSA_HEADER_SIZE;
2460 for (tlvh = TLV_HDR_TOP(lsah); sum < len && tlvh;
2461 tlvh = TLV_HDR_NEXT(tlvh)) {
f173deb3
OD		 2462 struct ri_sr_tlv_sr_algorithm *algo;
2463 struct ri_sr_tlv_sid_label_range *range;
2464 struct ri_sr_tlv_node_msd *msd;
2465 uint32_t size, lower;
2466
2467 switch (ntohs(tlvh->type)) {
2468 case RI_SR_TLV_SR_ALGORITHM:
2469 algo = (struct ri_sr_tlv_sr_algorithm *)tlvh;
2470
2471 for (int i = 0; i < ntohs(algo->header.length); i++) {
2472 if (CHECK_FLAG(node->flags, LS_NODE_SR)
2473 && (node->algo[i] == algo->value[i]))
2474 continue;
2475
2476 node->algo[i] = algo->value[i];
2477 SET_FLAG(node->flags, LS_NODE_SR);
2478 if (vertex->status != NEW)
2479 vertex->status = UPDATE;
2480 }
2481
2482 /* Reset other Algorithms */
2483 for (int i = ntohs(algo->header.length); i < 2; i++) {
2484 if (vertex->status != NEW
2485 && node->algo[i] != SR_ALGORITHM_UNSET)
2486 vertex->status = UPDATE;
2487 node->algo[i] = SR_ALGORITHM_UNSET;
2488 }
2489
2490 break;
2491
2492 case RI_SR_TLV_SRGB_LABEL_RANGE:
2493 range = (struct ri_sr_tlv_sid_label_range *)tlvh;
2494 size = GET_RANGE_SIZE(ntohl(range->size));
2495 lower = GET_LABEL(ntohl(range->lower.value));
2496 if ((CHECK_FLAG(node->flags, LS_NODE_SR))
2497 && ((node->srgb.range_size == size)
2498 && (node->srgb.lower_bound == lower)))
2499 break;
2500
2501 node->srgb.range_size = size;
2502 node->srgb.lower_bound = lower;
2503 SET_FLAG(node->flags, LS_NODE_SR);
2504 if (vertex->status != NEW)
2505 vertex->status = UPDATE;
2506
2507 break;
2508
2509 case RI_SR_TLV_SRLB_LABEL_RANGE:
2510 range = (struct ri_sr_tlv_sid_label_range *)tlvh;
2511 size = GET_RANGE_SIZE(ntohl(range->size));
2512 lower = GET_LABEL(ntohl(range->lower.value));
2513 if ((CHECK_FLAG(node->flags, LS_NODE_SRLB))
2514 && ((node->srlb.range_size == size)
2515 && (node->srlb.lower_bound == lower)))
2516 break;
2517
2518 node->srlb.range_size = size;
2519 node->srlb.lower_bound = lower;
2520 SET_FLAG(node->flags, LS_NODE_SRLB);
2521 if (vertex->status != NEW)
2522 vertex->status = UPDATE;
2523
2524 break;
2525
2526 case RI_SR_TLV_NODE_MSD:
2527 msd = (struct ri_sr_tlv_node_msd *)tlvh;
2528 if ((CHECK_FLAG(node->flags, LS_NODE_MSD))
2529 && (node->msd == msd->value))
2530 break;
2531
2532 node->msd = msd->value;
2533 SET_FLAG(node->flags, LS_NODE_MSD);
2534 if (vertex->status != NEW)
2535 vertex->status = UPDATE;
2536
2537 break;
2538
2539 default:
2540 break;
2541 }
2542 sum += TLV_SIZE(tlvh);
2543 }
2544
2545 /* Vertex has been created or updated: export it */
2546 if (vertex->status == NEW || vertex->status == UPDATE) {
2547 ote_debug(" |- %s SR info - SRGB[%d/%d] for Vertex %pI4",
2548 vertex->status == NEW ? "Add" : "Update",
2549 vertex->node->srgb.lower_bound,
2550 vertex->node->srgb.range_size,
2551 &vertex->node->router_id);
2552
2553 ospf_te_export(LS_MSG_TYPE_NODE, vertex);
2554 vertex->status = SYNC;
2555 }
2556
2557 return 0;
2558}
2559
2560/**
2561 * Delete Link State Node information (Segment Routing) that correspond to the
2562 * Opaque Router Information LSA (Type 4) TLVs. Note that the Vertex is not
2563 * removed.
2564 *
2565 * @param ted Link State Traffic Engineering Database
2566 * @param lsa OSPF Link State Advertisement
2567 *
2568 * @return 0 if success, -1 otherwise
2569 */
2570static int ospf_te_delete_ri(struct ls_ted *ted, struct ospf_lsa *lsa)
2571{
2572 struct ls_node_id lnid;
2573 struct ls_vertex *vertex;
2574 struct ls_node *node;
2575
2576 /* Search if a Link State Vertex already exist */
2577 lnid.origin = OSPFv2;
2578 lnid.id.ip.addr = lsa->data->adv_router;
2579 lnid.id.ip.area_id = lsa->area->area_id;
2580 vertex = ls_find_vertex_by_id(ted, lnid);
2581 if (!vertex)
2582 return -1;
2583
2584 /* Remove Segment Routing Information if any */
2585 node = vertex->node;
2586 UNSET_FLAG(node->flags, LS_NODE_SR);
2587 memset(&node->srgb, 0, sizeof(struct ls_srgb));
2588 node->algo[0] = SR_ALGORITHM_UNSET;
2589 node->algo[1] = SR_ALGORITHM_UNSET;
2590 UNSET_FLAG(node->flags, LS_NODE_SRLB);
2591 memset(&node->srlb, 0, sizeof(struct ls_srlb));
2592 UNSET_FLAG(node->flags, LS_NODE_MSD);
2593 node->msd = 0;
2594 vertex->status = UPDATE;
2595
2596 ote_debug(" |- Delete SR info. for Vertex %pI4",
2597 &vertex->node->router_id);
2598
2599 /* Vertex has been updated: export it */
2600 ospf_te_export(LS_MSG_TYPE_NODE, vertex);
2601 vertex->status = SYNC;
2602
2603 return 0;
2604}
2605
2606/**
2607 * Parse Opaque Extended Prefix LSA (Type 7) TLVs and update the corresponding
2608 * Link State Subnet with these information (Segment Routing ID).
2609 *
2610 * @param ted Link State Traffic Engineering Database
2611 * @param lsa OSPF Link State Advertisement
2612 *
2613 * @return 0 if success, -1 otherwise
2614 */
2615static int ospf_te_parse_ext_pref(struct ls_ted *ted, struct ospf_lsa *lsa)
2616{
2617 struct ls_node_id lnid;
2618 struct ls_subnet *subnet;
2619 struct ls_prefix *ls_pref;
2620 struct prefix pref;
2621 struct ext_tlv_prefix *ext;
2622 struct ext_subtlv_prefix_sid *pref_sid;
2623 uint32_t label;
2624
2625 /* Get corresponding Subnet from Link State Data Base */
2626 ext = (struct ext_tlv_prefix *)TLV_HDR_TOP(lsa->data);
2627 pref.family = AF_INET;
2628 pref.prefixlen = ext->pref_length;
2629 pref.u.prefix4 = ext->address;
2630 subnet = ls_find_subnet(ted, pref);
2631
2632 /* Create new Link State Prefix if not found */
2633 if (!subnet) {
2634 lnid.origin = OSPFv2;
2635 lnid.id.ip.addr = lsa->data->adv_router;
2636 lnid.id.ip.area_id = lsa->area->area_id;
2637 ls_pref = ls_prefix_new(lnid, pref);
2638 /* and add it to the TED */
2639 subnet = ls_subnet_add(ted, ls_pref);
2640 }
2641
2642 ote_debug(" |- Process Extended Prefix LSA %pI4 for subnet %pFX",
2643 &lsa->data->id, &pref);
2644
2645 /* Initialize TLV browsing */
2646 ls_pref = subnet->ls_pref;
2647 pref_sid = (struct ext_subtlv_prefix_sid *)((char *)(ext) + TLV_HDR_SIZE
2648 + EXT_TLV_PREFIX_SIZE);
2649 label = CHECK_FLAG(pref_sid->flags, EXT_SUBTLV_PREFIX_SID_VFLG)
2650 ? GET_LABEL(ntohl(pref_sid->value))
2651 : ntohl(pref_sid->value);
2652
2653 /* Check if it is a simple refresh */
2654 if (CHECK_FLAG(ls_pref->flags, LS_PREF_SR)
2655 && ls_pref->sr.algo == pref_sid->algorithm
2656 && ls_pref->sr.sid_flag == pref_sid->flags
2657 && ls_pref->sr.sid == label)
2658 return 0;
2659
2660 /* Fulfill SR information */
2661 ls_pref->sr.algo = pref_sid->algorithm;
2662 ls_pref->sr.sid_flag = pref_sid->flags;
2663 ls_pref->sr.sid = label;
2664 SET_FLAG(ls_pref->flags, LS_PREF_SR);
2665 if (subnet->status != NEW)
2666 subnet->status = UPDATE;
2667
2668 /* Export Subnet if needed */
2669 if (subnet->status == NEW || subnet->status == UPDATE) {
2670 ote_debug(" |- %s SID %d to subnet %pFX",
2671 subnet->status == NEW ? "Add" : "Update",
2672 ls_pref->sr.sid, &ls_pref->pref);
2673
2674 ospf_te_export(LS_MSG_TYPE_PREFIX, subnet);
2675 subnet->status = SYNC;
2676 }
2677
2678 return 0;
2679}
2680
2681/**
2682 * Delete Link State Subnet information (Segment Routing ID) that correspond to
2683 * the Opaque Extended Prefix LSA (Type 7) TLVs. Note that the Subnet is not
2684 * removed.
2685 *
2686 * @param ted Link State Traffic Engineering Database
2687 * @param lsa OSPF Link State Advertisement
2688 *
2689 * @return 0 if success, -1 otherwise
2690 */
2691static int ospf_te_delete_ext_pref(struct ls_ted *ted, struct ospf_lsa *lsa)
2692{
2693 struct ls_subnet *subnet;
2694 struct ls_prefix *ls_pref;
2695 struct prefix pref;
2696 struct ext_tlv_prefix *ext;
2697
2698 /* Get corresponding Subnet from Link State Data Base */
2699 ext = (struct ext_tlv_prefix *)TLV_HDR_TOP(lsa->data);
2700 pref.family = AF_INET;
2701 pref.prefixlen = ext->pref_length;
2702 pref.u.prefix4 = ext->address;
2703 subnet = ls_find_subnet(ted, pref);
2704
2705 /* Check if there is a corresponding subnet */
2706 if (!subnet)
2707 return -1;
2708
2709 ote_debug(" |- Delete SID %d to subnet %pFX", subnet->ls_pref->sr.sid,
2710 &subnet->ls_pref->pref);
2711
2712 /* Remove Segment Routing information */
2713 ls_pref = subnet->ls_pref;
2714 UNSET_FLAG(ls_pref->flags, LS_PREF_SR);
2715 memset(&ls_pref->sr, 0, sizeof(struct ls_sid));
2716 subnet->status = UPDATE;
2717
2718 /* Subnet has been updated: export it */
2719 ospf_te_export(LS_MSG_TYPE_PREFIX, subnet);
2720 subnet->status = SYNC;
2721
2722 return 0;
2723}
2724
2725/**
2726 * Parse Opaque Extended Link LSA (Type 8) TLVs and update the corresponding
2727 * Link State Edge with these information (Segment Routing Adjacency).
2728 *
2729 * @param ted Link State Traffic Engineering Database
2730 * @param lsa OSPF Link State Advertisement
2731 *
2732 * @return 0 if success, -1 otherwise
2733 */
2734static int ospf_te_parse_ext_link(struct ls_ted *ted, struct ospf_lsa *lsa)
2735{
2736 struct ls_node_id lnid;
2737 struct tlv_header *tlvh;
2738 struct ext_tlv_link *ext;
2739 struct ls_edge *edge;
2740 struct ls_attributes *atr;
2741 uint16_t len = 0, sum = 0, i;
2742 uint32_t label;
2743
2744 /* Get corresponding Edge from Link State Data Base */
2745 lnid.origin = OSPFv2;
2746 lnid.id.ip.addr = lsa->data->adv_router;
2747 lnid.id.ip.area_id = lsa->area->area_id;
2748 ext = (struct ext_tlv_link *)TLV_HDR_TOP(lsa->data);
2749 edge = get_edge(ted, lnid, ext->link_data);
2750 atr = edge->attributes;
2751
2752 ote_debug(" |- Process Extended Link LSA %pI4 for edge %pI4",
2753 &lsa->data->id, &edge->attributes->standard.local);
2754
2755 /* Initialize TLV browsing */
23508fff 2756 len = TLV_BODY_SIZE(&ext->header) - EXT_TLV_LINK_SIZE;
f173deb3
OD		 2757 tlvh = (struct tlv_header *)((char *)(ext) + TLV_HDR_SIZE
2758 + EXT_TLV_LINK_SIZE);
2759 for (; sum < len; tlvh = TLV_HDR_NEXT(tlvh)) {
2760 struct ext_subtlv_adj_sid *adj;
2761 struct ext_subtlv_lan_adj_sid *ladj;
2762 struct ext_subtlv_rmt_itf_addr *rmt;
2763
2764 switch (ntohs(tlvh->type)) {
2765 case EXT_SUBTLV_ADJ_SID:
2766 adj = (struct ext_subtlv_adj_sid *)tlvh;
2767 label = CHECK_FLAG(adj->flags,
2768 EXT_SUBTLV_LINK_ADJ_SID_VFLG)
2769 ? GET_LABEL(ntohl(adj->value))
2770 : ntohl(adj->value);
2771 i = CHECK_FLAG(adj->flags,
2772 EXT_SUBTLV_LINK_ADJ_SID_BFLG) ? 1 : 0;
2773 if (((i && CHECK_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID))
2774 || (!i && CHECK_FLAG(atr->flags, LS_ATTR_ADJ_SID)))
2775 && atr->adj_sid[i].flags == adj->flags
2776 && atr->adj_sid[i].sid == label
2777 && atr->adj_sid[i].weight == adj->weight)
2778 break;
2779
2780 atr->adj_sid[i].flags = adj->flags;
2781 atr->adj_sid[i].sid = label;
2782 atr->adj_sid[i].weight = adj->weight;
2783 if (i == 0)
2784 SET_FLAG(atr->flags, LS_ATTR_ADJ_SID);
2785 else
2786 SET_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID);
2787 if (edge->status != NEW)
2788 edge->status = UPDATE;
2789
2790 break;
2791 case EXT_SUBTLV_LAN_ADJ_SID:
2792 ladj = (struct ext_subtlv_lan_adj_sid *)tlvh;
2793 label = CHECK_FLAG(ladj->flags,
2794 EXT_SUBTLV_LINK_ADJ_SID_VFLG)
2795 ? GET_LABEL(ntohl(ladj->value))
2796 : ntohl(ladj->value);
2797 i = CHECK_FLAG(ladj->flags,
2798 EXT_SUBTLV_LINK_ADJ_SID_BFLG) ? 1 : 0;
2799 if (((i && CHECK_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID))
2800 || (!i && CHECK_FLAG(atr->flags, LS_ATTR_ADJ_SID)))
2801 && atr->adj_sid[i].flags == ladj->flags
2802 && atr->adj_sid[i].sid == label
2803 && atr->adj_sid[i].weight == ladj->weight
2804 && IPV4_ADDR_SAME(&atr->adj_sid[1].neighbor.addr,
2805 &ladj->neighbor_id))
2806 break;
2807
2808 atr->adj_sid[i].flags = ladj->flags;
2809 atr->adj_sid[i].sid = label;
2810 atr->adj_sid[i].weight = ladj->weight;
2811 atr->adj_sid[i].neighbor.addr = ladj->neighbor_id;
2812 if (i == 0)
2813 SET_FLAG(atr->flags, LS_ATTR_ADJ_SID);
2814 else
2815 SET_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID);
2816 if (edge->status != NEW)
2817 edge->status = UPDATE;
2818
2819 break;
2820 case EXT_SUBTLV_RMT_ITF_ADDR:
2821 rmt = (struct ext_subtlv_rmt_itf_addr *)tlvh;
2822 if (CHECK_FLAG(atr->flags, LS_ATTR_NEIGH_ADDR)
2823 && IPV4_ADDR_SAME(&atr->standard.remote,
2824 &rmt->value))
2825 break;
2826
2827 atr->standard.remote = rmt->value;
2828 SET_FLAG(atr->flags, LS_ATTR_NEIGH_ADDR);
2829 if (edge->status != NEW)
2830 edge->status = UPDATE;
2831
2832 break;
2833 default:
2834 break;
2835 }
2836 sum += TLV_SIZE(tlvh);
2837 }
2838
2839 /* Export Link State Edge if needed */
2840 if (edge->status == NEW || edge->status == UPDATE) {
2841 ote_debug(" |- %s Adj-SID %d & %d to edge %pI4",
2842 edge->status == NEW ? "Add" : "Update",
2843 edge->attributes->adj_sid[0].sid,
2844 edge->attributes->adj_sid[1].sid,
2845 &edge->attributes->standard.local);
2846
2847 ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
2848 edge->status = SYNC;
2849 }
2850
2851 return 0;
2852}
2853
2854/**
2855 * Delete Link State Edge information (Segment Routing Adjacency) that
2856 * correspond to the Opaque Extended Link LSA (Type 8) TLVs. Note that the Edge
2857 * is not removed.
2858 *
2859 * @param ted Link State Traffic Engineering Database
2860 * @param lsa OSPF Link State Advertisement
2861 *
2862 * @return 0 if success, -1 otherwise
2863 */
2864static int ospf_te_delete_ext_link(struct ls_ted *ted, struct ospf_lsa *lsa)
2865{
2866 struct ls_edge *edge;
2867 struct ls_attributes *atr;
2868 struct ext_tlv_link *ext;
dad17a21 2869 struct ls_edge_key key;
f173deb3
OD		 2870
2871 /* Search for corresponding Edge from Link State Data Base */
2872 ext = (struct ext_tlv_link *)TLV_HDR_TOP(lsa->data);
dad17a21
OD		 2873 key.family = AF_INET;
2874 IPV4_ADDR_COPY(&key.k.addr, &ext->link_data);
f173deb3
OD		 2875 edge = ls_find_edge_by_key(ted, key);
2876
2877 /* Check if there is a corresponding Edge */
2878 if (!edge)
2879 return -1;
2880
2881 ote_debug(" |- Delete Adj-SID %d to edge %pI4",
2882 edge->attributes->adj_sid[0].sid,
2883 &edge->attributes->standard.local);
2884
2885 /* Remove Segment Routing information */
2886 atr = edge->attributes;
2887 UNSET_FLAG(atr->flags, LS_ATTR_ADJ_SID);
2888 UNSET_FLAG(atr->flags, LS_ATTR_BCK_ADJ_SID);
2889 memset(atr->adj_sid, 0, 2 * sizeof(struct ls_sid));
2890 edge->status = UPDATE;
2891
2892 /* Edge has been updated: export it */
2893 ospf_te_export(LS_MSG_TYPE_ATTRIBUTES, edge);
2894 edge->status = SYNC;
2895
2896 return 0;
2897}
2898
2899/**
2900 * Parse Opaque LSA Type and call corresponding parser.
2901 *
2902 * @param ted Link State Traffic Engineering Database
2903 * @param lsa OSPF Link State Advertisement
2904 *
2905 * @return 0 if success, -1 otherwise
2906 */
2907static int ospf_te_parse_opaque_lsa(struct ls_ted *ted, struct ospf_lsa *lsa)
2908{
2909 uint8_t key = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
2910 int rc = -1;
2911
2912 ote_debug("MPLS-TE (%s): Parse Opaque LSA[%pI4] from Router[%pI4]",
2913 __func__, &lsa->data->id, &lsa->data->adv_router);
2914
2915 switch (key) {
2916 case OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA:
2917 case OPAQUE_TYPE_INTER_AS_LSA:
2918 rc = ospf_te_parse_te(ted, lsa);
2919 break;
2920 case OPAQUE_TYPE_ROUTER_INFORMATION_LSA:
2921 rc = ospf_te_parse_ri(ted, lsa);
2922 break;
2923 case OPAQUE_TYPE_EXTENDED_PREFIX_LSA:
2924 rc = ospf_te_parse_ext_pref(ted, lsa);
2925 break;
2926 case OPAQUE_TYPE_EXTENDED_LINK_LSA:
2927 rc = ospf_te_parse_ext_link(ted, lsa);
2928 break;
2929 default:
2930 break;
2931 }
2932
2933 return rc;
2934}
2935
2936/**
2937 * Parse Opaque LSA Type and call corresponding deletion function.
2938 *
2939 * @param ted Link State Traffic Engineering Database
2940 * @param lsa OSPF Link State Advertisement
2941 *
2942 * @return 0 if success, -1 otherwise
2943 */
2944static int ospf_te_delete_opaque_lsa(struct ls_ted *ted, struct ospf_lsa *lsa)
2945{
2946 uint8_t key = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
2947 int rc = -1;
2948
2949 ote_debug("MPLS-TE (%s): Parse Opaque LSA[%pI4] from Router[%pI4]",
2950 __func__, &lsa->data->id, &lsa->data->adv_router);
2951
2952 switch (key) {
2953 case OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA:
2954 case OPAQUE_TYPE_INTER_AS_LSA:
2955 rc = ospf_te_delete_te(ted, lsa);
2956 break;
2957 case OPAQUE_TYPE_ROUTER_INFORMATION_LSA:
2958 rc = ospf_te_delete_ri(ted, lsa);
2959 break;
2960 case OPAQUE_TYPE_EXTENDED_PREFIX_LSA:
2961 rc = ospf_te_delete_ext_pref(ted, lsa);
2962 break;
2963 case OPAQUE_TYPE_EXTENDED_LINK_LSA:
2964 rc = ospf_te_delete_ext_link(ted, lsa);
2965 break;
2966 default:
2967 break;
2968 }
2969
2970 return rc;
2971}
2972
2973/**
2974 * Update Traffic Engineering Database Elements that correspond to the received
2975 * OSPF LSA. If LSA age is equal to MAX_AGE, call deletion function instead.
2976 *
2977 * @param lsa OSPF Link State Advertisement
2978 *
2979 * @return 0 if success, -1 otherwise
2980 */
2981static int ospf_mpls_te_lsa_update(struct ospf_lsa *lsa)
2982{
2983
2984 uint8_t rc;
2985
2986 /* Check that MPLS-TE is active */
2987 if (!OspfMplsTE.enabled || !OspfMplsTE.ted)
2988 return 0;
2989
2990 /* Sanity Check */
2991 if (lsa == NULL) {
2992 flog_warn(EC_OSPF_LSA_NULL, "TE (%s): Abort! LSA is NULL",
2993 __func__);
2994 return -1;
2995 }
2996
2997 /* If LSA is MAX_AGE, remove corresponding Link State element */
2998 if (IS_LSA_MAXAGE(lsa)) {
2999 switch (lsa->data->type) {
3000 case OSPF_ROUTER_LSA:
3001 rc = ospf_te_delete_router_lsa(OspfMplsTE.ted, lsa);
3002 break;
3003 case OSPF_OPAQUE_AREA_LSA:
3004 case OSPF_OPAQUE_AS_LSA:
3005 rc = ospf_te_delete_opaque_lsa(OspfMplsTE.ted, lsa);
3006 break;
3007 default:
3008 rc = 0;
3009 break;
3010 }
3011 } else {
3012 /* Parse LSA to Update corresponding Link State element */
3013 switch (lsa->data->type) {
3014 case OSPF_ROUTER_LSA:
3015 rc = ospf_te_parse_router_lsa(OspfMplsTE.ted, lsa);
3016 break;
3017 case OSPF_OPAQUE_AREA_LSA:
3018 case OSPF_OPAQUE_AS_LSA:
3019 rc = ospf_te_parse_opaque_lsa(OspfMplsTE.ted, lsa);
3020 break;
3021 default:
3022 rc = 0;
3023 break;
3024 }
3025 }
3026
3027 return rc;
3028}
3029
3030/**
3031 * Delete Traffic Engineering Database element from OSPF LSA. This function
3032 * process only self LSA (i.e. advertised by the router) which reach MAX_AGE
3033 * as LSA deleted by neighbor routers are Flushed (i.e. advertised with
3034 * age == MAX_AGE) and processed by ospf_mpls_te_lsa_update() function.
3035 *
3036 * @param lsa OSPF Link State Advertisement
3037 *
3038 * @return 0 if success, -1 otherwise
3039 */
3040static int ospf_mpls_te_lsa_delete(struct ospf_lsa *lsa)
3041{
3042
3043 uint8_t rc;
3044
3045 /* Check that MPLS-TE is active */
3046 if (!OspfMplsTE.enabled || !OspfMplsTE.ted)
3047 return 0;
3048
3049 /* Sanity Check */
3050 if (lsa == NULL) {
3051 flog_warn(EC_OSPF_LSA_NULL, "TE (%s): Abort! LSA is NULL",
3052 __func__);
3053 return -1;
3054 }
3055
3056 /*
3057 * Process only self LSAs that reach MAX_AGE. Indeed, when the router
3058 * need to update or refresh an LSA, it first removes the old LSA from
3059 * the LSDB and then insert the new one. Thus, to avoid removing
3060 * corresponding Link State element and loosing some parameters
3061 * instead of just updating it, only self LSAs that reach MAX_AGE are
3062 * processed here. Other LSAs are processed by ospf_mpls_te_lsa_update()
3063 * and eventually removed when LSA age is MAX_AGE i.e. LSA is flushed
3064 * by the originator.
3065 */
3066 if (!IS_LSA_SELF(lsa) || !IS_LSA_MAXAGE(lsa))
3067 return 0;
3068
3069 /* Parse Link State information */
3070 switch (lsa->data->type) {
3071 case OSPF_ROUTER_LSA:
3072 rc = ospf_te_delete_router_lsa(OspfMplsTE.ted, lsa);
3073 break;
3074 case OSPF_OPAQUE_AREA_LSA:
3075 case OSPF_OPAQUE_AS_LSA:
3076 rc = ospf_te_delete_opaque_lsa(OspfMplsTE.ted, lsa);
3077 break;
3078 default:
3079 rc = 0;
3080 break;
3081 }
3082
3083 return rc;
3084}
3085
3086/**
3087 * Send the whole Link State Traffic Engineering Database to the consumer that
3088 * request it through a ZAPI Link State Synchronous Opaque Message.
3089 *
3090 * @param info ZAPI Opaque message
3091 *
3092 * @return 0 if success, -1 otherwise
3093 */
3094int ospf_te_sync_ted(struct zapi_opaque_reg_info dst)
3095{
3096 int rc = -1;
3097
3098 /* Check that MPLS-TE and TE distribution are enabled */
3099 if (!OspfMplsTE.enabled || !OspfMplsTE.export)
3100 return rc;
3101
3102 rc = ls_sync_ted(OspfMplsTE.ted, zclient, &dst);
3103
3104 return rc;
3105}
3106
3107/**
3108 * Initialize Traffic Engineering Database from the various OSPF Link State
3109 * Database (LSDB).
3110 *
3111 * @param ted Link State Traffice Engineering Database
3112 * @param ospf OSPF main structure
3113 */
3114static void ospf_te_init_ted(struct ls_ted *ted, struct ospf *ospf)
3115{
3116 struct listnode *node, *nnode;
3117 struct route_node *rn;
3118 struct ospf_area *area;
3119 struct ospf_lsa *lsa;
3120
3121 /* Iterate over all areas. */
3122 for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area)) {
3123 if (!area->lsdb)
3124 continue;
3125
3126 /* Parse all Router LSAs from the area LSDB */
3127 LSDB_LOOP (ROUTER_LSDB(area), rn, lsa)
3128 ospf_te_parse_router_lsa(ted, lsa);
3129
3130 /* Parse all Opaque LSAs from the area LSDB */
3131 LSDB_LOOP (OPAQUE_AREA_LSDB(area), rn, lsa)
3132 ospf_te_parse_opaque_lsa(ted, lsa);
3133 }
3134
3135 /* Parse AS-external opaque LSAs from OSPF LSDB */
3136 if (ospf->lsdb) {
3137 LSDB_LOOP (OPAQUE_AS_LSDB(ospf), rn, lsa)
3138 ospf_te_parse_opaque_lsa(ted, lsa);
3139 }
3140
3141}
3142
3143/*------------------------------------------------------------------------*
78dfa0c7 3144 * Following are vty session control functions.
f173deb3 3145 *------------------------------------------------------------------------*/
8db278b5
OD		 3146#define check_tlv_size(size, msg) \
3147 do { \
3148 if (ntohs(tlvh->length) > size) { \
3149 if (vty != NULL) \
3150 vty_out(vty, " Wrong %s TLV size: %d(%d)\n", \
3151 msg, ntohs(tlvh->length), size); \
3152 else \
55370b95 3153 zlog_debug(" Wrong %s TLV size: %d(%d)", \
8db278b5
OD		 3154 msg, ntohs(tlvh->length), size); \
3155 return size + TLV_HDR_SIZE; \
3156 } \
55370b95 3157 } while (0)
f173deb3
OD		 3158
3159static uint16_t show_vty_router_addr(struct vty *vty, struct tlv_header *tlvh)
3160{
3161 struct te_tlv_router_addr *top = (struct te_tlv_router_addr *)tlvh;
3162
8db278b5
OD		 3163 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Router Address");
3164
f173deb3
OD		 3165 if (vty != NULL)
3166 vty_out(vty, " Router-Address: %pI4\n", &top->value);
3167 else
3168 zlog_debug(" Router-Address: %pI4", &top->value);
3169
3170 return TLV_SIZE(tlvh);
3171}
3172
8db278b5
OD		 3173static uint16_t show_vty_link_header(struct vty *vty, struct tlv_header *tlvh,
3174 size_t buf_size)
f173deb3
OD		 3175{
3176 struct te_tlv_link *top = (struct te_tlv_link *)tlvh;
3177
8db278b5
OD		 3178 if (TLV_SIZE(tlvh) > buf_size) {
3179 if (vty != NULL)
3180 vty_out(vty,
3181 " TLV size %d exceeds buffer size. Abort!",
3182 TLV_SIZE(tlvh));
3183 else
3184 zlog_debug(
3185 " TLV size %d exceeds buffer size. Abort!",
3186 TLV_SIZE(tlvh));
3187 return buf_size;
3188 }
3189
f173deb3
OD		 3190 if (vty != NULL)
3191 vty_out(vty, " Link: %u octets of data\n",
3192 ntohs(top->header.length));
3193 else
3194 zlog_debug(" Link: %u octets of data",
3195 ntohs(top->header.length));
3196
3197 return TLV_HDR_SIZE; /* Here is special, not "TLV_SIZE". */
3198}
3199
3200static uint16_t show_vty_link_subtlv_link_type(struct vty *vty,
3201 struct tlv_header *tlvh)
3202{
3203 struct te_link_subtlv_link_type *top;
3204 const char *cp = "Unknown";
3205
8db278b5
OD		 3206 check_tlv_size(TE_LINK_SUBTLV_TYPE_SIZE, "Link Type");
3207
f173deb3
OD		 3208 top = (struct te_link_subtlv_link_type *)tlvh;
3209 switch (top->link_type.value) {
3210 case LINK_TYPE_SUBTLV_VALUE_PTP:
3211 cp = "Point-to-point";
3212 break;
3213 case LINK_TYPE_SUBTLV_VALUE_MA:
3214 cp = "Multiaccess";
3215 break;
3216 default:
3217 break;
3218 }
3219
3220 if (vty != NULL)
3221 vty_out(vty, " Link-Type: %s (%u)\n", cp,
3222 top->link_type.value);
3223 else
3224 zlog_debug(" Link-Type: %s (%u)", cp, top->link_type.value);
3225
3226 return TLV_SIZE(tlvh);
3227}
3228
3229static uint16_t show_vty_link_subtlv_link_id(struct vty *vty,
3230 struct tlv_header *tlvh)
3231{
3232 struct te_link_subtlv_link_id *top;
3233
8db278b5
OD		 3234 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Link ID");
3235
f173deb3
OD		 3236 top = (struct te_link_subtlv_link_id *)tlvh;
3237 if (vty != NULL)
3238 vty_out(vty, " Link-ID: %pI4\n", &top->value);
3239 else
3240 zlog_debug(" Link-ID: %pI4", &top->value);
3241
3242 return TLV_SIZE(tlvh);
3243}
3244
3245static uint16_t show_vty_link_subtlv_lclif_ipaddr(struct vty *vty,
8db278b5
OD		 3246 struct tlv_header *tlvh,
3247 size_t buf_size)
f173deb3
OD		 3248{
3249 struct te_link_subtlv_lclif_ipaddr *top;
3250 int i, n;
3251
8db278b5
OD		 3252 if (TLV_SIZE(tlvh) > buf_size) {
3253 if (vty != NULL)
3254 vty_out(vty,
3255 " TLV size %d exceeds buffer size. Abort!",
3256 TLV_SIZE(tlvh));
3257 else
3258 zlog_debug(
3259 " TLV size %d exceeds buffer size. Abort!",
3260 TLV_SIZE(tlvh));
3261 return buf_size;
3262 }
3263
f173deb3
OD		 3264 top = (struct te_link_subtlv_lclif_ipaddr *)tlvh;
3265 n = ntohs(tlvh->length) / sizeof(top->value[0]);
3266
3267 if (vty != NULL)
3268 vty_out(vty, " Local Interface IP Address(es): %d\n", n);
3269 else
3270 zlog_debug(" Local Interface IP Address(es): %d", n);
3271
3272 for (i = 0; i < n; i++) {
3273 if (vty != NULL)
3274 vty_out(vty, " #%d: %pI4\n", i, &top->value[i]);
3275 else
3276 zlog_debug(" #%d: %pI4", i, &top->value[i]);
3277 }
3278 return TLV_SIZE(tlvh);
3279}
3280
3281static uint16_t show_vty_link_subtlv_rmtif_ipaddr(struct vty *vty,
8db278b5
OD		 3282 struct tlv_header *tlvh,
3283 size_t buf_size)
f173deb3
OD		 3284{
3285 struct te_link_subtlv_rmtif_ipaddr *top;
3286 int i, n;
3287
8db278b5
OD		 3288 if (TLV_SIZE(tlvh) > buf_size) {
3289 if (vty != NULL)
3290 vty_out(vty,
3291 " TLV size %d exceeds buffer size. Abort!",
3292 TLV_SIZE(tlvh));
3293 else
3294 zlog_debug(
3295 " TLV size %d exceeds buffer size. Abort!",
3296 TLV_SIZE(tlvh));
3297 return buf_size;
3298 }
3299
f173deb3
OD		 3300 top = (struct te_link_subtlv_rmtif_ipaddr *)tlvh;
3301 n = ntohs(tlvh->length) / sizeof(top->value[0]);
3302 if (vty != NULL)
3303 vty_out(vty, " Remote Interface IP Address(es): %d\n", n);
3304 else
3305 zlog_debug(" Remote Interface IP Address(es): %d", n);
3306
3307 for (i = 0; i < n; i++) {
3308 if (vty != NULL)
3309 vty_out(vty, " #%d: %pI4\n", i, &top->value[i]);
3310 else
3311 zlog_debug(" #%d: %pI4", i, &top->value[i]);
3312 }
3313 return TLV_SIZE(tlvh);
3314}
3315
3316static uint16_t show_vty_link_subtlv_te_metric(struct vty *vty,
3317 struct tlv_header *tlvh)
3318{
3319 struct te_link_subtlv_te_metric *top;
3320
8db278b5
OD		 3321 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "TE Metric");
3322
f173deb3
OD		 3323 top = (struct te_link_subtlv_te_metric *)tlvh;
3324 if (vty != NULL)
3325 vty_out(vty, " Traffic Engineering Metric: %u\n",
3326 (uint32_t)ntohl(top->value));
3327 else
3328 zlog_debug(" Traffic Engineering Metric: %u",
3329 (uint32_t)ntohl(top->value));
3330
3331 return TLV_SIZE(tlvh);
3332}
3333
3334static uint16_t show_vty_link_subtlv_max_bw(struct vty *vty,
3335 struct tlv_header *tlvh)
3336{
3337 struct te_link_subtlv_max_bw *top;
3338 float fval;
3339
8db278b5
OD		 3340 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Maximum Bandwidth");
3341
f173deb3
OD		 3342 top = (struct te_link_subtlv_max_bw *)tlvh;
3343 fval = ntohf(top->value);
3344
3345 if (vty != NULL)
3346 vty_out(vty, " Maximum Bandwidth: %g (Bytes/sec)\n", fval);
3347 else
3348 zlog_debug(" Maximum Bandwidth: %g (Bytes/sec)", fval);
3349
3350 return TLV_SIZE(tlvh);
3351}
3352
3353static uint16_t show_vty_link_subtlv_max_rsv_bw(struct vty *vty,
3354 struct tlv_header *tlvh)
3355{
3356 struct te_link_subtlv_max_rsv_bw *top;
3357 float fval;
3358
8db278b5
OD		 3359 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Maximum Reservable Bandwidth");
3360
f173deb3
OD		 3361 top = (struct te_link_subtlv_max_rsv_bw *)tlvh;
3362 fval = ntohf(top->value);
3363
3364 if (vty != NULL)
3365 vty_out(vty, " Maximum Reservable Bandwidth: %g (Bytes/sec)\n",
3366 fval);
3367 else
3368 zlog_debug(" Maximum Reservable Bandwidth: %g (Bytes/sec)",
3369 fval);
3370
3371 return TLV_SIZE(tlvh);
3372}
3373
3374static uint16_t show_vty_link_subtlv_unrsv_bw(struct vty *vty,
3375 struct tlv_header *tlvh)
3376{
3377 struct te_link_subtlv_unrsv_bw *top;
3378 float fval1, fval2;
3379 int i;
3380
8db278b5
OD		 3381 check_tlv_size(TE_LINK_SUBTLV_UNRSV_SIZE, "Unreserved Bandwidth");
3382
f173deb3
OD		 3383 top = (struct te_link_subtlv_unrsv_bw *)tlvh;
3384 if (vty != NULL)
3385 vty_out(vty,
3386 " Unreserved Bandwidth per Class Type in Byte/s:\n");
3387 else
3388 zlog_debug(
3389 " Unreserved Bandwidth per Class Type in Byte/s:");
3390 for (i = 0; i < MAX_CLASS_TYPE; i += 2) {
3391 fval1 = ntohf(top->value[i]);
3392 fval2 = ntohf(top->value[i + 1]);
3393
3394 if (vty != NULL)
3395 vty_out(vty,
3396 " [%d]: %g (Bytes/sec),\t[%d]: %g (Bytes/sec)\n",
3397 i, fval1, i + 1, fval2);
3398 else
3399 zlog_debug(
3400 " [%d]: %g (Bytes/sec), [%d]: %g (Bytes/sec)",
3401 i, fval1, i + 1, fval2);
3402 }
3403
3404 return TLV_SIZE(tlvh);
3405}
3406
3407static uint16_t show_vty_link_subtlv_rsc_clsclr(struct vty *vty,
3408 struct tlv_header *tlvh)
3409{
3410 struct te_link_subtlv_rsc_clsclr *top;
3411
8db278b5
OD		 3412 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Resource class/color");
3413
f173deb3
OD		 3414 top = (struct te_link_subtlv_rsc_clsclr *)tlvh;
3415 if (vty != NULL)
3416 vty_out(vty, " Resource class/color: 0x%x\n",
3417 (uint32_t)ntohl(top->value));
3418 else
3419 zlog_debug(" Resource Class/Color: 0x%x",
3420 (uint32_t)ntohl(top->value));
3421
3422 return TLV_SIZE(tlvh);
3423}
3424
3425static uint16_t show_vty_link_subtlv_lrrid(struct vty *vty,
3426 struct tlv_header *tlvh)
3427{
3428 struct te_link_subtlv_lrrid *top;
3429
8db278b5
OD		 3430 check_tlv_size(TE_LINK_SUBTLV_LRRID_SIZE, "Local/Remote Router ID");
3431
f173deb3
OD		 3432 top = (struct te_link_subtlv_lrrid *)tlvh;
3433
3434 if (vty != NULL) {
3435 vty_out(vty, " Local TE Router ID: %pI4\n",
3436 &top->local);
3437 vty_out(vty, " Remote TE Router ID: %pI4\n",
3438 &top->remote);
3439 } else {
3440 zlog_debug(" Local TE Router ID: %pI4",
3441 &top->local);
3442 zlog_debug(" Remote TE Router ID: %pI4",
3443 &top->remote);
3444 }
3445
3446 return TLV_SIZE(tlvh);
16f1b9ee
OD		 3447}
3448
d7c0a89a
QY		 3449static uint16_t show_vty_link_subtlv_llri(struct vty *vty,
3450 struct tlv_header *tlvh)
16f1b9ee 3451{
d62a17ae 3452 struct te_link_subtlv_llri *top;
16f1b9ee 3453
8db278b5
OD		 3454 check_tlv_size(TE_LINK_SUBTLV_LLRI_SIZE, "Link Local/Remote ID");
3455
d62a17ae 3456 top = (struct te_link_subtlv_llri *)tlvh;
16f1b9ee 3457
d62a17ae 3458 if (vty != NULL) {
3459 vty_out(vty, " Link Local ID: %d\n",
d7c0a89a 3460 (uint32_t)ntohl(top->local));
d62a17ae 3461 vty_out(vty, " Link Remote ID: %d\n",
d7c0a89a 3462 (uint32_t)ntohl(top->remote));
d62a17ae 3463 } else {
3464 zlog_debug(" Link Local ID: %d",
d7c0a89a 3465 (uint32_t)ntohl(top->local));
d62a17ae 3466 zlog_debug(" Link Remote ID: %d",
d7c0a89a 3467 (uint32_t)ntohl(top->remote));
d62a17ae 3468 }
16f1b9ee 3469
d62a17ae 3470 return TLV_SIZE(tlvh);
16f1b9ee
OD		 3471}
3472
d7c0a89a
QY		 3473static uint16_t show_vty_link_subtlv_rip(struct vty *vty,
3474 struct tlv_header *tlvh)
16f1b9ee 3475{
d62a17ae 3476 struct te_link_subtlv_rip *top;
16f1b9ee 3477
8db278b5
OD		 3478 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Remote ASBR Address");
3479
d62a17ae 3480 top = (struct te_link_subtlv_rip *)tlvh;
16f1b9ee 3481
d62a17ae 3482 if (vty != NULL)
96b663a3
MS		 3483 vty_out(vty, " Inter-AS TE Remote ASBR IP address: %pI4\n",
3484 &top->value);
d62a17ae 3485 else
96b663a3
MS		 3486 zlog_debug(" Inter-AS TE Remote ASBR IP address: %pI4",
3487 &top->value);
16f1b9ee 3488
d62a17ae 3489 return TLV_SIZE(tlvh);
16f1b9ee
OD		 3490}
3491
d7c0a89a
QY		 3492static uint16_t show_vty_link_subtlv_ras(struct vty *vty,
3493 struct tlv_header *tlvh)
16f1b9ee 3494{
d62a17ae 3495 struct te_link_subtlv_ras *top;
16f1b9ee 3496
8db278b5
OD		 3497 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Remote AS number");
3498
d62a17ae 3499 top = (struct te_link_subtlv_ras *)tlvh;
16f1b9ee 3500
d62a17ae 3501 if (vty != NULL)
3502 vty_out(vty, " Inter-AS TE Remote AS number: %u\n",
3503 ntohl(top->value));
3504 else
3505 zlog_debug(" Inter-AS TE Remote AS number: %u",
3506 ntohl(top->value));
16f1b9ee 3507
d62a17ae 3508 return TLV_SIZE(tlvh);
16f1b9ee
OD		 3509}
3510
d7c0a89a
QY		 3511static uint16_t show_vty_link_subtlv_av_delay(struct vty *vty,
3512 struct tlv_header *tlvh)
16f1b9ee 3513{
d62a17ae 3514 struct te_link_subtlv_av_delay *top;
d7c0a89a
QY		 3515 uint32_t delay;
3516 uint32_t anomalous;
16f1b9ee 3517
8db278b5
OD		 3518 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Average Link Delay");
3519
d62a17ae 3520 top = (struct te_link_subtlv_av_delay *)tlvh;
d7c0a89a
QY		 3521 delay = (uint32_t)ntohl(top->value) & TE_EXT_MASK;
3522 anomalous = (uint32_t)ntohl(top->value) & TE_EXT_ANORMAL;
16f1b9ee 3523
d62a17ae 3524 if (vty != NULL)
3525 vty_out(vty, " %s Average Link Delay: %d (micro-sec)\n",
3526 anomalous ? "Anomalous" : "Normal", delay);
3527 else
3528 zlog_debug(" %s Average Link Delay: %d (micro-sec)",
3529 anomalous ? "Anomalous" : "Normal", delay);
16f1b9ee 3530
d62a17ae 3531 return TLV_SIZE(tlvh);
16f1b9ee
OD		 3532}
3533
d7c0a89a
QY		 3534static uint16_t show_vty_link_subtlv_mm_delay(struct vty *vty,
3535 struct tlv_header *tlvh)
16f1b9ee 3536{
d62a17ae 3537 struct te_link_subtlv_mm_delay *top;
d7c0a89a
QY		 3538 uint32_t low, high;
3539 uint32_t anomalous;
16f1b9ee 3540
8db278b5
OD		 3541 check_tlv_size(TE_LINK_SUBTLV_MM_DELAY_SIZE, "Min/Max Link Delay");
3542
d62a17ae 3543 top = (struct te_link_subtlv_mm_delay *)tlvh;
d7c0a89a
QY		 3544 low = (uint32_t)ntohl(top->low) & TE_EXT_MASK;
3545 anomalous = (uint32_t)ntohl(top->low) & TE_EXT_ANORMAL;
3546 high = (uint32_t)ntohl(top->high);
16f1b9ee 3547
d62a17ae 3548 if (vty != NULL)
3549 vty_out(vty, " %s Min/Max Link Delay: %d/%d (micro-sec)\n",
3550 anomalous ? "Anomalous" : "Normal", low, high);
3551 else
3552 zlog_debug(" %s Min/Max Link Delay: %d/%d (micro-sec)",
3553 anomalous ? "Anomalous" : "Normal", low, high);
16f1b9ee 3554
d62a17ae 3555 return TLV_SIZE(tlvh);
16f1b9ee
OD		 3556}
3557
d7c0a89a
QY		 3558static uint16_t show_vty_link_subtlv_delay_var(struct vty *vty,
3559 struct tlv_header *tlvh)
16f1b9ee 3560{
d62a17ae 3561 struct te_link_subtlv_delay_var *top;
d7c0a89a 3562 uint32_t jitter;
16f1b9ee 3563
8db278b5
OD		 3564 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Link Delay Variation");
3565
d62a17ae 3566 top = (struct te_link_subtlv_delay_var *)tlvh;
d7c0a89a 3567 jitter = (uint32_t)ntohl(top->value) & TE_EXT_MASK;
16f1b9ee 3568
d62a17ae 3569 if (vty != NULL)
3570 vty_out(vty, " Delay Variation: %d (micro-sec)\n", jitter);
3571 else
3572 zlog_debug(" Delay Variation: %d (micro-sec)", jitter);
16f1b9ee 3573
d62a17ae 3574 return TLV_SIZE(tlvh);
16f1b9ee
OD		 3575}
3576
d7c0a89a
QY		 3577static uint16_t show_vty_link_subtlv_pkt_loss(struct vty *vty,
3578 struct tlv_header *tlvh)
16f1b9ee 3579{
d62a17ae 3580 struct te_link_subtlv_pkt_loss *top;
d7c0a89a
QY		 3581 uint32_t loss;
3582 uint32_t anomalous;
d62a17ae 3583 float fval;
16f1b9ee 3584
8db278b5
OD		 3585 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Link Loss");
3586
d62a17ae 3587 top = (struct te_link_subtlv_pkt_loss *)tlvh;
d7c0a89a 3588 loss = (uint32_t)ntohl(top->value) & TE_EXT_MASK;
d62a17ae 3589 fval = (float)(loss * LOSS_PRECISION);
d7c0a89a 3590 anomalous = (uint32_t)ntohl(top->value) & TE_EXT_ANORMAL;
16f1b9ee 3591
d62a17ae 3592 if (vty != NULL)
3593 vty_out(vty, " %s Link Loss: %g (%%)\n",
3594 anomalous ? "Anomalous" : "Normal", fval);
3595 else
3596 zlog_debug(" %s Link Loss: %g (%%)",
3597 anomalous ? "Anomalous" : "Normal", fval);
16f1b9ee 3598
d62a17ae 3599 return TLV_SIZE(tlvh);
16f1b9ee
OD		 3600}
3601
d7c0a89a
QY		 3602static uint16_t show_vty_link_subtlv_res_bw(struct vty *vty,
3603 struct tlv_header *tlvh)
16f1b9ee 3604{
d62a17ae 3605 struct te_link_subtlv_res_bw *top;
3606 float fval;
16f1b9ee 3607
8db278b5
OD		 3608 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Residual Bandwidth");
3609
d62a17ae 3610 top = (struct te_link_subtlv_res_bw *)tlvh;
3611 fval = ntohf(top->value);
16f1b9ee 3612
d62a17ae 3613 if (vty != NULL)
3614 vty_out(vty,
3615 " Unidirectional Residual Bandwidth: %g (Bytes/sec)\n",
3616 fval);
3617 else
3618 zlog_debug(
3619 " Unidirectional Residual Bandwidth: %g (Bytes/sec)",
3620 fval);
3621
3622 return TLV_SIZE(tlvh);
3623}
3624
d7c0a89a
QY		 3625static uint16_t show_vty_link_subtlv_ava_bw(struct vty *vty,
3626 struct tlv_header *tlvh)
d62a17ae 3627{
3628 struct te_link_subtlv_ava_bw *top;
3629 float fval;
3630
8db278b5
OD		 3631 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Available Bandwidth");
3632
d62a17ae 3633 top = (struct te_link_subtlv_ava_bw *)tlvh;
3634 fval = ntohf(top->value);
3635
3636 if (vty != NULL)
3637 vty_out(vty,
3638 " Unidirectional Available Bandwidth: %g (Bytes/sec)\n",
3639 fval);
3640 else
3641 zlog_debug(
3642 " Unidirectional Available Bandwidth: %g (Bytes/sec)",
3643 fval);
3644
3645 return TLV_SIZE(tlvh);
3646}
3647
d7c0a89a
QY		 3648static uint16_t show_vty_link_subtlv_use_bw(struct vty *vty,
3649 struct tlv_header *tlvh)
d62a17ae 3650{
3651 struct te_link_subtlv_use_bw *top;
3652 float fval;
3653
8db278b5
OD		 3654 check_tlv_size(TE_LINK_SUBTLV_DEF_SIZE, "Utilized Bandwidth");
3655
d62a17ae 3656 top = (struct te_link_subtlv_use_bw *)tlvh;
3657 fval = ntohf(top->value);
3658
3659 if (vty != NULL)
3660 vty_out(vty,
3661 " Unidirectional Utilized Bandwidth: %g (Bytes/sec)\n",
3662 fval);
3663 else
3664 zlog_debug(
3665 " Unidirectional Utilized Bandwidth: %g (Bytes/sec)",
3666 fval);
3667
3668 return TLV_SIZE(tlvh);
3669}
3670
8db278b5
OD		 3671static uint16_t show_vty_unknown_tlv(struct vty *vty, struct tlv_header *tlvh,
3672 size_t buf_size)
d62a17ae 3673{
8db278b5
OD		 3674 if (TLV_SIZE(tlvh) > buf_size) {
3675 if (vty != NULL)
3676 vty_out(vty,
3677 " TLV size %d exceeds buffer size. Abort!",
3678 TLV_SIZE(tlvh));
3679 else
3680 zlog_debug(
3681 " TLV size %d exceeds buffer size. Abort!",
3682 TLV_SIZE(tlvh));
3683 return buf_size;
3684 }
3685
d62a17ae 3686 if (vty != NULL)
3687 vty_out(vty, " Unknown TLV: [type(0x%x), length(0x%x)]\n",
3688 ntohs(tlvh->type), ntohs(tlvh->length));
3689 else
3690 zlog_debug(" Unknown TLV: [type(0x%x), length(0x%x)]",
3691 ntohs(tlvh->type), ntohs(tlvh->length));
3692
3693 return TLV_SIZE(tlvh);
3694}
3695
d7c0a89a
QY		 3696static uint16_t ospf_mpls_te_show_link_subtlv(struct vty *vty,
3697 struct tlv_header *tlvh0,
3698 uint16_t subtotal, uint16_t total)
d62a17ae 3699{
9df48e81 3700 struct tlv_header *tlvh;
d7c0a89a 3701 uint16_t sum = subtotal;
d62a17ae 3702
8db278b5 3703 for (tlvh = tlvh0; sum < total; tlvh = TLV_HDR_NEXT(tlvh)) {
d62a17ae 3704 switch (ntohs(tlvh->type)) {
3705 case TE_LINK_SUBTLV_LINK_TYPE:
3706 sum += show_vty_link_subtlv_link_type(vty, tlvh);
3707 break;
3708 case TE_LINK_SUBTLV_LINK_ID:
3709 sum += show_vty_link_subtlv_link_id(vty, tlvh);
3710 break;
3711 case TE_LINK_SUBTLV_LCLIF_IPADDR:
8db278b5
OD		 3712 sum += show_vty_link_subtlv_lclif_ipaddr(vty, tlvh,
3713 total - sum);
d62a17ae 3714 break;
3715 case TE_LINK_SUBTLV_RMTIF_IPADDR:
8db278b5
OD		 3716 sum += show_vty_link_subtlv_rmtif_ipaddr(vty, tlvh,
3717 total - sum);
d62a17ae 3718 break;
3719 case TE_LINK_SUBTLV_TE_METRIC:
3720 sum += show_vty_link_subtlv_te_metric(vty, tlvh);
3721 break;
3722 case TE_LINK_SUBTLV_MAX_BW:
3723 sum += show_vty_link_subtlv_max_bw(vty, tlvh);
3724 break;
3725 case TE_LINK_SUBTLV_MAX_RSV_BW:
3726 sum += show_vty_link_subtlv_max_rsv_bw(vty, tlvh);
3727 break;
3728 case TE_LINK_SUBTLV_UNRSV_BW:
3729 sum += show_vty_link_subtlv_unrsv_bw(vty, tlvh);
3730 break;
3731 case TE_LINK_SUBTLV_RSC_CLSCLR:
3732 sum += show_vty_link_subtlv_rsc_clsclr(vty, tlvh);
3733 break;
3734 case TE_LINK_SUBTLV_LRRID:
3735 sum += show_vty_link_subtlv_lrrid(vty, tlvh);
3736 break;
3737 case TE_LINK_SUBTLV_LLRI:
3738 sum += show_vty_link_subtlv_llri(vty, tlvh);
3739 break;
3740 case TE_LINK_SUBTLV_RIP:
3741 sum += show_vty_link_subtlv_rip(vty, tlvh);
3742 break;
3743 case TE_LINK_SUBTLV_RAS:
3744 sum += show_vty_link_subtlv_ras(vty, tlvh);
3745 break;
3746 case TE_LINK_SUBTLV_AV_DELAY:
3747 sum += show_vty_link_subtlv_av_delay(vty, tlvh);
3748 break;
3749 case TE_LINK_SUBTLV_MM_DELAY:
3750 sum += show_vty_link_subtlv_mm_delay(vty, tlvh);
3751 break;
3752 case TE_LINK_SUBTLV_DELAY_VAR:
3753 sum += show_vty_link_subtlv_delay_var(vty, tlvh);
3754 break;
3755 case TE_LINK_SUBTLV_PKT_LOSS:
3756 sum += show_vty_link_subtlv_pkt_loss(vty, tlvh);
3757 break;
3758 case TE_LINK_SUBTLV_RES_BW:
3759 sum += show_vty_link_subtlv_res_bw(vty, tlvh);
3760 break;
3761 case TE_LINK_SUBTLV_AVA_BW:
3762 sum += show_vty_link_subtlv_ava_bw(vty, tlvh);
3763 break;
3764 case TE_LINK_SUBTLV_USE_BW:
3765 sum += show_vty_link_subtlv_use_bw(vty, tlvh);
3766 break;
3767 default:
8db278b5 3768 sum += show_vty_unknown_tlv(vty, tlvh, total - sum);
d62a17ae 3769 break;
3770 }
3771 }
3772 return sum;
3773}
3774
3e63092b
RW		 3775static void ospf_mpls_te_show_info(struct vty *vty, struct json_object *json,
3776 struct ospf_lsa *lsa)
d62a17ae 3777{
c4efd0f4 3778 struct lsa_header *lsah = lsa->data;
ead99d5f 3779 struct tlv_header *tlvh, *next;
d7c0a89a
QY		 3780 uint16_t sum, total;
3781 uint16_t (*subfunc)(struct vty * vty, struct tlv_header * tlvh,
3782 uint16_t subtotal, uint16_t total) = NULL;
d62a17ae 3783
3e63092b
RW		 3784 if (json)
3785 return;
3786
d62a17ae 3787 sum = 0;
8db278b5 3788 total = lsa->size - OSPF_LSA_HEADER_SIZE;
d62a17ae 3789
8db278b5 3790 for (tlvh = TLV_HDR_TOP(lsah); sum < total && tlvh;
d62a17ae 3791 tlvh = (next ? next : TLV_HDR_NEXT(tlvh))) {
3792 if (subfunc != NULL) {
3793 sum = (*subfunc)(vty, tlvh, sum, total);
ead99d5f 3794 next = (struct tlv_header *)((char *)tlvh + sum);
d62a17ae 3795 subfunc = NULL;
3796 continue;
3797 }
3798
3799 next = NULL;
3800 switch (ntohs(tlvh->type)) {
3801 case TE_TLV_ROUTER_ADDR:
3802 sum += show_vty_router_addr(vty, tlvh);
3803 break;
3804 case TE_TLV_LINK:
8db278b5 3805 sum += show_vty_link_header(vty, tlvh, total - sum);
d62a17ae 3806 subfunc = ospf_mpls_te_show_link_subtlv;
5d0df50f 3807 next = TLV_DATA(tlvh);
d62a17ae 3808 break;
3809 default:
8db278b5 3810 sum += show_vty_unknown_tlv(vty, tlvh, total - sum);
d62a17ae 3811 break;
3812 }
3813 }
3814 return;
3815}
3816
3817static void ospf_mpls_te_config_write_router(struct vty *vty)
3818{
3819
32ab5cf4 3820 if (OspfMplsTE.enabled) {
d62a17ae 3821 vty_out(vty, " mpls-te on\n");
96b663a3
MS		 3822 vty_out(vty, " mpls-te router-address %pI4\n",
3823 &OspfMplsTE.router_addr.value);
d62a17ae 3824
f173deb3
OD		 3825 if (OspfMplsTE.inter_as == AS)
3826 vty_out(vty, " mpls-te inter-as as\n");
3827 if (OspfMplsTE.inter_as == Area)
3828 vty_out(vty, " mpls-te inter-as area %pI4 \n",
3829 &OspfMplsTE.interas_areaid);
3830 if (OspfMplsTE.export)
3831 vty_out(vty, " mpls-te export\n");
3832 }
d62a17ae 3833 return;
718e3744 3834}
3835
3836/*------------------------------------------------------------------------*
78dfa0c7 3837 * Following are vty command functions.
718e3744 3838 *------------------------------------------------------------------------*/
3839
16f1b9ee
OD		 3840DEFUN (ospf_mpls_te_on,
3841 ospf_mpls_te_on_cmd,
3842 "mpls-te on",
3843 MPLS_TE_STR
718e3744 3844 "Enable the MPLS-TE functionality\n")
3845{
a3d826f0 3846 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
d62a17ae 3847 struct listnode *node;
3848 struct mpls_te_link *lp;
7c8ff89e 3849
32ab5cf4 3850 if (OspfMplsTE.enabled)
d62a17ae 3851 return CMD_SUCCESS;
718e3744 3852
fd3c7692 3853 ote_debug("MPLS-TE: OFF -> ON");
718e3744 3854
32ab5cf4 3855 OspfMplsTE.enabled = true;
718e3744 3856
d62a17ae 3857 /* Reoriginate RFC3630 & RFC6827 Links */
3858 ospf_mpls_te_foreach_area(ospf_mpls_te_lsa_schedule,
3859 REORIGINATE_THIS_LSA);
718e3744 3860
d62a17ae 3861 /* Reoriginate LSA if INTER-AS is always on */
ead99d5f 3862 if (OspfMplsTE.inter_as != Off) {
d62a17ae 3863 for (ALL_LIST_ELEMENTS_RO(OspfMplsTE.iflist, node, lp)) {
3864 if (IS_INTER_AS(lp->type)) {
3865 ospf_mpls_te_lsa_schedule(lp,
3866 REORIGINATE_THIS_LSA);
3867 }
3868 }
3869 }
718e3744 3870
f173deb3
OD		 3871 /* Create TED and initialize it */
3872 OspfMplsTE.ted = ls_ted_new(1, "OSPF", 0);
3873 if (!OspfMplsTE.ted) {
3874 vty_out(vty, "Unable to create Link State Data Base\n");
3875 return CMD_WARNING;
3876 }
3877 ospf_te_init_ted(OspfMplsTE.ted, ospf);
3878
d62a17ae 3879 return CMD_SUCCESS;
718e3744 3880}
3881
16f1b9ee
OD		 3882DEFUN (no_ospf_mpls_te,
3883 no_ospf_mpls_te_cmd,
3a2d747c 3884 "no mpls-te [on]",
718e3744 3885 NO_STR
3a2d747c 3886 MPLS_TE_STR
718e3744 3887 "Disable the MPLS-TE functionality\n")
3888{
a3d826f0 3889 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
d62a17ae 3890 struct listnode *node, *nnode;
3891 struct mpls_te_link *lp;
718e3744 3892
32ab5cf4 3893 if (!OspfMplsTE.enabled)
d62a17ae 3894 return CMD_SUCCESS;
718e3744 3895
fd3c7692 3896 ote_debug("MPLS-TE: ON -> OFF");
718e3744 3897
f173deb3 3898 /* Remove TED */
aa5ced0a 3899 ls_ted_del_all(&OspfMplsTE.ted);
32ab5cf4 3900 OspfMplsTE.enabled = false;
718e3744 3901
f173deb3 3902 /* Flush all TE Opaque LSAs */
d62a17ae 3903 for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp))
32ab5cf4
OD		 3904 if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED))
3905 ospf_mpls_te_lsa_schedule(lp, FLUSH_THIS_LSA);
718e3744 3906
d424f8d8
CG		 3907 /*
3908 * This resets the OspfMplsTE.inter_as to its initial state.
3909 * This is to avoid having an inter-as value different from
3910 * Off when mpls-te gets restarted (after being removed)
3911 */
2efd7e2b 3912 OspfMplsTE.inter_as = Off;
d424f8d8 3913
d62a17ae 3914 return CMD_SUCCESS;
718e3744 3915}
3916
16f1b9ee
OD		 3917DEFUN (ospf_mpls_te_router_addr,
3918 ospf_mpls_te_router_addr_cmd,
718e3744 3919 "mpls-te router-address A.B.C.D",
16f1b9ee 3920 MPLS_TE_STR
718e3744 3921 "Stable IP address of the advertising router\n"
3922 "MPLS-TE router address in IPv4 address format\n")
3923{
a3d826f0 3924 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
d62a17ae 3925 int idx_ipv4 = 2;
3926 struct te_tlv_router_addr *ra = &OspfMplsTE.router_addr;
3927 struct in_addr value;
3928
3929 if (!inet_aton(argv[idx_ipv4]->arg, &value)) {
3930 vty_out(vty, "Please specify Router-Addr by A.B.C.D\n");
3931 return CMD_WARNING;
3932 }
3933
3934 if (ntohs(ra->header.type) == 0
3935 || ntohl(ra->value.s_addr) != ntohl(value.s_addr)) {
3936 struct listnode *node, *nnode;
3937 struct mpls_te_link *lp;
3938 int need_to_reoriginate = 0;
3939
3940 set_mpls_te_router_addr(value);
3941
32ab5cf4 3942 if (!OspfMplsTE.enabled)
ead99d5f 3943 return CMD_SUCCESS;
d62a17ae 3944
3945 for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp)) {
2efd7e2b 3946 if ((lp->area == NULL) || IS_FLOOD_AS(lp->flags))
d62a17ae 3947 continue;
3948
3949 if (!CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED)) {
3950 need_to_reoriginate = 1;
3951 break;
3952 }
3953 }
3954
3955 for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp)) {
2efd7e2b 3956 if ((lp->area == NULL) || IS_FLOOD_AS(lp->flags))
d62a17ae 3957 continue;
3958
3959 if (need_to_reoriginate)
3960 SET_FLAG(lp->flags, LPFLG_LSA_FORCED_REFRESH);
3961 else
3962 ospf_mpls_te_lsa_schedule(lp, REFRESH_THIS_LSA);
3963 }
3964
3965 if (need_to_reoriginate)
3966 ospf_mpls_te_foreach_area(ospf_mpls_te_lsa_schedule,
3967 REORIGINATE_THIS_LSA);
3968 }
ead99d5f 3969
d62a17ae 3970 return CMD_SUCCESS;
3971}
3972
3973static int set_inter_as_mode(struct vty *vty, const char *mode_name,
3974 const char *area_id)
3975{
3976 enum inter_as_mode mode;
3977 struct listnode *node;
3978 struct mpls_te_link *lp;
3979 int format;
3980
32ab5cf4 3981 if (OspfMplsTE.enabled) {
d62a17ae 3982
3983 /* Read and Check inter_as mode */
3984 if (strcmp(mode_name, "as") == 0)
3985 mode = AS;
3986 else if (strcmp(mode_name, "area") == 0) {
3987 mode = Area;
3988 VTY_GET_OSPF_AREA_ID(OspfMplsTE.interas_areaid, format,
3989 area_id);
3990 } else {
3991 vty_out(vty,
3992 "Unknown mode. Please choose between as or area\n");
3993 return CMD_WARNING;
3994 }
3995
fd3c7692
OD		 3996 ote_debug(
3997 "MPLS-TE (%s): Inter-AS enable with %s flooding support",
3998 __func__, mode2text[mode]);
d62a17ae 3999
d62a17ae 4000 /* Enable mode and re-originate LSA if needed */
ead99d5f 4001 if ((OspfMplsTE.inter_as == Off)
d62a17ae 4002 && (mode != OspfMplsTE.inter_as)) {
4003 OspfMplsTE.inter_as = mode;
4004 /* Re-originate all InterAS-TEv2 LSA */
4005 for (ALL_LIST_ELEMENTS_RO(OspfMplsTE.iflist, node,
4006 lp)) {
4007 if (IS_INTER_AS(lp->type)) {
4008 if (mode == AS)
2efd7e2b
OD		 4009 SET_FLAG(lp->flags,
4010 LPFLG_LSA_FLOOD_AS);
d62a17ae 4011 else
2efd7e2b
OD		 4012 UNSET_FLAG(lp->flags,
4013 LPFLG_LSA_FLOOD_AS);
d62a17ae 4014 ospf_mpls_te_lsa_schedule(
4015 lp, REORIGINATE_THIS_LSA);
4016 }
4017 }
4018 } else {
4019 vty_out(vty,
4020 "Please change Inter-AS support to disable first before going to mode %s\n",
4021 mode2text[mode]);
4022 return CMD_WARNING;
4023 }
4024 } else {
4025 vty_out(vty, "mpls-te has not been turned on\n");
4026 return CMD_WARNING;
4027 }
4028 return CMD_SUCCESS;
718e3744 4029}
4030
718e3744 4031
16f1b9ee
OD		 4032DEFUN (ospf_mpls_te_inter_as_as,
4033 ospf_mpls_te_inter_as_cmd,
4034 "mpls-te inter-as as",
4035 MPLS_TE_STR
4036 "Configure MPLS-TE Inter-AS support\n"
4037 "AS native mode self originate INTER_AS LSA with Type 11 (as flooding scope)\n")
4038{
d62a17ae 4039 return set_inter_as_mode(vty, "as", "");
718e3744 4040}
4041
16f1b9ee
OD		 4042DEFUN (ospf_mpls_te_inter_as_area,
4043 ospf_mpls_te_inter_as_area_cmd,
6147e2c6 4044 "mpls-te inter-as area <A.B.C.D|(0-4294967295)>",
16f1b9ee
OD		 4045 MPLS_TE_STR
4046 "Configure MPLS-TE Inter-AS support\n"
4047 "AREA native mode self originate INTER_AS LSA with Type 10 (area flooding scope)\n"
4048 "OSPF area ID in IP format\n"
4049 "OSPF area ID as decimal value\n")
718e3744 4050{
d62a17ae 4051 int idx_ipv4_number = 3;
4052 return set_inter_as_mode(vty, "area", argv[idx_ipv4_number]->arg);
718e3744 4053}
4054
16f1b9ee
OD		 4055DEFUN (no_ospf_mpls_te_inter_as,
4056 no_ospf_mpls_te_inter_as_cmd,
4057 "no mpls-te inter-as",
4058 NO_STR
4059 MPLS_TE_STR
4060 "Disable MPLS-TE Inter-AS support\n")
718e3744 4061{
16f1b9ee 4062
d62a17ae 4063 struct listnode *node, *nnode;
4064 struct mpls_te_link *lp;
718e3744 4065
fd3c7692 4066 ote_debug("MPLS-TE: Inter-AS support OFF");
718e3744 4067
996c9314 4068 if ((OspfMplsTE.enabled) && (OspfMplsTE.inter_as != Off)) {
d62a17ae 4069 /* Flush all Inter-AS LSA */
4070 for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp))
4071 if (IS_INTER_AS(lp->type)
4072 && CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED))
4073 ospf_mpls_te_lsa_schedule(lp, FLUSH_THIS_LSA);
718e3744 4074
e790de41
DT		 4075 OspfMplsTE.inter_as = Off;
4076 }
bcf4475e 4077
d62a17ae 4078 return CMD_SUCCESS;
718e3744 4079}
4080
f173deb3
OD		 4081DEFUN (ospf_mpls_te_export,
4082 ospf_mpls_te_export_cmd,
4083 "mpls-te export",
4084 MPLS_TE_STR
4085 "Export the MPLS-TE information as Link State\n")
4086{
4087
4088 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
4089
4090 if (OspfMplsTE.enabled) {
4091 if (ls_register(zclient, true) != 0) {
4092 vty_out(vty, "Unable to register Link State\n");
4093 return CMD_WARNING;
4094 }
4095 OspfMplsTE.export = true;
4096 } else {
4097 vty_out(vty, "mpls-te has not been turned on\n");
4098 return CMD_WARNING;
4099 }
4100 return CMD_SUCCESS;
4101}
4102
4103
4104DEFUN (no_ospf_mpls_te_export,
4105 no_ospf_mpls_te_export_cmd,
4106 "no mpls-te export",
4107 NO_STR
4108 MPLS_TE_STR
4109 "Stop export of the MPLS-TE information as Link State\n")
4110{
4111
4112 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
4113
4114 if (OspfMplsTE.export) {
4115 if (ls_unregister(zclient, true) != 0) {
4116 vty_out(vty, "Unable to unregister Link State\n");
4117 return CMD_WARNING;
4118 }
4119 OspfMplsTE.export = false;
4120 }
4121 return CMD_SUCCESS;
4122}
4123
16f1b9ee
OD		 4124DEFUN (show_ip_ospf_mpls_te_router,
4125 show_ip_ospf_mpls_te_router_cmd,
4126 "show ip ospf mpls-te router",
718e3744 4127 SHOW_STR
16f1b9ee
OD		 4128 IP_STR
4129 OSPF_STR
718e3744 4130 "MPLS-TE information\n"
16f1b9ee 4131 "MPLS-TE Router parameters\n")
718e3744 4132{
32ab5cf4 4133 if (OspfMplsTE.enabled) {
d62a17ae 4134 vty_out(vty, "--- MPLS-TE router parameters ---\n");
4135
4136 if (ntohs(OspfMplsTE.router_addr.header.type) != 0)
4137 show_vty_router_addr(vty,
4138 &OspfMplsTE.router_addr.header);
0af35d90 4139 else
f173deb3
OD		 4140 vty_out(vty, " Router address is not set\n");
4141 vty_out(vty, " Link State distribution is %s\n",
4142 OspfMplsTE.export ? "Active" : "Inactive");
d62a17ae 4143 }
4144 return CMD_SUCCESS;
4145}
4146
4147static void show_mpls_te_link_sub(struct vty *vty, struct interface *ifp)
4148{
4149 struct mpls_te_link *lp;
4150
996c9314
LB		 4151 if ((OspfMplsTE.enabled) && HAS_LINK_PARAMS(ifp) && !if_is_loopback(ifp)
4152 && if_is_up(ifp)
d62a17ae 4153 && ((lp = lookup_linkparams_by_ifp(ifp)) != NULL)) {
4154 /* Continue only if interface is not passive or support Inter-AS
4155 * TEv2 */
4156 if (!(ospf_oi_count(ifp) > 0)) {
4157 if (IS_INTER_AS(lp->type)) {
4158 vty_out(vty,
4159 "-- Inter-AS TEv2 link parameters for %s --\n",
4160 ifp->name);
4161 } else {
4162 /* MPLS-TE is not activate on this interface */
4163 /* or this interface is passive and Inter-AS
4164 * TEv2 is not activate */
4165 vty_out(vty,
4166 " %s: MPLS-TE is disabled on this interface\n",
4167 ifp->name);
4168 return;
4169 }
4170 } else {
4171 vty_out(vty, "-- MPLS-TE link parameters for %s --\n",
4172 ifp->name);
4173 }
4174
4175 if (TLV_TYPE(lp->link_type) != 0)
4176 show_vty_link_subtlv_link_type(vty,
4177 &lp->link_type.header);
4178 if (TLV_TYPE(lp->link_id) != 0)
4179 show_vty_link_subtlv_link_id(vty, &lp->link_id.header);
4180 if (TLV_TYPE(lp->lclif_ipaddr) != 0)
4181 show_vty_link_subtlv_lclif_ipaddr(
8db278b5
OD		 4182 vty, &lp->lclif_ipaddr.header,
4183 lp->lclif_ipaddr.header.length);
d62a17ae 4184 if (TLV_TYPE(lp->rmtif_ipaddr) != 0)
4185 show_vty_link_subtlv_rmtif_ipaddr(
8db278b5
OD		 4186 vty, &lp->rmtif_ipaddr.header,
4187 lp->rmtif_ipaddr.header.length);
d62a17ae 4188 if (TLV_TYPE(lp->rip) != 0)
4189 show_vty_link_subtlv_rip(vty, &lp->rip.header);
4190 if (TLV_TYPE(lp->ras) != 0)
4191 show_vty_link_subtlv_ras(vty, &lp->ras.header);
4192 if (TLV_TYPE(lp->te_metric) != 0)
4193 show_vty_link_subtlv_te_metric(vty,
4194 &lp->te_metric.header);
4195 if (TLV_TYPE(lp->max_bw) != 0)
4196 show_vty_link_subtlv_max_bw(vty, &lp->max_bw.header);
4197 if (TLV_TYPE(lp->max_rsv_bw) != 0)
4198 show_vty_link_subtlv_max_rsv_bw(vty,
4199 &lp->max_rsv_bw.header);
4200 if (TLV_TYPE(lp->unrsv_bw) != 0)
4201 show_vty_link_subtlv_unrsv_bw(vty,
4202 &lp->unrsv_bw.header);
4203 if (TLV_TYPE(lp->rsc_clsclr) != 0)
4204 show_vty_link_subtlv_rsc_clsclr(vty,
4205 &lp->rsc_clsclr.header);
4206 if (TLV_TYPE(lp->av_delay) != 0)
4207 show_vty_link_subtlv_av_delay(vty,
4208 &lp->av_delay.header);
4209 if (TLV_TYPE(lp->mm_delay) != 0)
4210 show_vty_link_subtlv_mm_delay(vty,
4211 &lp->mm_delay.header);
4212 if (TLV_TYPE(lp->delay_var) != 0)
4213 show_vty_link_subtlv_delay_var(vty,
4214 &lp->delay_var.header);
4215 if (TLV_TYPE(lp->pkt_loss) != 0)
4216 show_vty_link_subtlv_pkt_loss(vty,
4217 &lp->pkt_loss.header);
4218 if (TLV_TYPE(lp->res_bw) != 0)
4219 show_vty_link_subtlv_res_bw(vty, &lp->res_bw.header);
4220 if (TLV_TYPE(lp->ava_bw) != 0)
4221 show_vty_link_subtlv_ava_bw(vty, &lp->ava_bw.header);
4222 if (TLV_TYPE(lp->use_bw) != 0)
4223 show_vty_link_subtlv_use_bw(vty, &lp->use_bw.header);
4224 vty_out(vty, "---------------\n\n");
4225 } else {
4226 vty_out(vty, " %s: MPLS-TE is disabled on this interface\n",
4227 ifp->name);
4228 }
4229
4230 return;
718e3744 4231}
4232
16f1b9ee
OD		 4233DEFUN (show_ip_ospf_mpls_te_link,
4234 show_ip_ospf_mpls_te_link_cmd,
b5a8894d 4235 "show ip ospf [vrf <NAME|all>] mpls-te interface [INTERFACE]",
718e3744 4236 SHOW_STR
16f1b9ee
OD		 4237 IP_STR
4238 OSPF_STR
b5a8894d
CS		 4239 VRF_CMD_HELP_STR
4240 "All VRFs\n"
718e3744 4241 "MPLS-TE information\n"
4242 "Interface information\n"
4243 "Interface name\n")
4244{
f4e14fdb 4245 struct vrf *vrf;
03ed9f02
PG		 4246 int idx_interface = 0;
4247 struct interface *ifp = NULL;
f4e14fdb 4248 struct listnode *node;
b5a8894d 4249 char *vrf_name = NULL;
8da59e56 4250 bool all_vrf = false;
b5a8894d
CS		 4251 int inst = 0;
4252 int idx_vrf = 0;
4253 struct ospf *ospf = NULL;
4254
4255 if (argv_find(argv, argc, "vrf", &idx_vrf)) {
4256 vrf_name = argv[idx_vrf + 1]->arg;
4257 all_vrf = strmatch(vrf_name, "all");
4258 }
03ed9f02 4259 argv_find(argv, argc, "INTERFACE", &idx_interface);
b5a8894d
CS		 4260 /* vrf input is provided could be all or specific vrf*/
4261 if (vrf_name) {
4262 if (all_vrf) {
f4e14fdb 4263 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
b5a8894d
CS		 4264 if (!ospf->oi_running)
4265 continue;
f4e14fdb 4266 vrf = vrf_lookup_by_id(ospf->vrf_id);
451fda4f 4267 FOR_ALL_INTERFACES (vrf, ifp)
b5a8894d
CS		 4268 show_mpls_te_link_sub(vty, ifp);
4269 }
4270 return CMD_SUCCESS;
4271 }
996c9314 4272 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
03ed9f02
PG		 4273 } else
4274 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
4275 if (ospf == NULL || !ospf->oi_running)
b5a8894d 4276 return CMD_SUCCESS;
03ed9f02
PG		 4277
4278 vrf = vrf_lookup_by_id(ospf->vrf_id);
4279 if (!vrf)
4280 return CMD_SUCCESS;
4281 if (idx_interface) {
4282 ifp = if_lookup_by_name(
4283 argv[idx_interface]->arg,
a36898e7 4284 ospf->vrf_id);
03ed9f02
PG		 4285 if (ifp == NULL) {
4286 vty_out(vty, "No such interface name in vrf %s\n",
4287 vrf->name);
4288 return CMD_SUCCESS;
43b8d1d8 4289 }
d62a17ae 4290 }
03ed9f02
PG		 4291 if (!ifp) {
4292 FOR_ALL_INTERFACES (vrf, ifp)
d62a17ae 4293 show_mpls_te_link_sub(vty, ifp);
03ed9f02 4294 return CMD_SUCCESS;
d62a17ae 4295 }
4296
03ed9f02 4297 show_mpls_te_link_sub(vty, ifp);
d62a17ae 4298 return CMD_SUCCESS;
4299}
4300
f173deb3
OD		 4301DEFUN (show_ip_ospf_mpls_te_db,
4302 show_ip_ospf_mpls_te_db_cmd,
4303 "show ip ospf mpls-te database [<vertex [<self-originate|adv-router A.B.C.D>]|edge [A.B.C.D]|subnet [A.B.C.D/M]>] [verbose|json]",
4304 SHOW_STR
4305 IP_STR
4306 OSPF_STR
4307 "MPLS-TE information\n"
4308 "MPLS-TE database\n"
4309 "MPLS-TE Vertex\n"
4310 "Self-originated MPLS-TE router\n"
4311 "Advertised MPLS-TE router\n"
4312 "MPLS-TE router ID (as an IP address)\n"
4313 "MPLS-TE Edge\n"
4314 "MPLS-TE Edge ID (as an IP address)\n"
4315 "MPLS-TE Subnet\n"
4316 "MPLS-TE Subnet ID (as an IP prefix)\n"
4317 "Verbose output\n"
4318 JSON_STR)
4319{
4320 int idx = 0;
4321 struct in_addr ip_addr;
4322 struct prefix pref;
4323 struct ls_vertex *vertex;
4324 struct ls_edge *edge;
4325 struct ls_subnet *subnet;
4326 uint64_t key;
dad17a21 4327 struct ls_edge_key ekey;
f173deb3
OD		 4328 bool verbose = false;
4329 bool uj = use_json(argc, argv);
4330 json_object *json = NULL;
4331
4332 if (!OspfMplsTE.enabled || !OspfMplsTE.ted) {
4333 vty_out(vty, "MPLS-TE database is not enabled\n");
4334 return CMD_WARNING;
4335 }
4336
4337 if (uj)
4338 json = json_object_new_object();
4339
4340 if (argv[argc - 1]->arg && strmatch(argv[argc - 1]->text, "verbose"))
4341 verbose = true;
4342
4343 idx = 5;
4344 if (argv_find(argv, argc, "vertex", &idx)) {
4345 /* Show Vertex */
4346 if (argv_find(argv, argc, "self-originate", &idx))
4347 vertex = OspfMplsTE.ted->self;
4348 else if (argv_find(argv, argc, "adv-router", &idx)) {
4349 if (!inet_aton(argv[idx + 1]->arg, &ip_addr)) {
4350 vty_out(vty,
4351 "Specified Router ID %s is invalid\n",
4352 argv[idx + 1]->arg);
4353 return CMD_WARNING_CONFIG_FAILED;
4354 }
4355 /* Get the Vertex from the Link State Database */
4356 key = ((uint64_t)ntohl(ip_addr.s_addr)) & 0xffffffff;
4357 vertex = ls_find_vertex_by_key(OspfMplsTE.ted, key);
4358 if (!vertex) {
4359 vty_out(vty, "No vertex found for ID %pI4\n",
4360 &ip_addr);
4361 return CMD_WARNING;
4362 }
4363 } else
4364 vertex = NULL;
4365
4366 if (vertex)
4367 ls_show_vertex(vertex, vty, json, verbose);
4368 else
4369 ls_show_vertices(OspfMplsTE.ted, vty, json, verbose);
4370
4371 } else if (argv_find(argv, argc, "edge", &idx)) {
4372 /* Show Edge */
4373 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
4374 if (!inet_aton(argv[idx]->arg, &ip_addr)) {
4375 vty_out(vty,
4376 "Specified Edge ID %s is invalid\n",
4377 argv[idx]->arg);
4378 return CMD_WARNING_CONFIG_FAILED;
4379 }
4380 /* Get the Edge from the Link State Database */
dad17a21
OD		 4381 ekey.family = AF_INET;
4382 IPV4_ADDR_COPY(&ekey.k.addr, &ip_addr);
4383 edge = ls_find_edge_by_key(OspfMplsTE.ted, ekey);
f173deb3
OD		 4384 if (!edge) {
4385 vty_out(vty, "No edge found for ID %pI4\n",
4386 &ip_addr);
4387 return CMD_WARNING;
4388 }
4389 } else
4390 edge = NULL;
4391
4392 if (edge)
4393 ls_show_edge(edge, vty, json, verbose);
4394 else
4395 ls_show_edges(OspfMplsTE.ted, vty, json, verbose);
4396
4397 } else if (argv_find(argv, argc, "subnet", &idx)) {
4398 /* Show Subnet */
4399 if (argv_find(argv, argc, "A.B.C.D/M", &idx)) {
4400 if (!str2prefix(argv[idx]->arg, &pref)) {
4401 vty_out(vty, "Invalid prefix format %s\n",
4402 argv[idx]->arg);
4403 return CMD_WARNING_CONFIG_FAILED;
4404 }
4405 /* Get the Subnet from the Link State Database */
4406 subnet = ls_find_subnet(OspfMplsTE.ted, pref);
4407 if (!subnet) {
4408 vty_out(vty, "No subnet found for ID %pFX\n",
4409 &pref);
4410 return CMD_WARNING;
4411 }
4412 } else
4413 subnet = NULL;
4414
4415 if (subnet)
4416 ls_show_subnet(subnet, vty, json, verbose);
4417 else
4418 ls_show_subnets(OspfMplsTE.ted, vty, json, verbose);
4419
4420 } else {
4421 /* Show the complete TED */
4422 ls_show_ted(OspfMplsTE.ted, vty, json, verbose);
4423 }
4424
c48349e3 4425 if (uj)
92ef0078 4426 vty_json(vty, json);
f173deb3
OD		 4427 return CMD_SUCCESS;
4428}
4429
d62a17ae 4430static void ospf_mpls_te_register_vty(void)
4431{
4432 install_element(VIEW_NODE, &show_ip_ospf_mpls_te_router_cmd);
4433 install_element(VIEW_NODE, &show_ip_ospf_mpls_te_link_cmd);
f173deb3 4434 install_element(VIEW_NODE, &show_ip_ospf_mpls_te_db_cmd);
d62a17ae 4435
4436 install_element(OSPF_NODE, &ospf_mpls_te_on_cmd);
4437 install_element(OSPF_NODE, &no_ospf_mpls_te_cmd);
4438 install_element(OSPF_NODE, &ospf_mpls_te_router_addr_cmd);
4439 install_element(OSPF_NODE, &ospf_mpls_te_inter_as_cmd);
4440 install_element(OSPF_NODE, &ospf_mpls_te_inter_as_area_cmd);
4441 install_element(OSPF_NODE, &no_ospf_mpls_te_inter_as_cmd);
f173deb3
OD		 4442 install_element(OSPF_NODE, &ospf_mpls_te_export_cmd);
4443 install_element(OSPF_NODE, &no_ospf_mpls_te_export_cmd);
d62a17ae 4444
4445 return;
718e3744 4446}
FRRouting mirror