diff --git a/ospfd/ospf_ri.c b/ospfd/ospf_ri.c
new file mode 100644
index 0000000..5b1032b
--- /dev/null
+++ b/ospfd/ospf_ri.c
@@ -0,0 +1,1639 @@
+/*
+ * This is an implementation of RFC4970 Router Information
+ * with support of RFC5088 PCE Capabilites announcement
+ *
+ * Module name: Router Information
+ * Version:     0.99.22
+ * Created:     2012-02-01 by Olivier Dugeon
+ * Copyright (C) 2012 Orange Labs http://www.orange.com/
+ *
+ * This file is part of GNU Quagga.
+ *
+ * GNU Zebra is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ * 
+ * GNU Quagga is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Quagga; see the file COPYING.  If not, write to the Free
+ * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <zebra.h>
+#include <math.h>
+
+#include "linklist.h"
+#include "prefix.h"
+#include "if.h"
+#include "table.h"
+#include "memory.h"
+#include "command.h"
+#include "vty.h"
+#include "stream.h"
+#include "log.h"
+#include "thread.h"
+#include "hash.h"
+#include "sockunion.h"          /* for inet_aton() */
+
+#include "ospfd/ospfd.h"
+#include "ospfd/ospf_interface.h"
+#include "ospfd/ospf_ism.h"
+#include "ospfd/ospf_asbr.h"
+#include "ospfd/ospf_lsa.h"
+#include "ospfd/ospf_lsdb.h"
+#include "ospfd/ospf_neighbor.h"
+#include "ospfd/ospf_nsm.h"
+#include "ospfd/ospf_flood.h"
+#include "ospfd/ospf_packet.h"
+#include "ospfd/ospf_spf.h"
+#include "ospfd/ospf_dump.h"
+#include "ospfd/ospf_route.h"
+#include "ospfd/ospf_ase.h"
+#include "ospfd/ospf_zebra.h"
+#include "ospfd/ospf_ri.h"
+#include "ospfd/ospf_te.h"
+
+struct ospf_pce_info
+{
+
+  /* Store Router Information PCE TLV and SubTLV in network byte order. */
+  struct ri_tlv_pce pce_header;
+  struct ri_pce_subtlv_address pce_address;
+  struct ri_pce_subtlv_path_scope pce_scope;
+  struct list *pce_domain;
+  struct list *pce_neighbor;
+  struct ri_pce_subtlv_cap_flag pce_cap_flag;
+};
+
+/* Following structure are internal use only. */
+struct ospf_router_info
+{
+  status_t status;
+
+  u_int8_t registered;
+  u_int8_t scope;
+
+  /* Flags to manage this router information. */
+#define RIFLG_LOOKUP_DONE			0x1
+#define RIFLG_LSA_ENGAGED			0x2
+#define RIFLG_LSA_FORCED_REFRESH	0x4
+  u_int32_t flags;
+
+  /* area pointer if flooding is Type 10 Null if flooding is AS scope */
+  struct ospf_area *area;
+  struct in_addr area_id;
+
+  /* Store Router Information Capabilities LSA */
+  struct ri_tlv_router_cap router_cap;
+
+  /* Store PCE capability LSA */
+  struct ospf_pce_info pce_info;
+};
+
+/*
+ * Global variable to manage Opaque-LSA/Router Information on this node.
+ * Note that all parameter values are stored in network byte order.
+ */
+static struct ospf_router_info OspfRI;
+
+/*------------------------------------------------------------------------------*
+ * Followings are initialize/terminate functions for Router Information handling.
+ *------------------------------------------------------------------------------*/
+
+static void ospf_router_info_ism_change (struct ospf_interface *oi,
+                                         int old_status);
+static void ospf_router_info_nsm_change (struct ospf_neighbor *nbr,
+                                         int old_status);
+static void ospf_router_info_config_write_router (struct vty *vty);
+static void ospf_router_info_show_info (struct vty *vty,
+                                        struct ospf_lsa *lsa);
+static int ospf_router_info_lsa_originate (void *arg);
+static struct ospf_lsa *ospf_router_info_lsa_refresh (struct ospf_lsa *lsa);
+static void ospf_router_info_lsa_schedule (opcode_t opcode);
+static void ospf_router_info_register_vty (void);
+static void del_pce_info (void *val);
+
+int
+ospf_router_info_init (void)
+{
+
+  memset (&OspfRI, 0, sizeof (struct ospf_router_info));
+  OspfRI.status = disabled;
+  OspfRI.registered = 0;
+  OspfRI.scope = OSPF_OPAQUE_AS_LSA;
+  OspfRI.flags = 0;
+
+  /* Initialize pce domain and neighbor list */
+  OspfRI.pce_info.pce_domain = list_new ();
+  OspfRI.pce_info.pce_domain->del = del_pce_info;
+  OspfRI.pce_info.pce_neighbor = list_new ();
+  OspfRI.pce_info.pce_neighbor->del = del_pce_info;
+
+  ospf_router_info_register_vty ();
+
+  return 0;
+}
+
+static int
+ospf_router_info_register (u_int8_t scope)
+{
+  int rc = 0;
+
+  if (OspfRI.registered)
+    return 0;
+
+  zlog_info ("Register Router Information with scope %s(%d)",
+             scope == OSPF_OPAQUE_AREA_LSA ? "Area" : "AS", scope);
+  rc = ospf_register_opaque_functab (scope,
+                                     OPAQUE_TYPE_ROUTER_INFORMATION_LSA,
+                                     NULL,    /* new interface */
+                                     NULL,    /* del interface */
+                                     ospf_router_info_ism_change,
+                                     ospf_router_info_nsm_change,
+                                     ospf_router_info_config_write_router,
+                                     NULL,    /* Config. write interface */
+                                     NULL,    /* Config. write debug */
+                                     ospf_router_info_show_info,
+                                     ospf_router_info_lsa_originate,
+                                     ospf_router_info_lsa_refresh,
+                                     NULL,    /* new_lsa_hook */
+                                     NULL);   /* del_lsa_hook */
+
+  if (rc != 0)
+    {
+      zlog_warn ("ospf_router_info_init: Failed to register functions");
+      return rc;
+    }
+
+  OspfRI.registered = 1;
+  OspfRI.scope = scope;
+  return 0;
+}
+
+static int
+ospf_router_info_unregister ()
+{
+
+  if ((OspfRI.scope != OSPF_OPAQUE_AS_LSA)
+      && (OspfRI.scope != OSPF_OPAQUE_AREA_LSA))
+    {
+      zlog_warn ("Unable to unregister Router Info functions: Wrong scope!");
+      return -1;
+    }
+
+  ospf_delete_opaque_functab (OspfRI.scope,
+                              OPAQUE_TYPE_ROUTER_INFORMATION_LSA);
+
+  OspfRI.registered = 0;
+  return 0;
+
+}
+
+void
+ospf_router_info_term (void)
+{
+
+  list_delete (OspfRI.pce_info.pce_domain);
+  list_delete (OspfRI.pce_info.pce_neighbor);
+
+  OspfRI.pce_info.pce_domain = NULL;
+  OspfRI.pce_info.pce_neighbor = NULL;
+  OspfRI.status = disabled;
+
+  ospf_router_info_unregister (OspfRI.scope);
+
+  return;
+}
+
+static void
+del_pce_info (void *val)
+{
+  XFREE (MTYPE_OSPF_PCE_PARAMS, val);
+  return;
+}
+
+/*------------------------------------------------------------------------*
+ * Followings are control functions for ROUTER INFORMATION parameters management.
+ *------------------------------------------------------------------------*/
+
+static void
+set_router_info_capabilities (struct ri_tlv_router_cap *ric, u_int32_t cap)
+{
+  ric->header.type = htons (RI_TLV_CAPABILITIES);
+  ric->header.length = htons (RI_TLV_LENGTH);
+  ric->value = htonl (cap);
+  return;
+}
+
+static int
+set_pce_header (struct ospf_pce_info *pce)
+{
+  u_int16_t length = 0;
+  struct listnode *node;
+  struct ri_pce_subtlv_domain *domain;
+  struct ri_pce_subtlv_neighbor *neighbor;
+
+  /* PCE Address */
+  if (ntohs (pce->pce_address.header.type) != 0)
+    length += RI_TLV_SIZE (&pce->pce_address.header);
+
+  /* PCE Path Scope */
+  if (ntohs (pce->pce_scope.header.type) != 0)
+    length += RI_TLV_SIZE (&pce->pce_scope.header);
+
+  /* PCE Domain */
+  for (ALL_LIST_ELEMENTS_RO (pce->pce_domain, node, domain))
+    {
+      if (ntohs (domain->header.type) != 0)
+        length += RI_TLV_SIZE (&domain->header);
+    }
+
+  /* PCE Neighbor */
+  for (ALL_LIST_ELEMENTS_RO (pce->pce_neighbor, node, neighbor))
+    {
+      if (ntohs (neighbor->header.type) != 0)
+        length += RI_TLV_SIZE (&neighbor->header);
+    }
+
+  /* PCE Capabilities */
+  if (ntohs (pce->pce_cap_flag.header.type) != 0)
+    length += RI_TLV_SIZE (&pce->pce_cap_flag.header);
+
+  if (length != 0)
+    {
+      pce->pce_header.header.type = htons (RI_TLV_PCE);
+      pce->pce_header.header.length = htons (length);
+    }
+  else
+    {
+      pce->pce_header.header.type = 0;
+      pce->pce_header.header.length = 0;
+    }
+
+  return length;
+}
+
+static void
+set_pce_address (struct in_addr ipv4, struct ospf_pce_info *pce)
+{
+
+  /* Enable PCE Info */
+  pce->pce_header.header.type = htons (RI_TLV_PCE);
+  /* Set PCE Address */
+  pce->pce_address.header.type = htons (RI_PCE_SUBTLV_ADDRESS);
+  pce->pce_address.header.length = htons (PCE_ADDRESS_LENGTH_IPV4);
+  pce->pce_address.address.type = htons (PCE_ADDRESS_TYPE_IPV4);
+  pce->pce_address.address.value = ipv4;
+
+  return;
+}
+
+static void
+set_pce_path_scope (u_int32_t scope, struct ospf_pce_info *pce)
+{
+
+  /* Enable PCE Info */
+  pce->pce_header.header.type = htons (RI_TLV_PCE);
+  /* Set PCE Scope */
+  pce->pce_scope.header.type = htons (RI_PCE_SUBTLV_PATH_SCOPE);
+  pce->pce_scope.header.length = htons (RI_TLV_LENGTH);
+  pce->pce_scope.value = htonl (scope);
+
+  return;
+}
+
+static void
+set_pce_domain (u_int16_t type, u_int32_t domain, struct ospf_pce_info *pce)
+{
+
+  struct ri_pce_subtlv_domain *new;
+
+  /* Enable PCE Info */
+  pce->pce_header.header.type = htons (RI_TLV_PCE);
+
+  /* Create new domain info */
+  new =
+    XCALLOC (MTYPE_OSPF_PCE_PARAMS,
+             sizeof (struct ri_pce_subtlv_domain));
+
+  new->header.type = htons (RI_PCE_SUBTLV_DOMAIN);
+  new->header.length = htons (PCE_ADDRESS_LENGTH_IPV4);
+  new->type = htons (type);
+  new->value = htonl (domain);
+
+  /* Add new domain to the list */
+  listnode_add (pce->pce_domain, new);
+
+  return;
+}
+
+static void
+unset_pce_domain (u_int16_t type, u_int32_t domain, struct ospf_pce_info *pce)
+{
+  struct listnode *node;
+  struct ri_pce_subtlv_domain *old = NULL;
+  int found = 0;
+
+  /* Search the corresponding node */
+  for (ALL_LIST_ELEMENTS_RO (pce->pce_domain, node, old))
+    {
+      if ((old->type == htons (type)) && (old->value == htonl (domain)))
+        {
+          found = 1;
+          break;
+        }
+    }
+
+  /* if found remove it */
+  if (found)
+    {
+      listnode_delete (pce->pce_domain, old);
+
+      /* Avoid misjudgement in the next lookup. */
+      if (listcount (pce->pce_domain) == 0)
+        pce->pce_domain->head = pce->pce_domain->tail = NULL;
+
+      /* Finally free the old domain */
+      XFREE (MTYPE_OSPF_PCE_PARAMS, old);
+    }
+}
+
+static void
+set_pce_neighbor (u_int16_t type, u_int32_t domain, struct ospf_pce_info *pce)
+{
+
+  struct ri_pce_subtlv_neighbor *new;
+
+  /* Enable PCE Info */
+  pce->pce_header.header.type = htons (RI_TLV_PCE);
+
+  /* Create new neighbor info */
+  new =
+    XCALLOC (MTYPE_OSPF_PCE_PARAMS,
+             sizeof (struct ri_pce_subtlv_neighbor));
+
+  new->header.type = htons (RI_PCE_SUBTLV_NEIGHBOR);
+  new->header.length = htons (PCE_ADDRESS_LENGTH_IPV4);
+  new->type = htons (type);
+  new->value = htonl (domain);
+
+  /* Add new domain to the list */
+  listnode_add (pce->pce_neighbor, new);
+
+  return;
+}
+
+static void
+unset_pce_neighbor (u_int16_t type, u_int32_t domain,
+                    struct ospf_pce_info *pce)
+{
+  struct listnode *node;
+  struct ri_pce_subtlv_neighbor *old = NULL;
+  int found = 0;
+
+  /* Search the corresponding node */
+  for (ALL_LIST_ELEMENTS_RO (pce->pce_neighbor, node, old))
+    {
+      if ((old->type == htons (type)) && (old->value == htonl (domain)))
+        {
+          found = 1;
+          break;
+        }
+    }
+
+  /* if found remove it */
+  if (found)
+    {
+      listnode_delete (pce->pce_neighbor, old);
+
+      /* Avoid misjudgement in the next lookup. */
+      if (listcount (pce->pce_neighbor) == 0)
+        pce->pce_neighbor->head = pce->pce_neighbor->tail = NULL;
+
+      /* Finally free the old domain */
+      XFREE (MTYPE_OSPF_PCE_PARAMS, old);
+    }
+}
+
+static void
+set_pce_cap_flag (u_int32_t cap, struct ospf_pce_info *pce)
+{
+
+  /* Enable PCE Info */
+  pce->pce_header.header.type = htons (RI_TLV_PCE);
+  /* Set PCE Capabilities flag */
+  pce->pce_cap_flag.header.type = htons (RI_PCE_SUBTLV_CAP_FLAG);
+  pce->pce_cap_flag.header.length = htons (RI_TLV_LENGTH);
+  pce->pce_cap_flag.value = htonl (cap);
+
+  return;
+}
+
+
+static void
+unset_param (struct ri_tlv_header *tlv)
+{
+
+  tlv->type = 0;
+  /* Fill the Value to 0 */
+  memset ((tlv + RI_TLV_HDR_SIZE), 0, RI_TLV_BODY_SIZE (tlv));
+  tlv->length = 0;
+
+  return;
+}
+
+static void
+initialize_params (struct ospf_router_info *ori)
+{
+  u_int32_t cap;
+  struct ospf *top;
+
+  /*
+   * Initialize default Router Information Capabilities.
+   */
+  cap = 0;
+  cap = cap | RI_TE_SUPPORT;
+
+  set_router_info_capabilities (&ori->router_cap, cap);
+
+  /* If Area address is not null and exist, retrieve corresponding structure */
+  top = ospf_lookup ();
+  zlog_info ("RI-> Initialize Router Info for %s scope within area %s",
+             OspfRI.scope == OSPF_OPAQUE_AREA_LSA ? "Area" : "AS",
+             inet_ntoa (OspfRI.area_id));
+
+  /* Try to get the Area context at this step. Do it latter if not available */
+  if ((OspfRI.scope == OSPF_OPAQUE_AREA_LSA) && (OspfRI.area == NULL))
+    OspfRI.area = ospf_area_lookup_by_area_id (top, OspfRI.area_id);
+
+  /*
+   * Initialize default PCE Information values
+   */
+  /* PCE address == OSPF Router ID */
+  set_pce_address (top->router_id, &ori->pce_info);
+
+  /* PCE scope */
+  cap = 7;                      /* Set L, R and Rd bits to one = intra & inter-area path computation */
+  set_pce_path_scope (cap, &ori->pce_info);
+
+  /* PCE Capabilities */
+  cap =
+    PCE_CAP_BIDIRECTIONAL | PCE_CAP_DIVERSE_PATH | PCE_CAP_OBJECTIVES |
+    PCE_CAP_ADDITIVE | PCE_CAP_MULTIPLE_REQ;
+  set_pce_cap_flag (cap, &ori->pce_info);
+
+  /* Finally compute PCE header */
+  set_pce_header (&ori->pce_info);
+
+  return;
+}
+
+static int
+is_mandated_params_set (struct ospf_router_info ori)
+{
+  int rc = 0;
+
+  if (ntohs (ori.router_cap.header.type) == 0)
+    goto out;
+
+  if ((ntohs (ori.pce_info.pce_header.header.type) == RI_TLV_PCE)
+      && (ntohs (ori.pce_info.pce_address.header.type) == 0)
+      && (ntohs (ori.pce_info.pce_cap_flag.header.type) == 0))
+    goto out;
+
+  rc = 1;
+
+out:
+  return rc;
+}
+
+/*------------------------------------------------------------------------*
+ * Followings are callback functions against generic Opaque-LSAs handling.
+ *------------------------------------------------------------------------*/
+static void
+ospf_router_info_ism_change (struct ospf_interface *oi, int old_state)
+{
+  /* So far, nothing to do here. */
+  return;
+
+}
+
+static void
+ospf_router_info_nsm_change (struct ospf_neighbor *nbr, int old_state)
+{
+
+  /* So far, nothing to do here. */
+  return;
+}
+
+/*------------------------------------------------------------------------*
+ * Followings are OSPF protocol processing functions for ROUTER INFORMATION
+ *------------------------------------------------------------------------*/
+
+static void
+build_tlv_header (struct stream *s, struct ri_tlv_header *tlvh)
+{
+
+  stream_put (s, tlvh, sizeof (struct ri_tlv_header));
+  return;
+}
+
+static void
+build_tlv (struct stream *s, struct ri_tlv_header *tlvh)
+{
+
+  if (ntohs (tlvh->type) != 0)
+    {
+      build_tlv_header (s, tlvh);
+      stream_put (s, tlvh + 1, RI_TLV_BODY_SIZE (tlvh));
+    }
+  return;
+}
+
+static void
+ospf_router_info_lsa_body_set (struct stream *s)
+{
+
+  struct listnode *node;
+  struct ri_pce_subtlv_domain *domain;
+  struct ri_pce_subtlv_neighbor *neighbor;
+
+  /* Build Router Information TLV */
+  build_tlv (s, &OspfRI.router_cap.header);
+
+  /* Add RI PCE TLV if it is set */
+  /* Compute PCE Info header first */
+  if ((set_pce_header (&OspfRI.pce_info)) != 0)
+    {
+
+      /* Build PCE TLV */
+      build_tlv_header (s, &OspfRI.pce_info.pce_header.header);
+
+      /* Build PCE address sub-tlv */
+      build_tlv (s, &OspfRI.pce_info.pce_address.header);
+
+      /* Build PCE path scope sub-tlv */
+      build_tlv (s, &OspfRI.pce_info.pce_scope.header);
+
+      /* Build PCE domain sub-tlv */
+      for (ALL_LIST_ELEMENTS_RO (OspfRI.pce_info.pce_domain, node, domain))
+        build_tlv (s, &domain->header);
+
+      /* Build PCE neighbor sub-tlv */
+      for (ALL_LIST_ELEMENTS_RO
+           (OspfRI.pce_info.pce_neighbor, node, neighbor))
+        build_tlv (s, &neighbor->header);
+
+      /* Build PCE cap flag sub-tlv */
+      build_tlv (s, &OspfRI.pce_info.pce_cap_flag.header);
+    }
+
+  return;
+}
+
+/* Create new opaque-LSA. */
+static struct ospf_lsa *
+ospf_router_info_lsa_new ()
+{
+  struct ospf *top;
+  struct stream *s;
+  struct lsa_header *lsah;
+  struct ospf_lsa *new = NULL;
+  u_char options, lsa_type;
+  struct in_addr lsa_id;
+  u_int32_t tmp;
+  u_int16_t length;
+
+  /* Create a stream for LSA. */
+  if ((s = stream_new (OSPF_MAX_LSA_SIZE)) == NULL)
+    {
+      zlog_warn ("ospf_router_info_lsa_new: stream_new() ?");
+      goto out;
+    }
+  lsah = (struct lsa_header *) STREAM_DATA (s);
+
+  options = OSPF_OPTION_E;      /* Enable AS external as we flood RI with Opaque Type 11 */
+  options |= OSPF_OPTION_O;     /* Don't forget this :-) */
+
+  lsa_type = OspfRI.scope;
+  /* LSA ID == 0 for Router Information see RFC 4970 */
+  tmp = SET_OPAQUE_LSID (OPAQUE_TYPE_ROUTER_INFORMATION_LSA, 0);
+  lsa_id.s_addr = htonl (tmp);
+
+  if (IS_DEBUG_OSPF (lsa, LSA_GENERATE))
+    zlog_debug
+      ("LSA[Type%d:%s]: Create an Opaque-LSA/ROUTER INFORMATION instance",
+       lsa_type, inet_ntoa (lsa_id));
+
+  top = ospf_lookup ();
+
+  /* Set opaque-LSA header fields. */
+  lsa_header_set (s, options, lsa_type, lsa_id, top->router_id);
+
+  /* Set opaque-LSA body fields. */
+  ospf_router_info_lsa_body_set (s);
+
+  /* Set length. */
+  length = stream_get_endp (s);
+  lsah->length = htons (length);
+
+  /* Now, create an OSPF LSA instance. */
+  if ((new = ospf_lsa_new ()) == NULL)
+    {
+      zlog_warn ("ospf_router_info_lsa_new: ospf_lsa_new() ?");
+      stream_free (s);
+      goto out;
+    }
+  if ((new->data = ospf_lsa_data_new (length)) == NULL)
+    {
+      zlog_warn ("ospf_router_info_lsa_new: ospf_lsa_data_new() ?");
+      ospf_lsa_unlock (&new);
+      new = NULL;
+      stream_free (s);
+      goto out;
+    }
+
+  new->area = OspfRI.area;      /* Area must be null if the Opaque type is AS scope, fulfill otherwise */
+
+  SET_FLAG (new->flags, OSPF_LSA_SELF);
+  memcpy (new->data, lsah, length);
+  stream_free (s);
+
+out:return new;
+}
+
+static int
+ospf_router_info_lsa_originate1 (void *arg)
+{
+  struct ospf_lsa *new;
+  struct ospf *top;
+  struct ospf_area *area;
+  int rc = -1;
+
+  /* First check if the area is known if flooding scope is Area */
+  if (OspfRI.scope == OSPF_OPAQUE_AREA_LSA)
+    {
+      area = (struct ospf_area *) arg;
+      if (area->area_id.s_addr != OspfRI.area_id.s_addr)
+        {
+          zlog_debug
+            ("RI -> This is not the Router Information Area. Stop processing");
+          goto out;
+        }
+      OspfRI.area = area;
+    }
+
+  /* Create new Opaque-LSA/ROUTER INFORMATION instance. */
+  if ((new = ospf_router_info_lsa_new ()) == NULL)
+    {
+      zlog_warn
+        ("ospf_router_info_lsa_originate1: ospf_router_info_lsa_new() ?");
+      goto out;
+    }
+
+  /* Get ospf info */
+  top = ospf_lookup ();
+
+  /* Install this LSA into LSDB. */
+  if (ospf_lsa_install (top, NULL /*oi */ , new) == NULL)
+    {
+      zlog_warn ("ospf_router_info_lsa_originate1: ospf_lsa_install() ?");
+      ospf_lsa_unlock (&new);
+      goto out;
+    }
+
+  /* Now this Router Info parameter entry has associated LSA. */
+  SET_FLAG (OspfRI.flags, RIFLG_LSA_ENGAGED);
+
+  /* Update new LSA origination count. */
+  top->lsa_originate_count++;
+
+  /* Flood new LSA through AS. */
+  if (OspfRI.scope == OSPF_OPAQUE_AS_LSA)
+    ospf_flood_through_as (top, NULL /*nbr */ , new);
+  else
+    ospf_flood_through_area (OspfRI.area, NULL /*nbr */ , new);
+
+  if (IS_DEBUG_OSPF (lsa, LSA_GENERATE))
+    {
+      zlog_debug ("LSA[Type%d:%s]: Originate Opaque-LSA/ROUTER INFORMATION",
+                  new->data->type, inet_ntoa (new->data->id));
+      ospf_lsa_header_dump (new->data);
+    }
+
+  rc = 0;
+out:return rc;
+}
+
+static int
+ospf_router_info_lsa_originate (void *arg)
+{
+
+  int rc = -1;
+
+  if (OspfRI.status == disabled)
+    {
+      zlog_info
+        ("ospf_router_info_lsa_originate: ROUTER INFORMATION is disabled now.");
+      rc = 0;                   /* This is not an error case. */
+      goto out;
+    }
+
+  /* Check if Router Information LSA is already engaged */
+  if (OspfRI.flags & RIFLG_LSA_ENGAGED)
+    {
+      if (OspfRI.flags & RIFLG_LSA_FORCED_REFRESH)
+        {
+          OspfRI.flags &= ~RIFLG_LSA_FORCED_REFRESH;
+          ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+        }
+    }
+  else
+    {
+      if (!is_mandated_params_set (OspfRI))
+        zlog_warn
+          ("ospf_router_info_lsa_originate: lacks mandated ROUTER INFORMATION parameters");
+
+      /* Ok, let's try to originate an LSA */
+      if (ospf_router_info_lsa_originate1 (arg) != 0)
+        goto out;
+    }
+
+  rc = 0;
+out:return rc;
+}
+
+static struct ospf_lsa *
+ospf_router_info_lsa_refresh (struct ospf_lsa *lsa)
+{
+  struct ospf_lsa *new = NULL;
+  struct ospf *top;
+
+  if (OspfRI.status == disabled)
+    {
+      /*
+       * This LSA must have flushed before due to ROUTER INFORMATION status change.
+       * It seems a slip among routers in the routing domain.
+       */
+      zlog_info
+        ("ospf_router_info_lsa_refresh: ROUTER INFORMATION is disabled now.");
+      lsa->data->ls_age = htons (OSPF_LSA_MAXAGE);      /* Flush it anyway. */
+    }
+
+  /* Verify that the Router Information ID is supported */
+  if (GET_OPAQUE_ID (ntohl (lsa->data->id.s_addr)) != 0)
+    {
+      zlog_warn
+        ("ospf_router_info_lsa_refresh: Unsupported Router Information ID");
+      goto out;
+    }
+
+  /* If the lsa's age reached to MaxAge, start flushing procedure. */
+  if (IS_LSA_MAXAGE (lsa))
+    {
+      OspfRI.flags &= ~RIFLG_LSA_ENGAGED;
+      ospf_opaque_lsa_flush_schedule (lsa);
+      goto out;
+    }
+
+  /* Create new Opaque-LSA/ROUTER INFORMATION instance. */
+  if ((new = ospf_router_info_lsa_new ()) == NULL)
+    {
+      zlog_warn
+        ("ospf_router_info_lsa_refresh: ospf_router_info_lsa_new() ?");
+      goto out;
+    }
+  new->data->ls_seqnum = lsa_seqnum_increment (lsa);
+
+  /* Install this LSA into LSDB. */
+  /* Given "lsa" will be freed in the next function. */
+  top = ospf_lookup ();
+  if (ospf_lsa_install (top, NULL /*oi */ , new) == NULL)
+    {
+      zlog_warn ("ospf_router_info_lsa_refresh: ospf_lsa_install() ?");
+      ospf_lsa_unlock (&new);
+      goto out;
+    }
+
+  /* Flood updated LSA through AS or AREA depending of OspfRI.scope. */
+  if (OspfRI.scope == OSPF_OPAQUE_AS_LSA)
+    ospf_flood_through_as (top, NULL /*nbr */ , new);
+  else
+    ospf_flood_through_area (OspfRI.area, NULL /*nbr */ , new);
+
+  /* Debug logging. */
+  if (IS_DEBUG_OSPF (lsa, LSA_GENERATE))
+    {
+      zlog_debug ("LSA[Type%d:%s]: Refresh Opaque-LSA/ROUTER INFORMATION",
+                  new->data->type, inet_ntoa (new->data->id));
+      ospf_lsa_header_dump (new->data);
+    }
+
+out:return new;
+}
+
+static void
+ospf_router_info_lsa_schedule (opcode_t opcode)
+{
+  struct ospf_lsa lsa;
+  struct lsa_header lsah;
+  struct ospf *top;
+  u_int32_t tmp;
+
+  memset (&lsa, 0, sizeof (lsa));
+  memset (&lsah, 0, sizeof (lsah));
+
+  zlog_debug ("RI-> LSA schedule %s%s%s",
+              opcode == REORIGINATE_THIS_LSA ? "Re-Originate" : "",
+              opcode == REFRESH_THIS_LSA ? "Refresh" : "",
+              opcode == FLUSH_THIS_LSA ? "Flush" : "");
+
+  top = ospf_lookup ();
+  if ((OspfRI.scope == OSPF_OPAQUE_AREA_LSA) && (OspfRI.area == NULL))
+    {
+      zlog_warn
+        ("ospf_router_info_lsa_schedule(): Router Info is Area scope flooding but area is not set");
+      OspfRI.area = ospf_area_lookup_by_area_id (top, OspfRI.area_id);
+    }
+  lsa.area = OspfRI.area;
+  lsa.data = &lsah;
+  lsah.type = OspfRI.scope;
+
+  /* LSA ID is set to 0 for the Router Information. See RFC 4970 */
+  tmp = SET_OPAQUE_LSID (OPAQUE_TYPE_ROUTER_INFORMATION_LSA, 0);
+  lsah.id.s_addr = htonl (tmp);
+
+  switch (opcode)
+    {
+    case REORIGINATE_THIS_LSA:
+      if (OspfRI.scope == OSPF_OPAQUE_AREA_LSA)
+        ospf_opaque_lsa_reoriginate_schedule ((void *) OspfRI.area,
+                                              OSPF_OPAQUE_AREA_LSA,
+                                              OPAQUE_TYPE_ROUTER_INFORMATION_LSA);
+      else
+        ospf_opaque_lsa_reoriginate_schedule ((void *) top,
+                                              OSPF_OPAQUE_AS_LSA,
+                                              OPAQUE_TYPE_ROUTER_INFORMATION_LSA);
+      break;
+    case REFRESH_THIS_LSA:
+      ospf_opaque_lsa_refresh_schedule (&lsa);
+      break;
+    case FLUSH_THIS_LSA:
+      OspfRI.flags &= ~RIFLG_LSA_ENGAGED;
+      ospf_opaque_lsa_flush_schedule (&lsa);
+      break;
+    default:
+      zlog_warn ("ospf_router_info_lsa_schedule: Unknown opcode (%u)",
+                 opcode);
+      break;
+    }
+
+  return;
+}
+
+/*------------------------------------------------------------------------*
+ * Followings are vty session control functions.
+ *------------------------------------------------------------------------*/
+
+static u_int16_t
+show_vty_router_cap (struct vty *vty, struct ri_tlv_header *tlvh)
+{
+  struct ri_tlv_router_cap *top = (struct ri_tlv_router_cap *) tlvh;
+
+  if (vty != NULL)
+    vty_out (vty, "  Router Capabilities: 0x%x%s", ntohl (top->value),
+             VTY_NEWLINE);
+  else
+    zlog_debug ("    Router Capabilities: 0x%x", ntohl (top->value));
+
+  return RI_TLV_SIZE (tlvh);
+}
+
+static u_int16_t
+show_vty_pce_subtlv_address (struct vty *vty, struct ri_tlv_header *tlvh)
+{
+  struct ri_pce_subtlv_address *top = (struct ri_pce_subtlv_address *) tlvh;
+
+  if (ntohs (top->address.type) == PCE_ADDRESS_TYPE_IPV4)
+    {
+      if (vty != NULL)
+        vty_out (vty, "  PCE Address: %s%s", inet_ntoa (top->address.value),
+                 VTY_NEWLINE);
+      else
+        zlog_debug ("    PCE Address: %s", inet_ntoa (top->address.value));
+    }
+  else
+    {
+      /* TODO: Add support to IPv6 with inet_ntop() */
+      if (vty != NULL)
+        vty_out (vty, "  PCE Address: 0x%x%s",
+                 ntohl (top->address.value.s_addr), VTY_NEWLINE);
+      else
+        zlog_debug ("    PCE Address: 0x%x",
+                    ntohl (top->address.value.s_addr));
+    }
+
+  return RI_TLV_SIZE (tlvh);
+}
+
+static u_int16_t
+show_vty_pce_subtlv_path_scope (struct vty *vty, struct ri_tlv_header *tlvh)
+{
+  struct ri_pce_subtlv_path_scope *top =
+    (struct ri_pce_subtlv_path_scope *) tlvh;
+
+  if (vty != NULL)
+    vty_out (vty, "  PCE Path Scope: 0x%x%s", ntohl (top->value),
+             VTY_NEWLINE);
+  else
+    zlog_debug ("    PCE Path Scope: 0x%x", ntohl (top->value));
+
+  return RI_TLV_SIZE (tlvh);
+}
+
+static u_int16_t
+show_vty_pce_subtlv_domain (struct vty *vty, struct ri_tlv_header *tlvh)
+{
+  struct ri_pce_subtlv_domain *top = (struct ri_pce_subtlv_domain *) tlvh;
+  struct in_addr tmp;
+
+  if (ntohs (top->type) == PCE_DOMAIN_TYPE_AREA)
+    {
+      tmp.s_addr = top->value;
+      if (vty != NULL)
+        vty_out (vty, "  PCE domain Area: %s%s", inet_ntoa (tmp),
+                 VTY_NEWLINE);
+      else
+        zlog_debug ("    PCE domain Area: %s", inet_ntoa (tmp));
+    }
+  else
+    {
+      if (vty != NULL)
+        vty_out (vty, "  PCE domain AS: %d%s", ntohl (top->value),
+                 VTY_NEWLINE);
+      else
+        zlog_debug ("    PCE domain AS: %d", ntohl (top->value));
+    }
+  return RI_TLV_SIZE (tlvh);
+}
+
+static u_int16_t
+show_vty_pce_subtlv_neighbor (struct vty *vty, struct ri_tlv_header *tlvh)
+{
+
+  struct ri_pce_subtlv_neighbor *top = (struct ri_pce_subtlv_neighbor *) tlvh;
+  struct in_addr tmp;
+
+  if (ntohs (top->type) == PCE_DOMAIN_TYPE_AREA)
+    {
+      tmp.s_addr = top->value;
+      if (vty != NULL)
+        vty_out (vty, "  PCE neighbor Area: %s%s", inet_ntoa (tmp),
+                 VTY_NEWLINE);
+      else
+        zlog_debug ("    PCE neighbor Area: %s", inet_ntoa (tmp));
+    }
+  else
+    {
+      if (vty != NULL)
+        vty_out (vty, "  PCE neighbor AS: %d%s", ntohl (top->value),
+                 VTY_NEWLINE);
+      else
+        zlog_debug ("    PCE neighbor AS: %d", ntohl (top->value));
+    }
+  return RI_TLV_SIZE (tlvh);
+}
+
+static u_int16_t
+show_vty_pce_subtlv_cap_flag (struct vty *vty, struct ri_tlv_header *tlvh)
+{
+  struct ri_pce_subtlv_cap_flag *top = (struct ri_pce_subtlv_cap_flag *) tlvh;
+
+  if (vty != NULL)
+    vty_out (vty, "  PCE Capabilities Flag: 0x%x%s", ntohl (top->value),
+             VTY_NEWLINE);
+  else
+    zlog_debug ("    PCE Capabilities Flag: 0x%x", ntohl (top->value));
+
+  return RI_TLV_SIZE (tlvh);
+}
+
+static u_int16_t
+show_vty_unknown_tlv (struct vty *vty, struct ri_tlv_header *tlvh)
+{
+  if (vty != NULL)
+    vty_out (vty, "  Unknown TLV: [type(0x%x), length(0x%x)]%s",
+             ntohs (tlvh->type), ntohs (tlvh->length), VTY_NEWLINE);
+  else
+    zlog_debug ("    Unknown TLV: [type(0x%x), length(0x%x)]",
+                ntohs (tlvh->type), ntohs (tlvh->length));
+
+  return RI_TLV_SIZE (tlvh);
+}
+
+static u_int16_t
+show_vty_pce_info (struct vty *vty, struct ri_tlv_header *ri, uint32_t total)
+{
+  struct ri_tlv_header *tlvh;
+  u_int16_t sum = 0;
+
+  for (tlvh = ri; sum < total; tlvh = RI_TLV_HDR_NEXT (tlvh))
+    {
+      switch (ntohs (tlvh->type))
+        {
+        case RI_PCE_SUBTLV_ADDRESS:
+          sum += show_vty_pce_subtlv_address (vty, tlvh);
+          break;
+        case RI_PCE_SUBTLV_PATH_SCOPE:
+          sum += show_vty_pce_subtlv_path_scope (vty, tlvh);
+          break;
+        case RI_PCE_SUBTLV_DOMAIN:
+          sum += show_vty_pce_subtlv_domain (vty, tlvh);
+          break;
+        case RI_PCE_SUBTLV_NEIGHBOR:
+          sum += show_vty_pce_subtlv_neighbor (vty, tlvh);
+          break;
+        case RI_PCE_SUBTLV_CAP_FLAG:
+          sum += show_vty_pce_subtlv_cap_flag (vty, tlvh);
+          break;
+        default:
+          sum += show_vty_unknown_tlv (vty, tlvh);
+          break;
+        }
+    }
+  return sum;
+}
+
+static void
+ospf_router_info_show_info (struct vty *vty, struct ospf_lsa *lsa)
+{
+  struct lsa_header *lsah = (struct lsa_header *) lsa->data;
+  struct ri_tlv_header *tlvh;
+  u_int16_t length = 0, sum = 0;
+
+  /* Initialize TLV browsing */
+  length = ntohs (lsah->length) - OSPF_LSA_HEADER_SIZE;
+
+  for (tlvh = RI_TLV_HDR_TOP (lsah); sum < length;
+       tlvh = RI_TLV_HDR_NEXT (tlvh))
+    {
+      switch (ntohs (tlvh->type))
+        {
+        case RI_TLV_CAPABILITIES:
+          sum += show_vty_router_cap (vty, tlvh);
+          break;
+        case RI_TLV_PCE:
+          tlvh++;
+          sum += RI_TLV_HDR_SIZE;
+          sum += show_vty_pce_info (vty, tlvh, length - sum);
+          break;
+        default:
+          sum += show_vty_unknown_tlv (vty, tlvh);
+          break;
+        }
+    }
+
+  return;
+}
+
+static void
+ospf_router_info_config_write_router (struct vty *vty)
+{
+  struct ospf_pce_info *pce = &OspfRI.pce_info;
+  struct listnode *node;
+  struct ri_pce_subtlv_domain *domain;
+  struct ri_pce_subtlv_neighbor *neighbor;
+  struct in_addr tmp;
+
+  if (OspfRI.status == enabled)
+    {
+      if (OspfRI.scope == OSPF_OPAQUE_AS_LSA)
+        vty_out (vty, " router-info as%s", VTY_NEWLINE);
+      else
+        vty_out (vty, " router-info area %s%s", inet_ntoa (OspfRI.area_id),
+                 VTY_NEWLINE);
+
+      if (pce->pce_address.header.type != 0)
+        vty_out (vty, "  pce address %s%s",
+                 inet_ntoa (pce->pce_address.address.value), VTY_NEWLINE);
+
+      if (pce->pce_cap_flag.header.type != 0)
+        vty_out (vty, "  pce flag 0x%x%s", ntohl (pce->pce_cap_flag.value),
+                 VTY_NEWLINE);
+
+      for (ALL_LIST_ELEMENTS_RO (pce->pce_domain, node, domain))
+        {
+          if (domain->header.type != 0)
+            {
+              if (domain->type == PCE_DOMAIN_TYPE_AREA)
+                {
+                  tmp.s_addr = domain->value;
+                  vty_out (vty, "  pce domain area %s%s", inet_ntoa (tmp),
+                           VTY_NEWLINE);
+                }
+              else
+                {
+                  vty_out (vty, "  pce domain as %d%s", ntohl (domain->value),
+                           VTY_NEWLINE);
+                }
+            }
+        }
+
+      for (ALL_LIST_ELEMENTS_RO (pce->pce_neighbor, node, neighbor))
+        {
+          if (neighbor->header.type != 0)
+            {
+              if (neighbor->type == PCE_DOMAIN_TYPE_AREA)
+                {
+                  tmp.s_addr = neighbor->value;
+                  vty_out (vty, "  pce neighbor area %s%s", inet_ntoa (tmp),
+                           VTY_NEWLINE);
+                }
+              else
+                {
+                  vty_out (vty, "  pce neighbor as %d%s",
+                           ntohl (neighbor->value), VTY_NEWLINE);
+                }
+            }
+        }
+
+      if (pce->pce_scope.header.type != 0)
+        vty_out (vty, "  pce scope 0x%x%s",
+                 ntohl (OspfRI.pce_info.pce_scope.value), VTY_NEWLINE);
+    }
+  return;
+}
+
+/*------------------------------------------------------------------------*
+ * Followings are vty command functions.
+ *------------------------------------------------------------------------*/
+
+DEFUN (router_info,
+       router_info_area_cmd,
+       "router-info area A.B.C.D",
+       OSPF_RI_STR
+       "Enable the Router Information functionality with Area flooding scope\n"
+       "OSPF area ID in IP format")
+{
+
+  u_int8_t scope;
+
+  if (OspfRI.status == enabled)
+    return CMD_SUCCESS;
+
+  /* Check and get Area value if present */
+  if (argc == 1)
+    {
+      if (!inet_aton (argv[0], &OspfRI.area_id))
+        {
+          vty_out (vty, "Please specify Router Info Area by A.B.C.D%s",
+                   VTY_NEWLINE);
+          return CMD_WARNING;
+        }
+      scope = OSPF_OPAQUE_AREA_LSA;
+    }
+  else
+    {
+      OspfRI.area_id.s_addr = 0;
+      scope = OSPF_OPAQUE_AS_LSA;
+    }
+
+  /* First start to register Router Information callbacks */
+  if ((ospf_router_info_register (scope)) != 0)
+    {
+      zlog_warn ("Enable to register Router Information callbacks. Abort!");
+      return CMD_WARNING;
+    }
+
+  OspfRI.status = enabled;
+
+  if (IS_DEBUG_OSPF_EVENT)
+    zlog_debug ("RI-> Router Information (%s flooding): OFF -> ON",
+                 OspfRI.scope == OSPF_OPAQUE_AREA_LSA ? "Area" : "AS");
+
+  /*
+   * Following code is intended to handle two cases;
+   *
+   * 1) Router Information was disabled at startup time, but now become enabled.
+   * 2) Router Information was once enabled then disabled, and now enabled again.
+   */
+
+  initialize_params (&OspfRI);
+
+  /* Refresh RI LSA if already engaged */
+  if (OspfRI.flags & RIFLG_LSA_ENGAGED)
+    {
+      zlog_debug ("RI-> Initial origination following configuration");
+      ospf_router_info_lsa_schedule (REORIGINATE_THIS_LSA);
+    }
+  return CMD_SUCCESS;
+
+}
+
+ALIAS (router_info,
+       router_info_as_cmd,
+       "router-info as",
+       OSPF_RI_STR
+       "Enable the Router Information functionality with AS flooding scope\n")
+
+DEFUN (no_router_info,
+       no_router_info_cmd,
+       "no router-info",
+       NO_STR
+       "Disable the Router Information functionality\n")
+{
+
+  if (OspfRI.status == disabled)
+    return CMD_SUCCESS;
+
+  if (IS_DEBUG_OSPF_EVENT)
+    zlog_debug ("RI-> Router Information: ON -> OFF");
+
+  if (OspfRI.flags & RIFLG_LSA_ENGAGED)
+    ospf_router_info_lsa_schedule (FLUSH_THIS_LSA);
+
+  /* Unregister the callbacks */
+  ospf_router_info_unregister ();
+
+  OspfRI.status = disabled;
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (pce_address,
+       pce_address_cmd,
+       "pce address A.B.C.D",
+       PCE_STR
+       "Stable IP address of the PCE\n"
+       "PCE address in IPv4 address format\n")
+{
+  struct in_addr value;
+  struct ospf_pce_info *pi = &OspfRI.pce_info;
+
+  if (!inet_aton (argv[0], &value))
+    {
+      vty_out (vty, "Please specify PCE Address by A.B.C.D%s", VTY_NEWLINE);
+      return CMD_WARNING;
+    }
+
+  if (ntohs (pi->pce_address.header.type) == 0
+      || ntohl (pi->pce_address.address.value.s_addr) != ntohl (value.s_addr))
+    {
+
+      set_pce_address (value, pi);
+
+      /* Refresh RI LSA if already engaged */
+      if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+        ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+    }
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_pce_address,
+       no_pce_address_cmd,
+       "no pce address",
+       NO_STR
+       PCE_STR
+       "Disable PCE address\n")
+{
+
+  unset_param (&OspfRI.pce_info.pce_address.header);
+
+  /* Refresh RI LSA if already engaged */
+  if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+    ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (pce_path_scope,
+       pce_path_scope_cmd,
+       "pce scope BITPATTERN",
+       PCE_STR
+       "Path scope visibilities of the PCE for path computation\n"
+       "32-bit Hexadecimal value\n")
+{
+  uint32_t scope;
+  struct ospf_pce_info *pi = &OspfRI.pce_info;
+
+  if (sscanf (argv[0], "0x%x", &scope) != 1)
+    {
+      vty_out (vty, "pce_path_scope: fscanf: %s%s", safe_strerror (errno),
+               VTY_NEWLINE);
+      return CMD_WARNING;
+    }
+
+  if (ntohl (pi->pce_scope.header.type) == 0 || scope != pi->pce_scope.value)
+    {
+      set_pce_path_scope (scope, pi);
+
+      /* Refresh RI LSA if already engaged */
+      if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+        ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+    }
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_pce_path_scope,
+       no_pce_path_scope_cmd,
+       "no pce scope",
+       NO_STR
+       PCE_STR
+       "Disable PCE path scope\n")
+{
+
+  unset_param (&OspfRI.pce_info.pce_address.header);
+
+  /* Refresh RI LSA if already engaged */
+  if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+    ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (pce_domain,
+       pce_domain_cmd,
+       "pce domain as <0-65535>",
+       PCE_STR
+       "Configure PCE domain AS number\n"
+       "AS number where the PCE as visibilities for path computation\n"
+       "AS number in decimal <0-65535>\n")
+{
+
+  uint32_t as;
+  struct ospf_pce_info *pce = &OspfRI.pce_info;
+  struct listnode *node;
+  struct ri_pce_subtlv_domain *domain;
+
+  if (sscanf (argv[0], "%d", &as) != 1)
+    {
+      vty_out (vty, "pce_domain: fscanf: %s%s", safe_strerror (errno),
+               VTY_NEWLINE);
+      return CMD_WARNING;
+    }
+
+  /* Check if the domain is not already in the domain list */
+  for (ALL_LIST_ELEMENTS_RO (pce->pce_domain, node, domain))
+    {
+      if (ntohl (domain->header.type) == 0 && as == domain->value)
+        goto out;
+    }
+
+  /* Create new domain if not found */
+  set_pce_domain (PCE_DOMAIN_TYPE_AS, as, pce);
+
+  /* Refresh RI LSA if already engaged */
+  if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+    ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+
+out:return CMD_SUCCESS;
+}
+
+DEFUN (no_pce_domain,
+       no_pce_domain_cmd,
+       "no pce domain as <0-65535>",
+       NO_STR
+       PCE_STR
+       "Disable PCE domain AS number\n"
+       "AS number where the PCE as visibilities for path computation\n"
+       "AS number in decimal <0-65535>\n")
+{
+
+  uint32_t as;
+  struct ospf_pce_info *pce = &OspfRI.pce_info;
+
+  if (sscanf (argv[0], "%d", &as) != 1)
+    {
+      vty_out (vty, "no_pce_domain: fscanf: %s%s", safe_strerror (errno),
+               VTY_NEWLINE);
+      return CMD_WARNING;
+    }
+
+  /* Unset corresponding PCE domain */
+  unset_pce_domain (PCE_DOMAIN_TYPE_AS, as, pce);
+
+  /* Refresh RI LSA if already engaged */
+  if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+    ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (pce_neigbhor,
+       pce_neighbor_cmd,
+       "pce neighbor as <0-65535>",
+       PCE_STR
+       "Configure PCE neighbor domain AS number\n"
+       "AS number of PCE neighbors\n"
+       "AS number in decimal <0-65535>\n")
+{
+
+  uint32_t as;
+  struct ospf_pce_info *pce = &OspfRI.pce_info;
+  struct listnode *node;
+  struct ri_pce_subtlv_neighbor *neighbor;
+
+  if (sscanf (argv[0], "%d", &as) != 1)
+    {
+      vty_out (vty, "pce_neighbor: fscanf: %s%s", safe_strerror (errno),
+               VTY_NEWLINE);
+      return CMD_WARNING;
+    }
+
+  /* Check if the domain is not already in the domain list */
+  for (ALL_LIST_ELEMENTS_RO (pce->pce_neighbor, node, neighbor))
+    {
+      if (ntohl (neighbor->header.type) == 0 && as == neighbor->value)
+        goto out;
+    }
+
+  /* Create new domain if not found */
+  set_pce_neighbor (PCE_DOMAIN_TYPE_AS, as, pce);
+
+  /* Refresh RI LSA if already engaged */
+  if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+    ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+
+out:return CMD_SUCCESS;
+}
+
+DEFUN (no_pce_neighbor,
+       no_pce_neighbor_cmd,
+       "no pce neighbor as <0-65535>",
+       NO_STR
+       PCE_STR
+       "Disable PCE neighbor AS number\n"
+       "AS number of PCE neighbor\n"
+       "AS number in decimal <0-65535>\n")
+{
+
+  uint32_t as;
+  struct ospf_pce_info *pce = &OspfRI.pce_info;
+
+  if (sscanf (argv[0], "%d", &as) != 1)
+    {
+      vty_out (vty, "no_pce_neighbor: fscanf: %s%s", safe_strerror (errno),
+               VTY_NEWLINE);
+      return CMD_WARNING;
+    }
+
+  /* Unset corresponding PCE domain */
+  unset_pce_neighbor (PCE_DOMAIN_TYPE_AS, as, pce);
+
+  /* Refresh RI LSA if already engaged */
+  if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+    ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (pce_cap_flag,
+       pce_cap_flag_cmd,
+       "pce flag BITPATTERN",
+       PCE_STR
+       "Capabilities of the PCE for path computation\n"
+       "32-bit Hexadecimal value\n")
+{
+
+  uint32_t cap;
+  struct ospf_pce_info *pce = &OspfRI.pce_info;
+
+  if (sscanf (argv[0], "0x%x", &cap) != 1)
+    {
+      vty_out (vty, "pce_cap_flag: fscanf: %s%s", safe_strerror (errno),
+               VTY_NEWLINE);
+      return CMD_WARNING;
+    }
+
+  if (ntohl (pce->pce_cap_flag.header.type) == 0
+      || cap != pce->pce_cap_flag.value)
+    {
+      set_pce_cap_flag (cap, pce);
+
+      /* Refresh RI LSA if already engaged */
+      if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+        ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+    }
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_pce_cap_flag,
+       no_pce_cap_flag_cmd,
+       "no pce flag",
+       NO_STR
+       PCE_STR
+       "Disable PCE capabilities\n")
+{
+
+  unset_param (&OspfRI.pce_info.pce_cap_flag.header);
+
+  /* Refresh RI LSA if already engaged */
+  if ((OspfRI.status == enabled) && (OspfRI.flags & RIFLG_LSA_ENGAGED))
+    ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (show_ip_ospf_router_info,
+       show_ip_ospf_router_info_cmd,
+       "show ip ospf router-info",
+       SHOW_STR
+       IP_STR
+       OSPF_STR
+       "Router Information\n")
+{
+
+  if (OspfRI.status == enabled)
+    {
+      vty_out (vty, "--- Router Information parameters ---%s", VTY_NEWLINE);
+      show_vty_router_cap (vty, &OspfRI.router_cap.header);
+    }
+  else
+    {
+      if (vty != NULL)
+        vty_out (vty, "  Router Information is disabled on this router%s", VTY_NEWLINE);
+    }
+  return CMD_SUCCESS;
+}
+
+DEFUN (show_ip_opsf_router_info_pce,
+       show_ip_ospf_router_info_pce_cmd,
+       "show ip ospf router-info pce",
+       SHOW_STR
+       IP_STR
+       OSPF_STR
+       "Router Information\n"
+       "PCE information\n")
+{
+
+  struct ospf_pce_info *pce = &OspfRI.pce_info;
+  struct listnode *node;
+  struct ri_pce_subtlv_domain *domain;
+  struct ri_pce_subtlv_neighbor *neighbor;
+
+  if (OspfRI.status == enabled)
+    {
+      vty_out (vty, "--- PCE parameters ---%s", VTY_NEWLINE);
+
+      if (pce->pce_address.header.type != 0)
+        show_vty_pce_subtlv_address (vty, &pce->pce_address.header);
+
+      if (pce->pce_scope.header.type != 0)
+        show_vty_pce_subtlv_path_scope (vty, &pce->pce_scope.header);
+
+      for (ALL_LIST_ELEMENTS_RO (pce->pce_domain, node, domain))
+        {
+          if (domain->header.type != 0)
+            show_vty_pce_subtlv_domain (vty, &domain->header);
+        }
+
+      for (ALL_LIST_ELEMENTS_RO (pce->pce_neighbor, node, neighbor))
+        {
+          if (neighbor->header.type != 0)
+            show_vty_pce_subtlv_neighbor (vty, &neighbor->header);
+        }
+
+      if (pce->pce_cap_flag.header.type != 0)
+        show_vty_pce_subtlv_cap_flag (vty, &pce->pce_cap_flag.header);
+
+    }
+  else
+    {
+      vty_out (vty, "  Router Information is disabled on this router%s",
+               VTY_NEWLINE);
+    }
+
+  return CMD_SUCCESS;
+}
+
+/* Install new CLI commands */
+static void
+ospf_router_info_register_vty (void)
+{
+  install_element (VIEW_NODE, &show_ip_ospf_router_info_cmd);
+  install_element (VIEW_NODE, &show_ip_ospf_router_info_pce_cmd);
+  install_element (ENABLE_NODE, &show_ip_ospf_router_info_cmd);
+  install_element (ENABLE_NODE, &show_ip_ospf_router_info_pce_cmd);
+
+  install_element (OSPF_NODE, &router_info_area_cmd);
+  install_element (OSPF_NODE, &router_info_as_cmd);
+  install_element (OSPF_NODE, &no_router_info_cmd);
+  install_element (OSPF_NODE, &pce_address_cmd);
+  install_element (OSPF_NODE, &pce_path_scope_cmd);
+  install_element (OSPF_NODE, &pce_domain_cmd);
+  install_element (OSPF_NODE, &no_pce_domain_cmd);
+  install_element (OSPF_NODE, &pce_neighbor_cmd);
+  install_element (OSPF_NODE, &no_pce_neighbor_cmd);
+  install_element (OSPF_NODE, &pce_cap_flag_cmd);
+
+  return;
+}