Annotation of embedaddon/quagga/ospfd/ospf_te.c, revision 1.1
1.1 ! misho 1: /*
! 2: * This is an implementation of draft-katz-yeung-ospf-traffic-06.txt
! 3: * Copyright (C) 2001 KDD R&D Laboratories, Inc.
! 4: * http://www.kddlabs.co.jp/
! 5: *
! 6: * This file is part of GNU Zebra.
! 7: *
! 8: * GNU Zebra is free software; you can redistribute it and/or modify it
! 9: * under the terms of the GNU General Public License as published by the
! 10: * Free Software Foundation; either version 2, or (at your option) any
! 11: * later version.
! 12: *
! 13: * GNU Zebra is distributed in the hope that it will be useful, but
! 14: * WITHOUT ANY WARRANTY; without even the implied warranty of
! 15: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 16: * General Public License for more details.
! 17: *
! 18: * You should have received a copy of the GNU General Public License
! 19: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 20: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 21: * 02111-1307, USA.
! 22: */
! 23:
! 24: /***** MTYPE definition is not reflected to "memory.h" yet. *****/
! 25: #define MTYPE_OSPF_MPLS_TE_LINKPARAMS 0
! 26:
! 27: #include <zebra.h>
! 28:
! 29: #ifdef HAVE_OSPF_TE
! 30: #ifndef HAVE_OPAQUE_LSA
! 31: #error "Wrong configure option"
! 32: #endif /* HAVE_OPAQUE_LSA */
! 33:
! 34: #include "linklist.h"
! 35: #include "prefix.h"
! 36: #include "if.h"
! 37: #include "table.h"
! 38: #include "memory.h"
! 39: #include "command.h"
! 40: #include "vty.h"
! 41: #include "stream.h"
! 42: #include "log.h"
! 43: #include "thread.h"
! 44: #include "hash.h"
! 45: #include "sockunion.h" /* for inet_aton() */
! 46:
! 47: #include "ospfd/ospfd.h"
! 48: #include "ospfd/ospf_interface.h"
! 49: #include "ospfd/ospf_ism.h"
! 50: #include "ospfd/ospf_asbr.h"
! 51: #include "ospfd/ospf_lsa.h"
! 52: #include "ospfd/ospf_lsdb.h"
! 53: #include "ospfd/ospf_neighbor.h"
! 54: #include "ospfd/ospf_nsm.h"
! 55: #include "ospfd/ospf_flood.h"
! 56: #include "ospfd/ospf_packet.h"
! 57: #include "ospfd/ospf_spf.h"
! 58: #include "ospfd/ospf_dump.h"
! 59: #include "ospfd/ospf_route.h"
! 60: #include "ospfd/ospf_ase.h"
! 61: #include "ospfd/ospf_zebra.h"
! 62: #include "ospfd/ospf_te.h"
! 63:
! 64: /* Following structure are internal use only. */
! 65: struct ospf_mpls_te
! 66: {
! 67: enum { disabled, enabled } status;
! 68:
! 69: /* List elements are zebra-interfaces (ifp), not ospf-interfaces (oi). */
! 70: struct list *iflist;
! 71:
! 72: /* Store Router-TLV in network byte order. */
! 73: struct te_tlv_router_addr router_addr;
! 74: };
! 75:
! 76: struct mpls_te_link
! 77: {
! 78: /*
! 79: * According to MPLS-TE (draft) specification, 24-bit Opaque-ID field
! 80: * is subdivided into 8-bit "unused" field and 16-bit "instance" field.
! 81: * In this implementation, each Link-TLV has its own instance.
! 82: */
! 83: u_int32_t instance;
! 84:
! 85: /* Reference pointer to a Zebra-interface. */
! 86: struct interface *ifp;
! 87:
! 88: /* Area info in which this MPLS-TE link belongs to. */
! 89: struct ospf_area *area;
! 90:
! 91: /* Flags to manage this link parameters. */
! 92: u_int32_t flags;
! 93: #define LPFLG_LOOKUP_DONE 0x1
! 94: #define LPFLG_LSA_ENGAGED 0x2
! 95: #define LPFLG_LSA_FORCED_REFRESH 0x4
! 96:
! 97: /* Store Link-TLV in network byte order. */
! 98: struct te_tlv_link link_header;
! 99: struct te_link_subtlv_link_type link_type;
! 100: struct te_link_subtlv_link_id link_id;
! 101: struct te_link_subtlv_lclif_ipaddr *lclif_ipaddr;
! 102: struct te_link_subtlv_rmtif_ipaddr *rmtif_ipaddr;
! 103: struct te_link_subtlv_te_metric te_metric;
! 104: struct te_link_subtlv_max_bw max_bw;
! 105: struct te_link_subtlv_max_rsv_bw max_rsv_bw;
! 106: struct te_link_subtlv_unrsv_bw unrsv_bw;
! 107: struct te_link_subtlv_rsc_clsclr rsc_clsclr;
! 108: };
! 109:
! 110: /*
! 111: * Global variable to manage Opaque-LSA/MPLS-TE on this node.
! 112: * Note that all parameter values are stored in network byte order.
! 113: */
! 114: static struct ospf_mpls_te OspfMplsTE;
! 115:
! 116: enum oifstate {
! 117: OI_ANY, OI_DOWN, OI_UP
! 118: };
! 119:
! 120: enum sched_opcode {
! 121: REORIGINATE_PER_AREA, REFRESH_THIS_LSA, FLUSH_THIS_LSA
! 122: };
! 123:
! 124: /*------------------------------------------------------------------------*
! 125: * Followings are initialize/terminate functions for MPLS-TE handling.
! 126: *------------------------------------------------------------------------*/
! 127:
! 128: static int ospf_mpls_te_new_if (struct interface *ifp);
! 129: static int ospf_mpls_te_del_if (struct interface *ifp);
! 130: static void ospf_mpls_te_ism_change (struct ospf_interface *oi, int old_status);
! 131: static void ospf_mpls_te_nsm_change (struct ospf_neighbor *nbr, int old_status);
! 132: static void ospf_mpls_te_config_write_router (struct vty *vty);
! 133: static void ospf_mpls_te_config_write_if (struct vty *vty, struct interface *ifp);
! 134: static void ospf_mpls_te_show_info (struct vty *vty, struct ospf_lsa *lsa);
! 135: static int ospf_mpls_te_lsa_originate (void *arg);
! 136: static struct ospf_lsa *ospf_mpls_te_lsa_refresh (struct ospf_lsa *lsa);
! 137: static void ospf_mpls_te_lsa_schedule (struct mpls_te_link *lp, enum sched_opcode);
! 138:
! 139: static void del_mpls_te_link (void *val);
! 140: static void ospf_mpls_te_register_vty (void);
! 141:
! 142: int
! 143: ospf_mpls_te_init (void)
! 144: {
! 145: int rc;
! 146:
! 147: rc = ospf_register_opaque_functab (
! 148: OSPF_OPAQUE_AREA_LSA,
! 149: OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA,
! 150: ospf_mpls_te_new_if,
! 151: ospf_mpls_te_del_if,
! 152: ospf_mpls_te_ism_change,
! 153: ospf_mpls_te_nsm_change,
! 154: ospf_mpls_te_config_write_router,
! 155: ospf_mpls_te_config_write_if,
! 156: NULL,/* ospf_mpls_te_config_write_debug */
! 157: ospf_mpls_te_show_info,
! 158: ospf_mpls_te_lsa_originate,
! 159: ospf_mpls_te_lsa_refresh,
! 160: NULL,/* ospf_mpls_te_new_lsa_hook */
! 161: NULL /* ospf_mpls_te_del_lsa_hook */);
! 162: if (rc != 0)
! 163: {
! 164: zlog_warn ("ospf_mpls_te_init: Failed to register functions");
! 165: goto out;
! 166: }
! 167:
! 168: memset (&OspfMplsTE, 0, sizeof (struct ospf_mpls_te));
! 169: OspfMplsTE.status = disabled;
! 170: OspfMplsTE.iflist = list_new ();
! 171: OspfMplsTE.iflist->del = del_mpls_te_link;
! 172:
! 173: ospf_mpls_te_register_vty ();
! 174:
! 175: out:
! 176: return rc;
! 177: }
! 178:
! 179: void
! 180: ospf_mpls_te_term (void)
! 181: {
! 182: list_delete (OspfMplsTE.iflist);
! 183:
! 184: OspfMplsTE.iflist = NULL;
! 185: OspfMplsTE.status = disabled;
! 186:
! 187: ospf_delete_opaque_functab (OSPF_OPAQUE_AREA_LSA,
! 188: OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA);
! 189: return;
! 190: }
! 191:
! 192: /*------------------------------------------------------------------------*
! 193: * Followings are control functions for MPLS-TE parameters management.
! 194: *------------------------------------------------------------------------*/
! 195:
! 196: static void
! 197: del_mpls_te_link (void *val)
! 198: {
! 199: XFREE (MTYPE_OSPF_MPLS_TE_LINKPARAMS, val);
! 200: return;
! 201: }
! 202:
! 203: static u_int32_t
! 204: get_mpls_te_instance_value (void)
! 205: {
! 206: static u_int32_t seqno = 0;
! 207:
! 208: if (LEGAL_TE_INSTANCE_RANGE (seqno + 1))
! 209: seqno += 1;
! 210: else
! 211: seqno = 1; /* Avoid zero. */
! 212:
! 213: return seqno;
! 214: }
! 215:
! 216: static struct ospf_interface *
! 217: lookup_oi_by_ifp (struct interface *ifp,
! 218: struct ospf_area *area, enum oifstate oifstate)
! 219: {
! 220: struct ospf_interface *oi = NULL;
! 221: struct route_node *rn;
! 222:
! 223: for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
! 224: {
! 225: if ((oi = rn->info) == NULL)
! 226: continue;
! 227:
! 228: switch (oifstate)
! 229: {
! 230: case OI_ANY:
! 231: break;
! 232: case OI_DOWN:
! 233: if (ospf_if_is_enable (oi))
! 234: continue;
! 235: break;
! 236: case OI_UP:
! 237: if (! ospf_if_is_enable (oi))
! 238: continue;
! 239: break;
! 240: default:
! 241: zlog_warn ("lookup_oi_by_ifp: Unknown oifstate: %x", oifstate);
! 242: goto out;
! 243: }
! 244:
! 245: if (area == NULL || oi->area == area)
! 246: return oi;
! 247: }
! 248: out:
! 249: return NULL;
! 250: }
! 251:
! 252: static struct mpls_te_link *
! 253: lookup_linkparams_by_ifp (struct interface *ifp)
! 254: {
! 255: struct listnode *node, *nnode;
! 256: struct mpls_te_link *lp;
! 257:
! 258: for (ALL_LIST_ELEMENTS (OspfMplsTE.iflist, node, nnode, lp))
! 259: if (lp->ifp == ifp)
! 260: return lp;
! 261:
! 262: return NULL;
! 263: }
! 264:
! 265: static struct mpls_te_link *
! 266: lookup_linkparams_by_instance (struct ospf_lsa *lsa)
! 267: {
! 268: struct listnode *node;
! 269: struct mpls_te_link *lp;
! 270: unsigned int key = GET_OPAQUE_ID (ntohl (lsa->data->id.s_addr));
! 271:
! 272: for (ALL_LIST_ELEMENTS_RO (OspfMplsTE.iflist, node, lp))
! 273: if (lp->instance == key)
! 274: return lp;
! 275:
! 276: zlog_warn ("lookup_linkparams_by_instance: Entry not found: key(%x)", key);
! 277: return NULL;
! 278: }
! 279:
! 280: static void
! 281: ospf_mpls_te_foreach_area (
! 282: void (*func)(struct mpls_te_link *lp, enum sched_opcode),
! 283: enum sched_opcode sched_opcode)
! 284: {
! 285: struct listnode *node, *nnode;
! 286: struct listnode *node2;
! 287: struct mpls_te_link *lp;
! 288: struct ospf_area *area;
! 289:
! 290: for (ALL_LIST_ELEMENTS (OspfMplsTE.iflist, node, nnode, lp))
! 291: {
! 292: if ((area = lp->area) == NULL)
! 293: continue;
! 294: if (lp->flags & LPFLG_LOOKUP_DONE)
! 295: continue;
! 296:
! 297: if (func != NULL)
! 298: (* func)(lp, sched_opcode);
! 299:
! 300: for (node2 = listnextnode (node); node2; node2 = listnextnode (node2))
! 301: if ((lp = listgetdata (node2)) != NULL)
! 302: if (lp->area != NULL)
! 303: if (IPV4_ADDR_SAME (&lp->area->area_id, &area->area_id))
! 304: lp->flags |= LPFLG_LOOKUP_DONE;
! 305: }
! 306:
! 307: for (ALL_LIST_ELEMENTS_RO (OspfMplsTE.iflist, node, lp))
! 308: if (lp->area != NULL)
! 309: lp->flags &= ~LPFLG_LOOKUP_DONE;
! 310:
! 311: return;
! 312: }
! 313:
! 314: static void
! 315: set_mpls_te_router_addr (struct in_addr ipv4)
! 316: {
! 317: OspfMplsTE.router_addr.header.type = htons (TE_TLV_ROUTER_ADDR);
! 318: OspfMplsTE.router_addr.header.length = htons (sizeof (ipv4));
! 319: OspfMplsTE.router_addr.value = ipv4;
! 320: return;
! 321: }
! 322:
! 323: static void
! 324: set_linkparams_link_header (struct mpls_te_link *lp)
! 325: {
! 326: struct te_tlv_header *tlvh;
! 327: u_int16_t length = 0;
! 328:
! 329: /* TE_LINK_SUBTLV_LINK_TYPE */
! 330: if (ntohs (lp->link_type.header.type) != 0)
! 331: length += TLV_SIZE (&lp->link_type.header);
! 332:
! 333: /* TE_LINK_SUBTLV_LINK_ID */
! 334: if (ntohs (lp->link_id.header.type) != 0)
! 335: length += TLV_SIZE (&lp->link_id.header);
! 336:
! 337: /* TE_LINK_SUBTLV_LCLIF_IPADDR */
! 338: if ((tlvh = (struct te_tlv_header *) lp->lclif_ipaddr) != NULL
! 339: && ntohs (tlvh->type) != 0)
! 340: length += TLV_SIZE (tlvh);
! 341:
! 342: /* TE_LINK_SUBTLV_RMTIF_IPADDR */
! 343: if ((tlvh = (struct te_tlv_header *) lp->rmtif_ipaddr) != NULL
! 344: && ntohs (tlvh->type) != 0)
! 345: length += TLV_SIZE (tlvh);
! 346:
! 347: /* TE_LINK_SUBTLV_TE_METRIC */
! 348: if (ntohs (lp->te_metric.header.type) != 0)
! 349: length += TLV_SIZE (&lp->te_metric.header);
! 350:
! 351: /* TE_LINK_SUBTLV_MAX_BW */
! 352: if (ntohs (lp->max_bw.header.type) != 0)
! 353: length += TLV_SIZE (&lp->max_bw.header);
! 354:
! 355: /* TE_LINK_SUBTLV_MAX_RSV_BW */
! 356: if (ntohs (lp->max_rsv_bw.header.type) != 0)
! 357: length += TLV_SIZE (&lp->max_rsv_bw.header);
! 358:
! 359: /* TE_LINK_SUBTLV_UNRSV_BW */
! 360: if (ntohs (lp->unrsv_bw.header.type) != 0)
! 361: length += TLV_SIZE (&lp->unrsv_bw.header);
! 362:
! 363: /* TE_LINK_SUBTLV_RSC_CLSCLR */
! 364: if (ntohs (lp->rsc_clsclr.header.type) != 0)
! 365: length += TLV_SIZE (&lp->rsc_clsclr.header);
! 366:
! 367: lp->link_header.header.type = htons (TE_TLV_LINK);
! 368: lp->link_header.header.length = htons (length);
! 369:
! 370: return;
! 371: }
! 372:
! 373: static void
! 374: set_linkparams_link_type (struct ospf_interface *oi, struct mpls_te_link *lp)
! 375: {
! 376: lp->link_type.header.type = htons (TE_LINK_SUBTLV_LINK_TYPE);
! 377: lp->link_type.header.length = htons (sizeof (lp->link_type.link_type.value));
! 378:
! 379: switch (oi->type)
! 380: {
! 381: case OSPF_IFTYPE_POINTOPOINT:
! 382: lp->link_type.link_type.value = LINK_TYPE_SUBTLV_VALUE_PTP;
! 383: break;
! 384: case OSPF_IFTYPE_BROADCAST:
! 385: case OSPF_IFTYPE_NBMA:
! 386: lp->link_type.link_type.value = LINK_TYPE_SUBTLV_VALUE_MA;
! 387: break;
! 388: default:
! 389: /* Not supported yet. *//* XXX */
! 390: lp->link_type.header.type = htons (0);
! 391: break;
! 392: }
! 393: return;
! 394: }
! 395:
! 396: static void
! 397: set_linkparams_link_id (struct ospf_interface *oi, struct mpls_te_link *lp)
! 398: {
! 399: struct ospf_neighbor *nbr;
! 400: int done = 0;
! 401:
! 402: lp->link_id.header.type = htons (TE_LINK_SUBTLV_LINK_ID);
! 403: lp->link_id.header.length = htons (sizeof (lp->link_id.value));
! 404:
! 405: /*
! 406: * The Link ID is identical to the contents of the Link ID field
! 407: * in the Router LSA for these link types.
! 408: */
! 409: switch (oi->type)
! 410: {
! 411: case OSPF_IFTYPE_POINTOPOINT:
! 412: /* Take the router ID of the neighbor. */
! 413: if ((nbr = ospf_nbr_lookup_ptop (oi))
! 414: && nbr->state == NSM_Full)
! 415: {
! 416: lp->link_id.value = nbr->router_id;
! 417: done = 1;
! 418: }
! 419: break;
! 420: case OSPF_IFTYPE_BROADCAST:
! 421: case OSPF_IFTYPE_NBMA:
! 422: /* Take the interface address of the designated router. */
! 423: if ((nbr = ospf_nbr_lookup_by_addr (oi->nbrs, &DR (oi))) == NULL)
! 424: break;
! 425:
! 426: if (nbr->state == NSM_Full
! 427: || (IPV4_ADDR_SAME (&oi->address->u.prefix4, &DR (oi))
! 428: && ospf_nbr_count (oi, NSM_Full) > 0))
! 429: {
! 430: lp->link_id.value = DR (oi);
! 431: done = 1;
! 432: }
! 433: break;
! 434: default:
! 435: /* Not supported yet. *//* XXX */
! 436: lp->link_id.header.type = htons (0);
! 437: break;
! 438: }
! 439:
! 440: if (! done)
! 441: {
! 442: struct in_addr mask;
! 443: masklen2ip (oi->address->prefixlen, &mask);
! 444: lp->link_id.value.s_addr = oi->address->u.prefix4.s_addr & mask.s_addr;
! 445: }
! 446: return;
! 447: }
! 448:
! 449: static void
! 450: set_linkparams_te_metric (struct mpls_te_link *lp, u_int32_t te_metric)
! 451: {
! 452: lp->te_metric.header.type = htons (TE_LINK_SUBTLV_TE_METRIC);
! 453: lp->te_metric.header.length = htons (sizeof (lp->te_metric.value));
! 454: lp->te_metric.value = htonl (te_metric);
! 455: return;
! 456: }
! 457:
! 458: static void
! 459: set_linkparams_max_bw (struct mpls_te_link *lp, float *fp)
! 460: {
! 461: lp->max_bw.header.type = htons (TE_LINK_SUBTLV_MAX_BW);
! 462: lp->max_bw.header.length = htons (sizeof (lp->max_bw.value));
! 463: htonf (fp, &lp->max_bw.value);
! 464: return;
! 465: }
! 466:
! 467: static void
! 468: set_linkparams_max_rsv_bw (struct mpls_te_link *lp, float *fp)
! 469: {
! 470: lp->max_rsv_bw.header.type = htons (TE_LINK_SUBTLV_MAX_RSV_BW);
! 471: lp->max_rsv_bw.header.length = htons (sizeof (lp->max_rsv_bw.value));
! 472: htonf (fp, &lp->max_rsv_bw.value);
! 473: return;
! 474: }
! 475:
! 476: static void
! 477: set_linkparams_unrsv_bw (struct mpls_te_link *lp, int priority, float *fp)
! 478: {
! 479: /* Note that TLV-length field is the size of array. */
! 480: lp->unrsv_bw.header.type = htons (TE_LINK_SUBTLV_UNRSV_BW);
! 481: lp->unrsv_bw.header.length = htons (sizeof (lp->unrsv_bw.value));
! 482: htonf (fp, &lp->unrsv_bw.value [priority]);
! 483: return;
! 484: }
! 485:
! 486: static void
! 487: set_linkparams_rsc_clsclr (struct mpls_te_link *lp, u_int32_t classcolor)
! 488: {
! 489: lp->rsc_clsclr.header.type = htons (TE_LINK_SUBTLV_RSC_CLSCLR);
! 490: lp->rsc_clsclr.header.length = htons (sizeof (lp->rsc_clsclr.value));
! 491: lp->rsc_clsclr.value = htonl (classcolor);
! 492: return;
! 493: }
! 494:
! 495: static void
! 496: initialize_linkparams (struct mpls_te_link *lp)
! 497: {
! 498: struct interface *ifp = lp->ifp;
! 499: struct ospf_interface *oi;
! 500: float fval;
! 501: int i;
! 502:
! 503: if ((oi = lookup_oi_by_ifp (ifp, NULL, OI_ANY)) == NULL)
! 504: return;
! 505:
! 506: /*
! 507: * Try to set initial values those can be derived from
! 508: * zebra-interface information.
! 509: */
! 510: set_linkparams_link_type (oi, lp);
! 511:
! 512: /*
! 513: * Linux and *BSD kernel holds bandwidth parameter as an "int" type.
! 514: * We may have to reconsider, if "ifp->bandwidth" type changes to float.
! 515: */
! 516: fval = (float)((ifp->bandwidth ? ifp->bandwidth
! 517: : OSPF_DEFAULT_BANDWIDTH) * 1000 / 8);
! 518:
! 519: set_linkparams_max_bw (lp, &fval);
! 520: set_linkparams_max_rsv_bw (lp, &fval);
! 521:
! 522: for (i = 0; i < 8; i++)
! 523: set_linkparams_unrsv_bw (lp, i, &fval);
! 524:
! 525: return;
! 526: }
! 527:
! 528: static int
! 529: is_mandated_params_set (struct mpls_te_link *lp)
! 530: {
! 531: int rc = 0;
! 532:
! 533: if (ntohs (OspfMplsTE.router_addr.header.type) == 0)
! 534: goto out;
! 535:
! 536: if (ntohs (lp->link_type.header.type) == 0)
! 537: goto out;
! 538:
! 539: if (ntohs (lp->link_id.header.type) == 0)
! 540: goto out;
! 541:
! 542: rc = 1;
! 543: out:
! 544: return rc;
! 545: }
! 546:
! 547: /*------------------------------------------------------------------------*
! 548: * Followings are callback functions against generic Opaque-LSAs handling.
! 549: *------------------------------------------------------------------------*/
! 550:
! 551: static int
! 552: ospf_mpls_te_new_if (struct interface *ifp)
! 553: {
! 554: struct mpls_te_link *new;
! 555: int rc = -1;
! 556:
! 557: if (lookup_linkparams_by_ifp (ifp) != NULL)
! 558: {
! 559: zlog_warn ("ospf_mpls_te_new_if: ifp(%p) already in use?", ifp);
! 560: rc = 0; /* Do nothing here. */
! 561: goto out;
! 562: }
! 563:
! 564: new = XCALLOC (MTYPE_OSPF_MPLS_TE_LINKPARAMS,
! 565: sizeof (struct mpls_te_link));
! 566: if (new == NULL)
! 567: {
! 568: zlog_warn ("ospf_mpls_te_new_if: XMALLOC: %s", safe_strerror (errno));
! 569: goto out;
! 570: }
! 571:
! 572: new->area = NULL;
! 573: new->flags = 0;
! 574: new->instance = get_mpls_te_instance_value ();
! 575: new->ifp = ifp;
! 576:
! 577: initialize_linkparams (new);
! 578:
! 579: listnode_add (OspfMplsTE.iflist, new);
! 580:
! 581: /* Schedule Opaque-LSA refresh. *//* XXX */
! 582:
! 583: rc = 0;
! 584: out:
! 585: return rc;
! 586: }
! 587:
! 588: static int
! 589: ospf_mpls_te_del_if (struct interface *ifp)
! 590: {
! 591: struct mpls_te_link *lp;
! 592: int rc = -1;
! 593:
! 594: if ((lp = lookup_linkparams_by_ifp (ifp)) != NULL)
! 595: {
! 596: struct list *iflist = OspfMplsTE.iflist;
! 597:
! 598: /* Dequeue listnode entry from the list. */
! 599: listnode_delete (iflist, lp);
! 600:
! 601: /* Avoid misjudgement in the next lookup. */
! 602: if (listcount (iflist) == 0)
! 603: iflist->head = iflist->tail = NULL;
! 604:
! 605: XFREE (MTYPE_OSPF_MPLS_TE_LINKPARAMS, lp);
! 606: }
! 607:
! 608: /* Schedule Opaque-LSA refresh. *//* XXX */
! 609:
! 610: rc = 0;
! 611: /*out:*/
! 612: return rc;
! 613: }
! 614:
! 615: static void
! 616: ospf_mpls_te_ism_change (struct ospf_interface *oi, int old_state)
! 617: {
! 618: struct te_link_subtlv_link_type old_type;
! 619: struct te_link_subtlv_link_id old_id;
! 620: struct mpls_te_link *lp;
! 621:
! 622: if ((lp = lookup_linkparams_by_ifp (oi->ifp)) == NULL)
! 623: {
! 624: zlog_warn ("ospf_mpls_te_ism_change: Cannot get linkparams from OI(%s)?", IF_NAME (oi));
! 625: goto out;
! 626: }
! 627: if (oi->area == NULL || oi->area->ospf == NULL)
! 628: {
! 629: zlog_warn ("ospf_mpls_te_ism_change: Cannot refer to OSPF from OI(%s)?",
! 630: IF_NAME (oi));
! 631: goto out;
! 632: }
! 633: #ifdef notyet
! 634: if ((lp->area != NULL
! 635: && ! IPV4_ADDR_SAME (&lp->area->area_id, &oi->area->area_id))
! 636: || (lp->area != NULL && oi->area == NULL))
! 637: {
! 638: /* How should we consider this case? */
! 639: zlog_warn ("MPLS-TE: Area for OI(%s) has changed to [%s], flush previous LSAs", IF_NAME (oi), oi->area ? inet_ntoa (oi->area->area_id) : "N/A");
! 640: ospf_mpls_te_lsa_schedule (lp, FLUSH_THIS_LSA);
! 641: }
! 642: #endif
! 643: /* Keep Area information in conbination with linkparams. */
! 644: lp->area = oi->area;
! 645:
! 646: switch (oi->state)
! 647: {
! 648: case ISM_PointToPoint:
! 649: case ISM_DROther:
! 650: case ISM_Backup:
! 651: case ISM_DR:
! 652: old_type = lp->link_type;
! 653: old_id = lp->link_id;
! 654:
! 655: set_linkparams_link_type (oi, lp);
! 656: set_linkparams_link_id (oi, lp);
! 657:
! 658: if ((ntohs (old_type.header.type) != ntohs (lp->link_type.header.type)
! 659: || old_type.link_type.value != lp->link_type.link_type.value)
! 660: || (ntohs (old_id.header.type) != ntohs (lp->link_id.header.type)
! 661: || ntohl (old_id.value.s_addr) != ntohl (lp->link_id.value.s_addr)))
! 662: {
! 663: if (lp->flags & LPFLG_LSA_ENGAGED)
! 664: ospf_mpls_te_lsa_schedule (lp, REFRESH_THIS_LSA);
! 665: else
! 666: ospf_mpls_te_lsa_schedule (lp, REORIGINATE_PER_AREA);
! 667: }
! 668: break;
! 669: default:
! 670: lp->link_type.header.type = htons (0);
! 671: lp->link_id.header.type = htons (0);
! 672:
! 673: if (lp->flags & LPFLG_LSA_ENGAGED)
! 674: ospf_mpls_te_lsa_schedule (lp, FLUSH_THIS_LSA);
! 675: break;
! 676: }
! 677:
! 678: out:
! 679: return;
! 680: }
! 681:
! 682: static void
! 683: ospf_mpls_te_nsm_change (struct ospf_neighbor *nbr, int old_state)
! 684: {
! 685: /* So far, nothing to do here. */
! 686: return;
! 687: }
! 688:
! 689: /*------------------------------------------------------------------------*
! 690: * Followings are OSPF protocol processing functions for MPLS-TE.
! 691: *------------------------------------------------------------------------*/
! 692:
! 693: static void
! 694: build_tlv_header (struct stream *s, struct te_tlv_header *tlvh)
! 695: {
! 696: stream_put (s, tlvh, sizeof (struct te_tlv_header));
! 697: return;
! 698: }
! 699:
! 700: static void
! 701: build_router_tlv (struct stream *s)
! 702: {
! 703: struct te_tlv_header *tlvh = &OspfMplsTE.router_addr.header;
! 704: if (ntohs (tlvh->type) != 0)
! 705: {
! 706: build_tlv_header (s, tlvh);
! 707: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 708: }
! 709: return;
! 710: }
! 711:
! 712: static void
! 713: build_link_subtlv_link_type (struct stream *s, struct mpls_te_link *lp)
! 714: {
! 715: struct te_tlv_header *tlvh = &lp->link_type.header;
! 716: if (ntohs (tlvh->type) != 0)
! 717: {
! 718: build_tlv_header (s, tlvh);
! 719: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 720: }
! 721: return;
! 722: }
! 723:
! 724: static void
! 725: build_link_subtlv_link_id (struct stream *s, struct mpls_te_link *lp)
! 726: {
! 727: struct te_tlv_header *tlvh = &lp->link_id.header;
! 728: if (ntohs (tlvh->type) != 0)
! 729: {
! 730: build_tlv_header (s, tlvh);
! 731: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 732: }
! 733: return;
! 734: }
! 735:
! 736: static void
! 737: build_link_subtlv_lclif_ipaddr (struct stream *s, struct mpls_te_link *lp)
! 738: {
! 739: struct te_tlv_header *tlvh = (struct te_tlv_header *) lp->lclif_ipaddr;
! 740: if (tlvh != NULL && ntohs (tlvh->type) != 0)
! 741: {
! 742: build_tlv_header (s, tlvh);
! 743: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 744: }
! 745: return;
! 746: }
! 747:
! 748: static void
! 749: build_link_subtlv_rmtif_ipaddr (struct stream *s, struct mpls_te_link *lp)
! 750: {
! 751: struct te_tlv_header *tlvh = (struct te_tlv_header *) lp->rmtif_ipaddr;
! 752: if (tlvh != NULL && ntohs (tlvh->type) != 0)
! 753: {
! 754: build_tlv_header (s, tlvh);
! 755: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 756: }
! 757: return;
! 758: }
! 759:
! 760: static void
! 761: build_link_subtlv_te_metric (struct stream *s, struct mpls_te_link *lp)
! 762: {
! 763: struct te_tlv_header *tlvh = &lp->te_metric.header;
! 764: if (ntohs (tlvh->type) != 0)
! 765: {
! 766: build_tlv_header (s, tlvh);
! 767: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 768: }
! 769: return;
! 770: }
! 771:
! 772: static void
! 773: build_link_subtlv_max_bw (struct stream *s, struct mpls_te_link *lp)
! 774: {
! 775: struct te_tlv_header *tlvh = &lp->max_bw.header;
! 776: if (ntohs (tlvh->type) != 0)
! 777: {
! 778: build_tlv_header (s, tlvh);
! 779: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 780: }
! 781: return;
! 782: }
! 783:
! 784: static void
! 785: build_link_subtlv_max_rsv_bw (struct stream *s, struct mpls_te_link *lp)
! 786: {
! 787: struct te_tlv_header *tlvh = &lp->max_rsv_bw.header;
! 788: if (ntohs (tlvh->type) != 0)
! 789: {
! 790: build_tlv_header (s, tlvh);
! 791: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 792: }
! 793: return;
! 794: }
! 795:
! 796: static void
! 797: build_link_subtlv_unrsv_bw (struct stream *s, struct mpls_te_link *lp)
! 798: {
! 799: struct te_tlv_header *tlvh = &lp->unrsv_bw.header;
! 800: if (ntohs (tlvh->type) != 0)
! 801: {
! 802: build_tlv_header (s, tlvh);
! 803: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 804: }
! 805: return;
! 806: }
! 807:
! 808: static void
! 809: build_link_subtlv_rsc_clsclr (struct stream *s, struct mpls_te_link *lp)
! 810: {
! 811: struct te_tlv_header *tlvh = &lp->rsc_clsclr.header;
! 812: if (ntohs (tlvh->type) != 0)
! 813: {
! 814: build_tlv_header (s, tlvh);
! 815: stream_put (s, tlvh+1, TLV_BODY_SIZE (tlvh));
! 816: }
! 817: return;
! 818: }
! 819:
! 820: static void
! 821: build_link_tlv (struct stream *s, struct mpls_te_link *lp)
! 822: {
! 823: set_linkparams_link_header (lp);
! 824: build_tlv_header (s, &lp->link_header.header);
! 825:
! 826: build_link_subtlv_link_type (s, lp);
! 827: build_link_subtlv_link_id (s, lp);
! 828: build_link_subtlv_lclif_ipaddr (s, lp);
! 829: build_link_subtlv_rmtif_ipaddr (s, lp);
! 830: build_link_subtlv_te_metric (s, lp);
! 831: build_link_subtlv_max_bw (s, lp);
! 832: build_link_subtlv_max_rsv_bw (s, lp);
! 833: build_link_subtlv_unrsv_bw (s, lp);
! 834: build_link_subtlv_rsc_clsclr (s, lp);
! 835: return;
! 836: }
! 837:
! 838: static void
! 839: ospf_mpls_te_lsa_body_set (struct stream *s, struct mpls_te_link *lp)
! 840: {
! 841: /*
! 842: * The router address TLV is type 1, and ...
! 843: * It must appear in exactly one
! 844: * Traffic Engineering LSA originated by a router.
! 845: */
! 846: build_router_tlv (s);
! 847:
! 848: /*
! 849: * Only one Link TLV shall be carried in each LSA, allowing for fine
! 850: * granularity changes in topology.
! 851: */
! 852: build_link_tlv (s, lp);
! 853: return;
! 854: }
! 855:
! 856: /* Create new opaque-LSA. */
! 857: static struct ospf_lsa *
! 858: ospf_mpls_te_lsa_new (struct ospf_area *area, struct mpls_te_link *lp)
! 859: {
! 860: struct stream *s;
! 861: struct lsa_header *lsah;
! 862: struct ospf_lsa *new = NULL;
! 863: u_char options, lsa_type;
! 864: struct in_addr lsa_id;
! 865: u_int32_t tmp;
! 866: u_int16_t length;
! 867:
! 868: /* Create a stream for LSA. */
! 869: if ((s = stream_new (OSPF_MAX_LSA_SIZE)) == NULL)
! 870: {
! 871: zlog_warn ("ospf_mpls_te_lsa_new: stream_new() ?");
! 872: goto out;
! 873: }
! 874: lsah = (struct lsa_header *) STREAM_DATA (s);
! 875:
! 876: options = LSA_OPTIONS_GET (area);
! 877: options |= LSA_OPTIONS_NSSA_GET (area);
! 878: options |= OSPF_OPTION_O; /* Don't forget this :-) */
! 879:
! 880: lsa_type = OSPF_OPAQUE_AREA_LSA;
! 881: tmp = SET_OPAQUE_LSID (OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA, lp->instance);
! 882: lsa_id.s_addr = htonl (tmp);
! 883:
! 884: if (IS_DEBUG_OSPF (lsa, LSA_GENERATE))
! 885: zlog_debug ("LSA[Type%d:%s]: Create an Opaque-LSA/MPLS-TE instance", lsa_type, inet_ntoa (lsa_id));
! 886:
! 887: /* Set opaque-LSA header fields. */
! 888: lsa_header_set (s, options, lsa_type, lsa_id, area->ospf->router_id);
! 889:
! 890: /* Set opaque-LSA body fields. */
! 891: ospf_mpls_te_lsa_body_set (s, lp);
! 892:
! 893: /* Set length. */
! 894: length = stream_get_endp (s);
! 895: lsah->length = htons (length);
! 896:
! 897: /* Now, create an OSPF LSA instance. */
! 898: if ((new = ospf_lsa_new ()) == NULL)
! 899: {
! 900: zlog_warn ("ospf_mpls_te_lsa_new: ospf_lsa_new() ?");
! 901: stream_free (s);
! 902: goto out;
! 903: }
! 904: if ((new->data = ospf_lsa_data_new (length)) == NULL)
! 905: {
! 906: zlog_warn ("ospf_mpls_te_lsa_new: ospf_lsa_data_new() ?");
! 907: ospf_lsa_unlock (&new);
! 908: new = NULL;
! 909: stream_free (s);
! 910: goto out;
! 911: }
! 912:
! 913: new->area = area;
! 914: SET_FLAG (new->flags, OSPF_LSA_SELF);
! 915: memcpy (new->data, lsah, length);
! 916: stream_free (s);
! 917:
! 918: out:
! 919: return new;
! 920: }
! 921:
! 922: static int
! 923: ospf_mpls_te_lsa_originate1 (struct ospf_area *area, struct mpls_te_link *lp)
! 924: {
! 925: struct ospf_lsa *new;
! 926: int rc = -1;
! 927:
! 928: /* Create new Opaque-LSA/MPLS-TE instance. */
! 929: if ((new = ospf_mpls_te_lsa_new (area, lp)) == NULL)
! 930: {
! 931: zlog_warn ("ospf_mpls_te_lsa_originate1: ospf_mpls_te_lsa_new() ?");
! 932: goto out;
! 933: }
! 934:
! 935: /* Install this LSA into LSDB. */
! 936: if (ospf_lsa_install (area->ospf, NULL/*oi*/, new) == NULL)
! 937: {
! 938: zlog_warn ("ospf_mpls_te_lsa_originate1: ospf_lsa_install() ?");
! 939: ospf_lsa_unlock (&new);
! 940: goto out;
! 941: }
! 942:
! 943: /* Now this linkparameter entry has associated LSA. */
! 944: lp->flags |= LPFLG_LSA_ENGAGED;
! 945:
! 946: /* Update new LSA origination count. */
! 947: area->ospf->lsa_originate_count++;
! 948:
! 949: /* Flood new LSA through area. */
! 950: ospf_flood_through_area (area, NULL/*nbr*/, new);
! 951:
! 952: if (IS_DEBUG_OSPF (lsa, LSA_GENERATE))
! 953: {
! 954: char area_id[INET_ADDRSTRLEN];
! 955: strcpy (area_id, inet_ntoa (area->area_id));
! 956: zlog_debug ("LSA[Type%d:%s]: Originate Opaque-LSA/MPLS-TE: Area(%s), Link(%s)", new->data->type, inet_ntoa (new->data->id), area_id, lp->ifp->name);
! 957: ospf_lsa_header_dump (new->data);
! 958: }
! 959:
! 960: rc = 0;
! 961: out:
! 962: return rc;
! 963: }
! 964:
! 965: static int
! 966: ospf_mpls_te_lsa_originate (void *arg)
! 967: {
! 968: struct ospf_area *area = (struct ospf_area *) arg;
! 969: struct listnode *node, *nnode;
! 970: struct mpls_te_link *lp;
! 971: int rc = -1;
! 972:
! 973: if (OspfMplsTE.status == disabled)
! 974: {
! 975: zlog_info ("ospf_mpls_te_lsa_originate: MPLS-TE is disabled now.");
! 976: rc = 0; /* This is not an error case. */
! 977: goto out;
! 978: }
! 979:
! 980: for (ALL_LIST_ELEMENTS (OspfMplsTE.iflist, node, nnode, lp))
! 981: {
! 982: if (lp->area == NULL)
! 983: continue;
! 984: if (! IPV4_ADDR_SAME (&lp->area->area_id, &area->area_id))
! 985: continue;
! 986:
! 987: if (lp->flags & LPFLG_LSA_ENGAGED)
! 988: {
! 989: if (lp->flags & LPFLG_LSA_FORCED_REFRESH)
! 990: {
! 991: lp->flags &= ~LPFLG_LSA_FORCED_REFRESH;
! 992: ospf_mpls_te_lsa_schedule (lp, REFRESH_THIS_LSA);
! 993: }
! 994: continue;
! 995: }
! 996: if (! is_mandated_params_set (lp))
! 997: {
! 998: zlog_warn ("ospf_mpls_te_lsa_originate: Link(%s) lacks some mandated MPLS-TE parameters.", lp->ifp ? lp->ifp->name : "?");
! 999: continue;
! 1000: }
! 1001:
! 1002: /* Ok, let's try to originate an LSA for this area and Link. */
! 1003: if (ospf_mpls_te_lsa_originate1 (area, lp) != 0)
! 1004: goto out;
! 1005: }
! 1006:
! 1007: rc = 0;
! 1008: out:
! 1009: return rc;
! 1010: }
! 1011:
! 1012: static struct ospf_lsa *
! 1013: ospf_mpls_te_lsa_refresh (struct ospf_lsa *lsa)
! 1014: {
! 1015: struct mpls_te_link *lp;
! 1016: struct ospf_area *area = lsa->area;
! 1017: struct ospf_lsa *new = NULL;
! 1018:
! 1019: if (OspfMplsTE.status == disabled)
! 1020: {
! 1021: /*
! 1022: * This LSA must have flushed before due to MPLS-TE status change.
! 1023: * It seems a slip among routers in the routing domain.
! 1024: */
! 1025: zlog_info ("ospf_mpls_te_lsa_refresh: MPLS-TE is disabled now.");
! 1026: lsa->data->ls_age = htons (OSPF_LSA_MAXAGE); /* Flush it anyway. */
! 1027: }
! 1028:
! 1029: /* At first, resolve lsa/lp relationship. */
! 1030: if ((lp = lookup_linkparams_by_instance (lsa)) == NULL)
! 1031: {
! 1032: zlog_warn ("ospf_mpls_te_lsa_refresh: Invalid parameter?");
! 1033: lsa->data->ls_age = htons (OSPF_LSA_MAXAGE); /* Flush it anyway. */
! 1034: }
! 1035:
! 1036: /* If the lsa's age reached to MaxAge, start flushing procedure. */
! 1037: if (IS_LSA_MAXAGE (lsa))
! 1038: {
! 1039: lp->flags &= ~LPFLG_LSA_ENGAGED;
! 1040: ospf_opaque_lsa_flush_schedule (lsa);
! 1041: goto out;
! 1042: }
! 1043:
! 1044: /* Create new Opaque-LSA/MPLS-TE instance. */
! 1045: if ((new = ospf_mpls_te_lsa_new (area, lp)) == NULL)
! 1046: {
! 1047: zlog_warn ("ospf_mpls_te_lsa_refresh: ospf_mpls_te_lsa_new() ?");
! 1048: goto out;
! 1049: }
! 1050: new->data->ls_seqnum = lsa_seqnum_increment (lsa);
! 1051:
! 1052: /* Install this LSA into LSDB. */
! 1053: /* Given "lsa" will be freed in the next function. */
! 1054: if (ospf_lsa_install (area->ospf, NULL/*oi*/, new) == NULL)
! 1055: {
! 1056: zlog_warn ("ospf_mpls_te_lsa_refresh: ospf_lsa_install() ?");
! 1057: ospf_lsa_unlock (&new);
! 1058: goto out;
! 1059: }
! 1060:
! 1061: /* Flood updated LSA through area. */
! 1062: ospf_flood_through_area (area, NULL/*nbr*/, new);
! 1063:
! 1064: /* Debug logging. */
! 1065: if (IS_DEBUG_OSPF (lsa, LSA_GENERATE))
! 1066: {
! 1067: zlog_debug ("LSA[Type%d:%s]: Refresh Opaque-LSA/MPLS-TE",
! 1068: new->data->type, inet_ntoa (new->data->id));
! 1069: ospf_lsa_header_dump (new->data);
! 1070: }
! 1071:
! 1072: out:
! 1073: return new;
! 1074: }
! 1075:
! 1076: static void
! 1077: ospf_mpls_te_lsa_schedule (struct mpls_te_link *lp,
! 1078: enum sched_opcode opcode)
! 1079: {
! 1080: struct ospf_lsa lsa;
! 1081: struct lsa_header lsah;
! 1082: u_int32_t tmp;
! 1083:
! 1084: memset (&lsa, 0, sizeof (lsa));
! 1085: memset (&lsah, 0, sizeof (lsah));
! 1086:
! 1087: lsa.area = lp->area;
! 1088: lsa.data = &lsah;
! 1089: lsah.type = OSPF_OPAQUE_AREA_LSA;
! 1090: tmp = SET_OPAQUE_LSID (OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA, lp->instance);
! 1091: lsah.id.s_addr = htonl (tmp);
! 1092:
! 1093: switch (opcode)
! 1094: {
! 1095: case REORIGINATE_PER_AREA:
! 1096: ospf_opaque_lsa_reoriginate_schedule ((void *) lp->area,
! 1097: OSPF_OPAQUE_AREA_LSA, OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA);
! 1098: break;
! 1099: case REFRESH_THIS_LSA:
! 1100: ospf_opaque_lsa_refresh_schedule (&lsa);
! 1101: break;
! 1102: case FLUSH_THIS_LSA:
! 1103: lp->flags &= ~LPFLG_LSA_ENGAGED;
! 1104: ospf_opaque_lsa_flush_schedule (&lsa);
! 1105: break;
! 1106: default:
! 1107: zlog_warn ("ospf_mpls_te_lsa_schedule: Unknown opcode (%u)", opcode);
! 1108: break;
! 1109: }
! 1110:
! 1111: return;
! 1112: }
! 1113:
! 1114: /*------------------------------------------------------------------------*
! 1115: * Followings are vty session control functions.
! 1116: *------------------------------------------------------------------------*/
! 1117:
! 1118: static u_int16_t
! 1119: show_vty_router_addr (struct vty *vty, struct te_tlv_header *tlvh)
! 1120: {
! 1121: struct te_tlv_router_addr *top = (struct te_tlv_router_addr *) tlvh;
! 1122:
! 1123: if (vty != NULL)
! 1124: vty_out (vty, " Router-Address: %s%s", inet_ntoa (top->value), VTY_NEWLINE);
! 1125: else
! 1126: zlog_debug (" Router-Address: %s", inet_ntoa (top->value));
! 1127:
! 1128: return TLV_SIZE (tlvh);
! 1129: }
! 1130:
! 1131: static u_int16_t
! 1132: show_vty_link_header (struct vty *vty, struct te_tlv_header *tlvh)
! 1133: {
! 1134: struct te_tlv_link *top = (struct te_tlv_link *) tlvh;
! 1135:
! 1136: if (vty != NULL)
! 1137: vty_out (vty, " Link: %u octets of data%s", ntohs (top->header.length), VTY_NEWLINE);
! 1138: else
! 1139: zlog_debug (" Link: %u octets of data", ntohs (top->header.length));
! 1140:
! 1141: return TLV_HDR_SIZE; /* Here is special, not "TLV_SIZE". */
! 1142: }
! 1143:
! 1144: static u_int16_t
! 1145: show_vty_link_subtlv_link_type (struct vty *vty, struct te_tlv_header *tlvh)
! 1146: {
! 1147: struct te_link_subtlv_link_type *top;
! 1148: const char *cp = "Unknown";
! 1149:
! 1150: top = (struct te_link_subtlv_link_type *) tlvh;
! 1151: switch (top->link_type.value)
! 1152: {
! 1153: case LINK_TYPE_SUBTLV_VALUE_PTP:
! 1154: cp = "Point-to-point";
! 1155: break;
! 1156: case LINK_TYPE_SUBTLV_VALUE_MA:
! 1157: cp = "Multiaccess";
! 1158: break;
! 1159: default:
! 1160: break;
! 1161: }
! 1162:
! 1163: if (vty != NULL)
! 1164: vty_out (vty, " Link-Type: %s (%u)%s", cp, top->link_type.value, VTY_NEWLINE);
! 1165: else
! 1166: zlog_debug (" Link-Type: %s (%u)", cp, top->link_type.value);
! 1167:
! 1168: return TLV_SIZE (tlvh);
! 1169: }
! 1170:
! 1171: static u_int16_t
! 1172: show_vty_link_subtlv_link_id (struct vty *vty, struct te_tlv_header *tlvh)
! 1173: {
! 1174: struct te_link_subtlv_link_id *top;
! 1175:
! 1176: top = (struct te_link_subtlv_link_id *) tlvh;
! 1177: if (vty != NULL)
! 1178: vty_out (vty, " Link-ID: %s%s", inet_ntoa (top->value), VTY_NEWLINE);
! 1179: else
! 1180: zlog_debug (" Link-ID: %s", inet_ntoa (top->value));
! 1181:
! 1182: return TLV_SIZE (tlvh);
! 1183: }
! 1184:
! 1185: static u_int16_t
! 1186: show_vty_link_subtlv_lclif_ipaddr (struct vty *vty, struct te_tlv_header *tlvh)
! 1187: {
! 1188: struct te_link_subtlv_lclif_ipaddr *top;
! 1189: int i, n;
! 1190:
! 1191: top = (struct te_link_subtlv_lclif_ipaddr *) tlvh;
! 1192: n = ntohs (tlvh->length) / sizeof (top->value[0]);
! 1193:
! 1194: if (vty != NULL)
! 1195: vty_out (vty, " Local Interface IP Address(es): %d%s", n, VTY_NEWLINE);
! 1196: else
! 1197: zlog_debug (" Local Interface IP Address(es): %d", n);
! 1198:
! 1199: for (i = 0; i < n; i++)
! 1200: {
! 1201: if (vty != NULL)
! 1202: vty_out (vty, " #%d: %s%s", i, inet_ntoa (top->value[i]), VTY_NEWLINE);
! 1203: else
! 1204: zlog_debug (" #%d: %s", i, inet_ntoa (top->value[i]));
! 1205: }
! 1206: return TLV_SIZE (tlvh);
! 1207: }
! 1208:
! 1209: static u_int16_t
! 1210: show_vty_link_subtlv_rmtif_ipaddr (struct vty *vty, struct te_tlv_header *tlvh)
! 1211: {
! 1212: struct te_link_subtlv_rmtif_ipaddr *top;
! 1213: int i, n;
! 1214:
! 1215: top = (struct te_link_subtlv_rmtif_ipaddr *) tlvh;
! 1216: n = ntohs (tlvh->length) / sizeof (top->value[0]);
! 1217: if (vty != NULL)
! 1218: vty_out (vty, " Remote Interface IP Address(es): %d%s", n, VTY_NEWLINE);
! 1219: else
! 1220: zlog_debug (" Remote Interface IP Address(es): %d", n);
! 1221:
! 1222: for (i = 0; i < n; i++)
! 1223: {
! 1224: if (vty != NULL)
! 1225: vty_out (vty, " #%d: %s%s", i, inet_ntoa (top->value[i]), VTY_NEWLINE);
! 1226: else
! 1227: zlog_debug (" #%d: %s", i, inet_ntoa (top->value[i]));
! 1228: }
! 1229: return TLV_SIZE (tlvh);
! 1230: }
! 1231:
! 1232: static u_int16_t
! 1233: show_vty_link_subtlv_te_metric (struct vty *vty, struct te_tlv_header *tlvh)
! 1234: {
! 1235: struct te_link_subtlv_te_metric *top;
! 1236:
! 1237: top = (struct te_link_subtlv_te_metric *) tlvh;
! 1238: if (vty != NULL)
! 1239: vty_out (vty, " Traffic Engineering Metric: %u%s", (u_int32_t) ntohl (top->value), VTY_NEWLINE);
! 1240: else
! 1241: zlog_debug (" Traffic Engineering Metric: %u", (u_int32_t) ntohl (top->value));
! 1242:
! 1243: return TLV_SIZE (tlvh);
! 1244: }
! 1245:
! 1246: static u_int16_t
! 1247: show_vty_link_subtlv_max_bw (struct vty *vty, struct te_tlv_header *tlvh)
! 1248: {
! 1249: struct te_link_subtlv_max_bw *top;
! 1250: float fval;
! 1251:
! 1252: top = (struct te_link_subtlv_max_bw *) tlvh;
! 1253: ntohf (&top->value, &fval);
! 1254:
! 1255: if (vty != NULL)
! 1256: vty_out (vty, " Maximum Bandwidth: %g (Bytes/sec)%s", fval, VTY_NEWLINE);
! 1257: else
! 1258: zlog_debug (" Maximum Bandwidth: %g (Bytes/sec)", fval);
! 1259:
! 1260: return TLV_SIZE (tlvh);
! 1261: }
! 1262:
! 1263: static u_int16_t
! 1264: show_vty_link_subtlv_max_rsv_bw (struct vty *vty, struct te_tlv_header *tlvh)
! 1265: {
! 1266: struct te_link_subtlv_max_rsv_bw *top;
! 1267: float fval;
! 1268:
! 1269: top = (struct te_link_subtlv_max_rsv_bw *) tlvh;
! 1270: ntohf (&top->value, &fval);
! 1271:
! 1272: if (vty != NULL)
! 1273: vty_out (vty, " Maximum Reservable Bandwidth: %g (Bytes/sec)%s", fval, VTY_NEWLINE);
! 1274: else
! 1275: zlog_debug (" Maximum Reservable Bandwidth: %g (Bytes/sec)", fval);
! 1276:
! 1277: return TLV_SIZE (tlvh);
! 1278: }
! 1279:
! 1280: static u_int16_t
! 1281: show_vty_link_subtlv_unrsv_bw (struct vty *vty, struct te_tlv_header *tlvh)
! 1282: {
! 1283: struct te_link_subtlv_unrsv_bw *top;
! 1284: float fval;
! 1285: int i;
! 1286:
! 1287: top = (struct te_link_subtlv_unrsv_bw *) tlvh;
! 1288: for (i = 0; i < 8; i++)
! 1289: {
! 1290: ntohf (&top->value[i], &fval);
! 1291: if (vty != NULL)
! 1292: vty_out (vty, " Unreserved Bandwidth (pri %d): %g (Bytes/sec)%s", i, fval, VTY_NEWLINE);
! 1293: else
! 1294: zlog_debug (" Unreserved Bandwidth (pri %d): %g (Bytes/sec)", i, fval);
! 1295: }
! 1296:
! 1297: return TLV_SIZE (tlvh);
! 1298: }
! 1299:
! 1300: static u_int16_t
! 1301: show_vty_link_subtlv_rsc_clsclr (struct vty *vty, struct te_tlv_header *tlvh)
! 1302: {
! 1303: struct te_link_subtlv_rsc_clsclr *top;
! 1304:
! 1305: top = (struct te_link_subtlv_rsc_clsclr *) tlvh;
! 1306: if (vty != NULL)
! 1307: vty_out (vty, " Resource class/color: 0x%x%s", (u_int32_t) ntohl (top->value), VTY_NEWLINE);
! 1308: else
! 1309: zlog_debug (" Resource Class/Color: 0x%x", (u_int32_t) ntohl (top->value));
! 1310:
! 1311: return TLV_SIZE (tlvh);
! 1312: }
! 1313:
! 1314: static u_int16_t
! 1315: show_vty_unknown_tlv (struct vty *vty, struct te_tlv_header *tlvh)
! 1316: {
! 1317: if (vty != NULL)
! 1318: vty_out (vty, " Unknown TLV: [type(0x%x), length(0x%x)]%s", ntohs (tlvh->type), ntohs (tlvh->length), VTY_NEWLINE);
! 1319: else
! 1320: zlog_debug (" Unknown TLV: [type(0x%x), length(0x%x)]", ntohs (tlvh->type), ntohs (tlvh->length));
! 1321:
! 1322: return TLV_SIZE (tlvh);
! 1323: }
! 1324:
! 1325: static u_int16_t
! 1326: ospf_mpls_te_show_link_subtlv (struct vty *vty, struct te_tlv_header *tlvh0,
! 1327: u_int16_t subtotal, u_int16_t total)
! 1328: {
! 1329: struct te_tlv_header *tlvh, *next;
! 1330: u_int16_t sum = subtotal;
! 1331:
! 1332: for (tlvh = tlvh0; sum < total; tlvh = (next ? next : TLV_HDR_NEXT (tlvh)))
! 1333: {
! 1334: next = NULL;
! 1335: switch (ntohs (tlvh->type))
! 1336: {
! 1337: case TE_LINK_SUBTLV_LINK_TYPE:
! 1338: sum += show_vty_link_subtlv_link_type (vty, tlvh);
! 1339: break;
! 1340: case TE_LINK_SUBTLV_LINK_ID:
! 1341: sum += show_vty_link_subtlv_link_id (vty, tlvh);
! 1342: break;
! 1343: case TE_LINK_SUBTLV_LCLIF_IPADDR:
! 1344: sum += show_vty_link_subtlv_lclif_ipaddr (vty, tlvh);
! 1345: break;
! 1346: case TE_LINK_SUBTLV_RMTIF_IPADDR:
! 1347: sum += show_vty_link_subtlv_rmtif_ipaddr (vty, tlvh);
! 1348: break;
! 1349: case TE_LINK_SUBTLV_TE_METRIC:
! 1350: sum += show_vty_link_subtlv_te_metric (vty, tlvh);
! 1351: break;
! 1352: case TE_LINK_SUBTLV_MAX_BW:
! 1353: sum += show_vty_link_subtlv_max_bw (vty, tlvh);
! 1354: break;
! 1355: case TE_LINK_SUBTLV_MAX_RSV_BW:
! 1356: sum += show_vty_link_subtlv_max_rsv_bw (vty, tlvh);
! 1357: break;
! 1358: case TE_LINK_SUBTLV_UNRSV_BW:
! 1359: sum += show_vty_link_subtlv_unrsv_bw (vty, tlvh);
! 1360: break;
! 1361: case TE_LINK_SUBTLV_RSC_CLSCLR:
! 1362: sum += show_vty_link_subtlv_rsc_clsclr (vty, tlvh);
! 1363: break;
! 1364: default:
! 1365: sum += show_vty_unknown_tlv (vty, tlvh);
! 1366: break;
! 1367: }
! 1368: }
! 1369: return sum;
! 1370: }
! 1371:
! 1372: static void
! 1373: ospf_mpls_te_show_info (struct vty *vty, struct ospf_lsa *lsa)
! 1374: {
! 1375: struct lsa_header *lsah = (struct lsa_header *) lsa->data;
! 1376: struct te_tlv_header *tlvh, *next;
! 1377: u_int16_t sum, total;
! 1378: u_int16_t (* subfunc)(struct vty *vty, struct te_tlv_header *tlvh,
! 1379: u_int16_t subtotal, u_int16_t total) = NULL;
! 1380:
! 1381: sum = 0;
! 1382: total = ntohs (lsah->length) - OSPF_LSA_HEADER_SIZE;
! 1383:
! 1384: for (tlvh = TLV_HDR_TOP (lsah); sum < total;
! 1385: tlvh = (next ? next : TLV_HDR_NEXT (tlvh)))
! 1386: {
! 1387: if (subfunc != NULL)
! 1388: {
! 1389: sum = (* subfunc)(vty, tlvh, sum, total);
! 1390: next = (struct te_tlv_header *)((char *) tlvh + sum);
! 1391: subfunc = NULL;
! 1392: continue;
! 1393: }
! 1394:
! 1395: next = NULL;
! 1396: switch (ntohs (tlvh->type))
! 1397: {
! 1398: case TE_TLV_ROUTER_ADDR:
! 1399: sum += show_vty_router_addr (vty, tlvh);
! 1400: break;
! 1401: case TE_TLV_LINK:
! 1402: sum += show_vty_link_header (vty, tlvh);
! 1403: subfunc = ospf_mpls_te_show_link_subtlv;
! 1404: next = tlvh + 1;
! 1405: break;
! 1406: default:
! 1407: sum += show_vty_unknown_tlv (vty, tlvh);
! 1408: break;
! 1409: }
! 1410: }
! 1411: return;
! 1412: }
! 1413:
! 1414: static void
! 1415: ospf_mpls_te_config_write_router (struct vty *vty)
! 1416: {
! 1417: if (OspfMplsTE.status == enabled)
! 1418: {
! 1419: vty_out (vty, " mpls-te%s", VTY_NEWLINE);
! 1420: vty_out (vty, " mpls-te router-address %s%s",
! 1421: inet_ntoa (OspfMplsTE.router_addr.value), VTY_NEWLINE);
! 1422: }
! 1423: return;
! 1424: }
! 1425:
! 1426: static void
! 1427: ospf_mpls_te_config_write_if (struct vty *vty, struct interface *ifp)
! 1428: {
! 1429: struct mpls_te_link *lp;
! 1430:
! 1431: if ((OspfMplsTE.status == enabled)
! 1432: && (! if_is_loopback (ifp) && if_is_up (ifp) && ospf_oi_count (ifp) > 0)
! 1433: && ((lp = lookup_linkparams_by_ifp (ifp)) != NULL))
! 1434: {
! 1435: float fval;
! 1436: int i;
! 1437:
! 1438: vty_out (vty, " mpls-te link metric %u%s",
! 1439: (u_int32_t) ntohl (lp->te_metric.value), VTY_NEWLINE);
! 1440:
! 1441: ntohf (&lp->max_bw.value, &fval);
! 1442: if (fval >= MPLS_TE_MINIMUM_BANDWIDTH)
! 1443: vty_out (vty, " mpls-te link max-bw %g%s", fval, VTY_NEWLINE);
! 1444:
! 1445: ntohf (&lp->max_rsv_bw.value, &fval);
! 1446: if (fval >= MPLS_TE_MINIMUM_BANDWIDTH)
! 1447: vty_out (vty, " mpls-te link max-rsv-bw %g%s", fval, VTY_NEWLINE);
! 1448:
! 1449: for (i = 0; i < 8; i++)
! 1450: {
! 1451: ntohf (&lp->unrsv_bw.value[i], &fval);
! 1452: if (fval >= MPLS_TE_MINIMUM_BANDWIDTH)
! 1453: vty_out (vty, " mpls-te link unrsv-bw %d %g%s",
! 1454: i, fval, VTY_NEWLINE);
! 1455: }
! 1456:
! 1457: vty_out (vty, " mpls-te link rsc-clsclr 0x%x%s",
! 1458: (u_int32_t) ntohl (lp->rsc_clsclr.value), VTY_NEWLINE);
! 1459: }
! 1460: return;
! 1461: }
! 1462:
! 1463: /*------------------------------------------------------------------------*
! 1464: * Followings are vty command functions.
! 1465: *------------------------------------------------------------------------*/
! 1466:
! 1467: DEFUN (mpls_te,
! 1468: mpls_te_cmd,
! 1469: "mpls-te",
! 1470: "Configure MPLS-TE parameters\n"
! 1471: "Enable the MPLS-TE functionality\n")
! 1472: {
! 1473: struct listnode *node, *nnode;
! 1474: struct mpls_te_link *lp;
! 1475:
! 1476: if (OspfMplsTE.status == enabled)
! 1477: return CMD_SUCCESS;
! 1478:
! 1479: if (IS_DEBUG_OSPF_EVENT)
! 1480: zlog_debug ("MPLS-TE: OFF -> ON");
! 1481:
! 1482: OspfMplsTE.status = enabled;
! 1483:
! 1484: /*
! 1485: * Following code is intended to handle two cases;
! 1486: *
! 1487: * 1) MPLS-TE was disabled at startup time, but now become enabled.
! 1488: * 2) MPLS-TE was once enabled then disabled, and now enabled again.
! 1489: */
! 1490: for (ALL_LIST_ELEMENTS (OspfMplsTE.iflist, node, nnode, lp))
! 1491: initialize_linkparams (lp);
! 1492:
! 1493: ospf_mpls_te_foreach_area (ospf_mpls_te_lsa_schedule, REORIGINATE_PER_AREA);
! 1494:
! 1495: return CMD_SUCCESS;
! 1496: }
! 1497:
! 1498: ALIAS (mpls_te,
! 1499: mpls_te_on_cmd,
! 1500: "mpls-te on",
! 1501: "Configure MPLS-TE parameters\n"
! 1502: "Enable the MPLS-TE functionality\n")
! 1503:
! 1504: DEFUN (no_mpls_te,
! 1505: no_mpls_te_cmd,
! 1506: "no mpls-te",
! 1507: NO_STR
! 1508: "Configure MPLS-TE parameters\n"
! 1509: "Disable the MPLS-TE functionality\n")
! 1510: {
! 1511: struct listnode *node, *nnode;
! 1512: struct mpls_te_link *lp;
! 1513:
! 1514: if (OspfMplsTE.status == disabled)
! 1515: return CMD_SUCCESS;
! 1516:
! 1517: if (IS_DEBUG_OSPF_EVENT)
! 1518: zlog_debug ("MPLS-TE: ON -> OFF");
! 1519:
! 1520: OspfMplsTE.status = disabled;
! 1521:
! 1522: for (ALL_LIST_ELEMENTS (OspfMplsTE.iflist, node, nnode, lp))
! 1523: if (lp->area != NULL)
! 1524: if (lp->flags & LPFLG_LSA_ENGAGED)
! 1525: ospf_mpls_te_lsa_schedule (lp, FLUSH_THIS_LSA);
! 1526:
! 1527: return CMD_SUCCESS;
! 1528: }
! 1529:
! 1530: DEFUN (mpls_te_router_addr,
! 1531: mpls_te_router_addr_cmd,
! 1532: "mpls-te router-address A.B.C.D",
! 1533: "MPLS-TE specific commands\n"
! 1534: "Stable IP address of the advertising router\n"
! 1535: "MPLS-TE router address in IPv4 address format\n")
! 1536: {
! 1537: struct te_tlv_router_addr *ra = &OspfMplsTE.router_addr;
! 1538: struct in_addr value;
! 1539:
! 1540: if (! inet_aton (argv[0], &value))
! 1541: {
! 1542: vty_out (vty, "Please specify Router-Addr by A.B.C.D%s", VTY_NEWLINE);
! 1543: return CMD_WARNING;
! 1544: }
! 1545:
! 1546: if (ntohs (ra->header.type) == 0
! 1547: || ntohl (ra->value.s_addr) != ntohl (value.s_addr))
! 1548: {
! 1549: struct listnode *node, *nnode;
! 1550: struct mpls_te_link *lp;
! 1551: int need_to_reoriginate = 0;
! 1552:
! 1553: set_mpls_te_router_addr (value);
! 1554:
! 1555: if (OspfMplsTE.status == disabled)
! 1556: goto out;
! 1557:
! 1558: for (ALL_LIST_ELEMENTS (OspfMplsTE.iflist, node, nnode, lp))
! 1559: {
! 1560: if (lp->area == NULL)
! 1561: continue;
! 1562:
! 1563: if ((lp->flags & LPFLG_LSA_ENGAGED) == 0)
! 1564: {
! 1565: need_to_reoriginate = 1;
! 1566: break;
! 1567: }
! 1568: }
! 1569:
! 1570: for (ALL_LIST_ELEMENTS (OspfMplsTE.iflist, node, nnode, lp))
! 1571: {
! 1572: if (lp->area == NULL)
! 1573: continue;
! 1574:
! 1575: if (need_to_reoriginate)
! 1576: lp->flags |= LPFLG_LSA_FORCED_REFRESH;
! 1577: else
! 1578: ospf_mpls_te_lsa_schedule (lp, REFRESH_THIS_LSA);
! 1579: }
! 1580:
! 1581: if (need_to_reoriginate)
! 1582: ospf_mpls_te_foreach_area (
! 1583: ospf_mpls_te_lsa_schedule, REORIGINATE_PER_AREA);
! 1584: }
! 1585: out:
! 1586: return CMD_SUCCESS;
! 1587: }
! 1588:
! 1589: DEFUN (mpls_te_link_metric,
! 1590: mpls_te_link_metric_cmd,
! 1591: "mpls-te link metric <0-4294967295>",
! 1592: "MPLS-TE specific commands\n"
! 1593: "Configure MPLS-TE link parameters\n"
! 1594: "Link metric for MPLS-TE purpose\n"
! 1595: "Metric\n")
! 1596: {
! 1597: struct interface *ifp = (struct interface *) vty->index;
! 1598: struct mpls_te_link *lp;
! 1599: u_int32_t value;
! 1600:
! 1601: if ((lp = lookup_linkparams_by_ifp (ifp)) == NULL)
! 1602: {
! 1603: vty_out (vty, "mpls_te_link_metric: Something wrong!%s", VTY_NEWLINE);
! 1604: return CMD_WARNING;
! 1605: }
! 1606:
! 1607: value = strtoul (argv[0], NULL, 10);
! 1608:
! 1609: if (ntohs (lp->te_metric.header.type) == 0
! 1610: || ntohl (lp->te_metric.value) != value)
! 1611: {
! 1612: set_linkparams_te_metric (lp, value);
! 1613:
! 1614: if (OspfMplsTE.status == enabled)
! 1615: if (lp->area != NULL)
! 1616: {
! 1617: if (lp->flags & LPFLG_LSA_ENGAGED)
! 1618: ospf_mpls_te_lsa_schedule (lp, REFRESH_THIS_LSA);
! 1619: else
! 1620: ospf_mpls_te_lsa_schedule (lp, REORIGINATE_PER_AREA);
! 1621: }
! 1622: }
! 1623: return CMD_SUCCESS;
! 1624: }
! 1625:
! 1626: DEFUN (mpls_te_link_maxbw,
! 1627: mpls_te_link_maxbw_cmd,
! 1628: "mpls-te link max-bw BANDWIDTH",
! 1629: "MPLS-TE specific commands\n"
! 1630: "Configure MPLS-TE link parameters\n"
! 1631: "Maximum bandwidth that can be used\n"
! 1632: "Bytes/second (IEEE floating point format)\n")
! 1633: {
! 1634: struct interface *ifp = (struct interface *) vty->index;
! 1635: struct mpls_te_link *lp;
! 1636: float f1, f2;
! 1637:
! 1638: if ((lp = lookup_linkparams_by_ifp (ifp)) == NULL)
! 1639: {
! 1640: vty_out (vty, "mpls_te_link_maxbw: Something wrong!%s", VTY_NEWLINE);
! 1641: return CMD_WARNING;
! 1642: }
! 1643:
! 1644: ntohf (&lp->max_bw.value, &f1);
! 1645: if (sscanf (argv[0], "%g", &f2) != 1)
! 1646: {
! 1647: vty_out (vty, "mpls_te_link_maxbw: fscanf: %s%s", safe_strerror (errno), VTY_NEWLINE);
! 1648: return CMD_WARNING;
! 1649: }
! 1650:
! 1651: if (ntohs (lp->max_bw.header.type) == 0
! 1652: || f1 != f2)
! 1653: {
! 1654: set_linkparams_max_bw (lp, &f2);
! 1655:
! 1656: if (OspfMplsTE.status == enabled)
! 1657: if (lp->area != NULL)
! 1658: {
! 1659: if (lp->flags & LPFLG_LSA_ENGAGED)
! 1660: ospf_mpls_te_lsa_schedule (lp, REFRESH_THIS_LSA);
! 1661: else
! 1662: ospf_mpls_te_lsa_schedule (lp, REORIGINATE_PER_AREA);
! 1663: }
! 1664: }
! 1665: return CMD_SUCCESS;
! 1666: }
! 1667:
! 1668: DEFUN (mpls_te_link_max_rsv_bw,
! 1669: mpls_te_link_max_rsv_bw_cmd,
! 1670: "mpls-te link max-rsv-bw BANDWIDTH",
! 1671: "MPLS-TE specific commands\n"
! 1672: "Configure MPLS-TE link parameters\n"
! 1673: "Maximum bandwidth that may be reserved\n"
! 1674: "Bytes/second (IEEE floating point format)\n")
! 1675: {
! 1676: struct interface *ifp = (struct interface *) vty->index;
! 1677: struct mpls_te_link *lp;
! 1678: float f1, f2;
! 1679:
! 1680: if ((lp = lookup_linkparams_by_ifp (ifp)) == NULL)
! 1681: {
! 1682: vty_out (vty, "mpls_te_link_max_rsv_bw: Something wrong!%s", VTY_NEWLINE);
! 1683: return CMD_WARNING;
! 1684: }
! 1685:
! 1686: ntohf (&lp->max_rsv_bw.value, &f1);
! 1687: if (sscanf (argv[0], "%g", &f2) != 1)
! 1688: {
! 1689: vty_out (vty, "mpls_te_link_max_rsv_bw: fscanf: %s%s", safe_strerror (errno), VTY_NEWLINE);
! 1690: return CMD_WARNING;
! 1691: }
! 1692:
! 1693: if (ntohs (lp->max_rsv_bw.header.type) == 0
! 1694: || f1 != f2)
! 1695: {
! 1696: set_linkparams_max_rsv_bw (lp, &f2);
! 1697:
! 1698: if (OspfMplsTE.status == enabled)
! 1699: if (lp->area != NULL)
! 1700: {
! 1701: if (lp->flags & LPFLG_LSA_ENGAGED)
! 1702: ospf_mpls_te_lsa_schedule (lp, REFRESH_THIS_LSA);
! 1703: else
! 1704: ospf_mpls_te_lsa_schedule (lp, REORIGINATE_PER_AREA);
! 1705: }
! 1706: }
! 1707: return CMD_SUCCESS;
! 1708: }
! 1709:
! 1710: DEFUN (mpls_te_link_unrsv_bw,
! 1711: mpls_te_link_unrsv_bw_cmd,
! 1712: "mpls-te link unrsv-bw <0-7> BANDWIDTH",
! 1713: "MPLS-TE specific commands\n"
! 1714: "Configure MPLS-TE link parameters\n"
! 1715: "Unreserved bandwidth at each priority level\n"
! 1716: "Priority\n"
! 1717: "Bytes/second (IEEE floating point format)\n")
! 1718: {
! 1719: struct interface *ifp = (struct interface *) vty->index;
! 1720: struct mpls_te_link *lp;
! 1721: int priority;
! 1722: float f1, f2;
! 1723:
! 1724: if ((lp = lookup_linkparams_by_ifp (ifp)) == NULL)
! 1725: {
! 1726: vty_out (vty, "mpls_te_link_unrsv_bw: Something wrong!%s", VTY_NEWLINE);
! 1727: return CMD_WARNING;
! 1728: }
! 1729:
! 1730: /* We don't have to consider about range check here. */
! 1731: if (sscanf (argv[0], "%d", &priority) != 1)
! 1732: {
! 1733: vty_out (vty, "mpls_te_link_unrsv_bw: fscanf: %s%s", safe_strerror (errno), VTY_NEWLINE);
! 1734: return CMD_WARNING;
! 1735: }
! 1736:
! 1737: ntohf (&lp->unrsv_bw.value [priority], &f1);
! 1738: if (sscanf (argv[1], "%g", &f2) != 1)
! 1739: {
! 1740: vty_out (vty, "mpls_te_link_unrsv_bw: fscanf: %s%s", safe_strerror (errno), VTY_NEWLINE);
! 1741: return CMD_WARNING;
! 1742: }
! 1743:
! 1744: if (ntohs (lp->unrsv_bw.header.type) == 0
! 1745: || f1 != f2)
! 1746: {
! 1747: set_linkparams_unrsv_bw (lp, priority, &f2);
! 1748:
! 1749: if (OspfMplsTE.status == enabled)
! 1750: if (lp->area != NULL)
! 1751: {
! 1752: if (lp->flags & LPFLG_LSA_ENGAGED)
! 1753: ospf_mpls_te_lsa_schedule (lp, REFRESH_THIS_LSA);
! 1754: else
! 1755: ospf_mpls_te_lsa_schedule (lp, REORIGINATE_PER_AREA);
! 1756: }
! 1757: }
! 1758: return CMD_SUCCESS;
! 1759: }
! 1760:
! 1761: DEFUN (mpls_te_link_rsc_clsclr,
! 1762: mpls_te_link_rsc_clsclr_cmd,
! 1763: "mpls-te link rsc-clsclr BITPATTERN",
! 1764: "MPLS-TE specific commands\n"
! 1765: "Configure MPLS-TE link parameters\n"
! 1766: "Administrative group membership\n"
! 1767: "32-bit Hexadecimal value (ex. 0xa1)\n")
! 1768: {
! 1769: struct interface *ifp = (struct interface *) vty->index;
! 1770: struct mpls_te_link *lp;
! 1771: unsigned long value;
! 1772:
! 1773: if ((lp = lookup_linkparams_by_ifp (ifp)) == NULL)
! 1774: {
! 1775: vty_out (vty, "mpls_te_link_rsc_clsclr: Something wrong!%s", VTY_NEWLINE);
! 1776: return CMD_WARNING;
! 1777: }
! 1778:
! 1779: if (sscanf (argv[0], "0x%lx", &value) != 1)
! 1780: {
! 1781: vty_out (vty, "mpls_te_link_rsc_clsclr: fscanf: %s%s", safe_strerror (errno), VTY_NEWLINE);
! 1782: return CMD_WARNING;
! 1783: }
! 1784:
! 1785: if (ntohs (lp->rsc_clsclr.header.type) == 0
! 1786: || ntohl (lp->rsc_clsclr.value) != value)
! 1787: {
! 1788: set_linkparams_rsc_clsclr (lp, value);
! 1789:
! 1790: if (OspfMplsTE.status == enabled)
! 1791: if (lp->area != NULL)
! 1792: {
! 1793: if (lp->flags & LPFLG_LSA_ENGAGED)
! 1794: ospf_mpls_te_lsa_schedule (lp, REFRESH_THIS_LSA);
! 1795: else
! 1796: ospf_mpls_te_lsa_schedule (lp, REORIGINATE_PER_AREA);
! 1797: }
! 1798: }
! 1799: return CMD_SUCCESS;
! 1800: }
! 1801:
! 1802: DEFUN (show_mpls_te_router,
! 1803: show_mpls_te_router_cmd,
! 1804: "show mpls-te router",
! 1805: SHOW_STR
! 1806: "MPLS-TE information\n"
! 1807: "Router information\n")
! 1808: {
! 1809: if (OspfMplsTE.status == enabled)
! 1810: {
! 1811: vty_out (vty, "--- MPLS-TE router parameters ---%s",
! 1812: VTY_NEWLINE);
! 1813:
! 1814: if (ntohs (OspfMplsTE.router_addr.header.type) != 0)
! 1815: show_vty_router_addr (vty, &OspfMplsTE.router_addr.header);
! 1816: else if (vty != NULL)
! 1817: vty_out (vty, " N/A%s", VTY_NEWLINE);
! 1818: }
! 1819: return CMD_SUCCESS;
! 1820: }
! 1821:
! 1822: static void
! 1823: show_mpls_te_link_sub (struct vty *vty, struct interface *ifp)
! 1824: {
! 1825: struct mpls_te_link *lp;
! 1826: struct te_tlv_header *tlvh;
! 1827:
! 1828: if ((OspfMplsTE.status == enabled)
! 1829: && (! if_is_loopback (ifp) && if_is_up (ifp) && ospf_oi_count (ifp) > 0)
! 1830: && ((lp = lookup_linkparams_by_ifp (ifp)) != NULL))
! 1831: {
! 1832: vty_out (vty, "-- MPLS-TE link parameters for %s --%s",
! 1833: ifp->name, VTY_NEWLINE);
! 1834:
! 1835: show_vty_link_subtlv_link_type (vty, &lp->link_type.header);
! 1836: show_vty_link_subtlv_link_id (vty, &lp->link_id.header);
! 1837:
! 1838: if ((tlvh = (struct te_tlv_header *) lp->lclif_ipaddr) != NULL)
! 1839: show_vty_link_subtlv_lclif_ipaddr (vty, tlvh);
! 1840: if ((tlvh = (struct te_tlv_header *) lp->rmtif_ipaddr) != NULL)
! 1841: show_vty_link_subtlv_rmtif_ipaddr (vty, tlvh);
! 1842:
! 1843: show_vty_link_subtlv_te_metric (vty, &lp->te_metric.header);
! 1844:
! 1845: show_vty_link_subtlv_max_bw (vty, &lp->max_bw.header);
! 1846: show_vty_link_subtlv_max_rsv_bw (vty, &lp->max_rsv_bw.header);
! 1847: show_vty_link_subtlv_unrsv_bw (vty, &lp->unrsv_bw.header);
! 1848: show_vty_link_subtlv_rsc_clsclr (vty, &lp->rsc_clsclr.header);
! 1849: }
! 1850: else
! 1851: {
! 1852: vty_out (vty, " %s: MPLS-TE is disabled on this interface%s",
! 1853: ifp->name, VTY_NEWLINE);
! 1854: }
! 1855:
! 1856: return;
! 1857: }
! 1858:
! 1859: DEFUN (show_mpls_te_link,
! 1860: show_mpls_te_link_cmd,
! 1861: "show mpls-te interface [INTERFACE]",
! 1862: SHOW_STR
! 1863: "MPLS-TE information\n"
! 1864: "Interface information\n"
! 1865: "Interface name\n")
! 1866: {
! 1867: struct interface *ifp;
! 1868: struct listnode *node, *nnode;
! 1869:
! 1870: /* Show All Interfaces. */
! 1871: if (argc == 0)
! 1872: {
! 1873: for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
! 1874: show_mpls_te_link_sub (vty, ifp);
! 1875: }
! 1876: /* Interface name is specified. */
! 1877: else
! 1878: {
! 1879: if ((ifp = if_lookup_by_name (argv[0])) == NULL)
! 1880: vty_out (vty, "No such interface name%s", VTY_NEWLINE);
! 1881: else
! 1882: show_mpls_te_link_sub (vty, ifp);
! 1883: }
! 1884:
! 1885: return CMD_SUCCESS;
! 1886: }
! 1887:
! 1888: static void
! 1889: ospf_mpls_te_register_vty (void)
! 1890: {
! 1891: install_element (VIEW_NODE, &show_mpls_te_router_cmd);
! 1892: install_element (VIEW_NODE, &show_mpls_te_link_cmd);
! 1893: install_element (ENABLE_NODE, &show_mpls_te_router_cmd);
! 1894: install_element (ENABLE_NODE, &show_mpls_te_link_cmd);
! 1895:
! 1896: install_element (OSPF_NODE, &mpls_te_cmd);
! 1897: install_element (OSPF_NODE, &no_mpls_te_cmd);
! 1898: install_element (OSPF_NODE, &mpls_te_on_cmd);
! 1899: install_element (OSPF_NODE, &mpls_te_router_addr_cmd);
! 1900:
! 1901: install_element (INTERFACE_NODE, &mpls_te_link_metric_cmd);
! 1902: install_element (INTERFACE_NODE, &mpls_te_link_maxbw_cmd);
! 1903: install_element (INTERFACE_NODE, &mpls_te_link_max_rsv_bw_cmd);
! 1904: install_element (INTERFACE_NODE, &mpls_te_link_unrsv_bw_cmd);
! 1905: install_element (INTERFACE_NODE, &mpls_te_link_rsc_clsclr_cmd);
! 1906:
! 1907: return;
! 1908: }
! 1909:
! 1910: #endif /* HAVE_OSPF_TE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospf_te.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / ospfd