There can now be multiple adj with the same LDP speaker. The

[mpls-ldp-portable.git] / zebra-ldp.diff

diff --exclude=CVS -uNr zebra/bgpd/bgpd.c zebra-ldp/bgpd/bgpd.c
--- zebra/bgpd/bgpd.c   2003-03-14 08:44:35.000000000 -0600
+++ zebra-ldp/bgpd/bgpd.c       2003-02-26 22:34:02.000000000 -0600
@@ -63,6 +63,8 @@
 /* BGP process wide configuration.  */
 static struct bgp_master bgp_master;
 
+extern struct in_addr router_id_zebra;
+
 /* BGP process wide configuration pointer to export.  */
 struct bgp_master *bm;
 
@@ -179,38 +181,6 @@
   return 0;
 }
 
-/* Unset BGP router identifier. */
-int
-bgp_router_id_unset (struct bgp *bgp)
-{
-  struct peer *peer;
-  struct listnode *nn;
-
-  if (! bgp_config_check (bgp, BGP_CONFIG_ROUTER_ID))
-    return 0;
-
-  bgp->router_id.s_addr = 0;
-  bgp_config_unset (bgp, BGP_CONFIG_ROUTER_ID);
-
-  /* Clear peer router id configuration.  */
-  LIST_LOOP (bgp->peer, peer, nn)
-    {
-      peer->local_id.s_addr = 0;
-    }
-
-  /* Set router-id from interface's address. */
-  bgp_if_update_all ();
-
-  /* Reset all BGP sessions to use new router-id.  */
-  LIST_LOOP (bgp->peer, peer, nn)
-    {
-      if (peer->status == Established)
-       bgp_notify_send (peer, BGP_NOTIFY_CEASE,
-                        BGP_NOTIFY_CEASE_CONFIG_CHANGE);
-    }
-
-  return 0;
-}
 \f
 /* BGP's cluster-id control. */
 int
@@ -1728,7 +1698,7 @@
 
   bgp = bgp_create (as, name);
   listnode_add (bm->bgp, bgp);
-  bgp_if_update_all ();
+  bgp_router_id_set(bgp, &router_id_zebra);
   *bgp_val = bgp;
 
   return 0;
diff --exclude=CVS -uNr zebra/bgpd/bgpd.h zebra-ldp/bgpd/bgpd.h
--- zebra/bgpd/bgpd.h   2003-03-14 08:44:35.000000000 -0600
+++ zebra-ldp/bgpd/bgpd.h       2003-02-26 22:34:09.000000000 -0600
@@ -74,6 +74,7 @@
 
   /* BGP router identifier.  */
   struct in_addr router_id;
+  struct in_addr router_id_static;
 
   /* BGP route reflector cluster ID.  */
   struct in_addr cluster_id;
diff --exclude=CVS -uNr zebra/bgpd/bgp_vty.c zebra-ldp/bgpd/bgp_vty.c
--- zebra/bgpd/bgp_vty.c        2003-03-14 08:44:34.000000000 -0600
+++ zebra-ldp/bgpd/bgp_vty.c    2003-02-26 22:33:38.000000000 -0600
@@ -39,6 +39,8 @@
 #include "bgpd/bgp_route.h"
 #include "bgpd/bgp_zebra.h"
 
+extern struct in_addr router_id_zebra;
+
 /* Utility function to get address family from current node.  */
 afi_t
 bgp_node_afi (struct vty *vty)
@@ -398,6 +400,7 @@
       return CMD_WARNING;
     }
 
+  bgp->router_id_static = id;
   bgp_router_id_set (bgp, &id);
 
   return CMD_SUCCESS;
@@ -425,14 +428,15 @@
          return CMD_WARNING;
        }
 
-      if (! IPV4_ADDR_SAME (&bgp->router_id, &id))
+      if (! IPV4_ADDR_SAME (&bgp->router_id_static, &id))
        {
          vty_out (vty, "%% BGP router-id doesn't match%s", VTY_NEWLINE);
          return CMD_WARNING;
        }
     }
 
-  bgp_router_id_unset (bgp);
+  bgp->router_id_static.s_addr = 0;
+  bgp_router_id_set (bgp, &router_id_zebra);
 
   return CMD_SUCCESS;
 }
diff --exclude=CVS -uNr zebra/bgpd/bgp_zebra.c zebra-ldp/bgpd/bgp_zebra.c
--- zebra/bgpd/bgp_zebra.c      2003-03-14 08:44:34.000000000 -0600
+++ zebra-ldp/bgpd/bgp_zebra.c  2003-02-26 15:47:04.000000000 -0600
@@ -39,61 +39,24 @@
 \f
 /* All information about zebra. */
 static struct zclient *zclient = NULL;
+struct in_addr router_id_zebra;
 
-/* Update default router id. */
+/* Router-id update message from zebra. */
 int
-bgp_if_update (struct interface *ifp)
+bgp_router_id_update (int command, struct zclient *zclient, zebra_size_t length)
 {
-  struct bgp *bgp;
-  listnode cn;
+  struct prefix router_id;
   struct listnode *nn;
-  struct listnode *nm;
-  struct peer *peer;
-
-  for (cn = listhead (ifp->connected); cn; nextnode (cn))
-    {
-      struct connected *co;
-      struct in_addr addr;
-
-      co = getdata (cn);
-
-      if (co->address->family == AF_INET)
-       {
-         addr = co->address->u.prefix4;
-
-         /* Ignore NET127. */
-         if (IPV4_NET127 (ntohl (addr.s_addr)))
-           continue;
+  struct bgp *bgp;
 
-         LIST_LOOP (bm->bgp, bgp, nn)
-           {
-             /* Respect configured router id */
-             if (! (bgp->config & BGP_CONFIG_ROUTER_ID))
-               if (ntohl (bgp->router_id.s_addr) < ntohl (addr.s_addr))
-                 {
-                   bgp->router_id = addr;
-                   LIST_LOOP (bgp->peer, peer, nm)
-                     {
-                       peer->local_id = addr;
-                     }
-                 }
-           }
-       }
-    }
-  return 0;
-}
+  zebra_router_id_update_read(zclient->ibuf,&router_id);
+  router_id_zebra = router_id.u.prefix4;
 
-int
-bgp_if_update_all ()
-{
-  listnode node;
-  struct interface *ifp;
+  LIST_LOOP (bm->bgp, bgp, nn) {
+    if (!bgp->router_id_static.s_addr)
+      bgp_router_id_set (bgp, &router_id.u.prefix4);
+  }
 
-  for (node = listhead (iflist); node; node = nextnode (node))
-    {
-      ifp = getdata (node);
-      bgp_if_update (ifp);
-    }
   return 0;
 }
 
@@ -104,7 +67,6 @@
   struct interface *ifp;
 
   ifp = zebra_interface_add_read (zclient->ibuf);
-  bgp_if_update (ifp);
 
   return 0;
 }
@@ -206,8 +168,6 @@
   if (ifc == NULL)
     return 0;
 
-  bgp_if_update (ifc->ifp);
-
   if (if_is_up (ifc->ifp))
     bgp_connected_add (ifc);
 
@@ -225,8 +185,6 @@
   if (ifc == NULL)
     return 0;
 
-  bgp_if_update (ifc->ifp);
-
   if (if_is_up (ifc->ifp))
     bgp_connected_delete (ifc);
 
@@ -983,6 +941,7 @@
   /* Set default values. */
   zclient = zclient_new ();
   zclient_init (zclient, ZEBRA_ROUTE_BGP);
+  zclient->router_id_update = bgp_router_id_update;
   zclient->interface_add = bgp_interface_add;
   zclient->interface_delete = bgp_interface_delete;
   zclient->interface_address_add = bgp_interface_address_add;
diff --exclude=CVS -uNr zebra/config.h.in zebra-ldp/config.h.in
--- zebra/config.h.in   2003-03-14 08:44:35.000000000 -0600
+++ zebra-ldp/config.h.in       2003-03-14 08:42:11.000000000 -0600
@@ -306,6 +306,9 @@
 /* zebra PID */
 #undef PATH_ZEBRA_PID
 
+/* zebra PID */
+#undef PATH_MPLSD_PID
+
 /* Define as the return type of signal handlers (`int' or `void'). */
 #undef RETSIGTYPE
 
diff --exclude=CVS -uNr zebra/configure.ac zebra-ldp/configure.ac
--- zebra/configure.ac  2003-03-14 08:44:36.000000000 -0600
+++ zebra-ldp/configure.ac      2003-03-14 08:37:17.000000000 -0600
@@ -71,6 +71,8 @@
 [  --disable-ospfd         do not build ospfd])
 AC_ARG_ENABLE(ospf6d,
 [  --disable-ospf6d        do not build ospf6d])
+AC_ARG_ENABLE(mplsd,
+[  --disable-mplsd         do not build mplsd])
 AC_ARG_ENABLE(bgp-announce,
 [  --disable-bgp-announce, turn off BGP route announcement])
 AC_ARG_ENABLE(netlink,
@@ -541,6 +543,12 @@
   OSPFD="ospfd"
 fi
 
+if test "${enable_mpsld}" = "no";then
+  MPLSD=""
+else
+  MPLSD="mplsd"
+fi
+
 case "${enable_ripngd}" in
   "yes") RIPNGD="ripngd";;
   "no" ) RIPNGD="";;
@@ -563,6 +571,7 @@
 AC_SUBST(RIPNGD)
 AC_SUBST(OSPFD)
 AC_SUBST(OSPF6D)
+AC_SUBST(MPLSD)
 AC_SUBST(VTYSH)
 AC_SUBST(INCLUDES)
 AC_SUBST(CURSES)
@@ -795,6 +804,7 @@
 AC_DEFINE_UNQUOTED(PATH_BGPD_PID, "$ac_piddir/bgpd.pid")
 AC_DEFINE_UNQUOTED(PATH_OSPFD_PID, "$ac_piddir/ospfd.pid")
 AC_DEFINE_UNQUOTED(PATH_OSPF6D_PID, "$ac_piddir/ospf6d.pid")
+AC_DEFINE_UNQUOTED(PATH_MPLSD_PID, "$ac_piddir/mplsd.pid")
 
 
 dnl ---------------------------
@@ -816,7 +826,7 @@
 ac_cv_htonl_works=no)])
 AC_MSG_RESULT($ac_cv_htonl_works)
 
-AC_OUTPUT(Makefile lib/Makefile zebra/Makefile ripd/Makefile ripngd/Makefile bgpd/Makefile ospfd/Makefile ospf6d/Makefile vtysh/Makefile doc/Makefile)
+AC_OUTPUT(Makefile lib/Makefile zebra/Makefile ripd/Makefile ripngd/Makefile bgpd/Makefile ospfd/Makefile ospf6d/Makefile mplsd/Makefile vtysh/Makefile doc/Makefile)
 
 echo "
 zebra configuration
diff --exclude=CVS -uNr zebra/lib/command.c zebra-ldp/lib/command.c
--- zebra/lib/command.c 2003-03-14 08:44:39.000000000 -0600
+++ zebra-ldp/lib/command.c     2003-02-26 22:35:07.000000000 -0600
@@ -2080,12 +2080,22 @@
     case RIPNG_NODE:
     case OSPF_NODE:
     case OSPF6_NODE:
+    case MPLS_STATIC_NODE:
+    case MPLS_LDP_NODE:
+    case MPLS_IF_NODE:
     case KEYCHAIN_NODE:
     case MASC_NODE:
     case RMAP_NODE:
     case VTY_NODE:
       vty->node = CONFIG_NODE;
       break;
+    case MPLS_IN_INSTR_NODE:
+    case MPLS_OUT_INSTR_NODE:
+      vty->node = MPLS_STATIC_NODE;
+      break;
+    case MPLS_LDP_IF_NODE:
+      vty->node = INTERFACE_NODE;
+      break;
     case BGP_VPNV4_NODE:
     case BGP_IPV4_NODE:
     case BGP_IPV4M_NODE:
@@ -2132,6 +2142,12 @@
     case RMAP_NODE:
     case OSPF_NODE:
     case OSPF6_NODE:
+    case MPLS_IF_NODE:
+    case MPLS_LDP_NODE:
+    case MPLS_LDP_IF_NODE:
+    case MPLS_STATIC_NODE:
+    case MPLS_IN_INSTR_NODE:
+    case MPLS_OUT_INSTR_NODE:
     case KEYCHAIN_NODE:
     case KEYCHAIN_KEY_NODE:
     case MASC_NODE:
diff --exclude=CVS -uNr zebra/lib/command.h zebra-ldp/lib/command.h
--- zebra/lib/command.h 2003-03-14 08:44:39.000000000 -0600
+++ zebra-ldp/lib/command.h     2003-02-26 15:47:28.000000000 -0600
@@ -75,6 +75,12 @@
   AAA_NODE,                    /* AAA node. */
   KEYCHAIN_NODE,               /* Key-chain node. */
   KEYCHAIN_KEY_NODE,           /* Key-chain key node. */
+  MPLS_IF_NODE,                        /* MPLS tunnel interface node */
+  MPLS_LDP_NODE,               /* MPLS LDP protocol node */
+  MPLS_LDP_IF_NODE,            /* MPLS LDP interface node */
+  MPLS_STATIC_NODE,            /* static MPLS protocol mode */
+  MPLS_IN_INSTR_NODE,          /* MPLS in-seg instructions */
+  MPLS_OUT_INSTR_NODE,         /* MPLS out-seg instructions */
   INTERFACE_NODE,              /* Interface mode node. */
   ZEBRA_NODE,                  /* zebra connection node. */
   TABLE_NODE,                  /* rtm_table selection node. */
diff --exclude=CVS -uNr zebra/lib/if.c zebra-ldp/lib/if.c
--- zebra/lib/if.c      2003-03-14 08:44:40.000000000 -0600
+++ zebra-ldp/lib/if.c  2003-02-26 15:47:30.000000000 -0600
@@ -594,6 +594,30 @@
 }
 #endif
 
+struct interface *if_getfirst()
+{
+  listnode node = listhead(iflist);
+  return getdata(node);
+}
+
+struct interface *if_getnext(struct interface *old)
+{
+  struct interface *ifp;
+  listnode node;
+  int flag = 0;
+
+  for (node = listhead(iflist); node; nextnode(node)) {
+    ifp = getdata(node);
+    if (flag) {
+      return ifp;
+    }
+    if (ifp->ifindex == old->ifindex) {
+      flag = 1;
+    }
+  }
+  return NULL;
+}
+
 #ifndef HAVE_IF_INDEXTONAME
 char *
 if_indextoname (unsigned int ifindex, char *name)
diff --exclude=CVS -uNr zebra/lib/if.h zebra-ldp/lib/if.h
--- zebra/lib/if.h      2003-03-14 08:44:40.000000000 -0600
+++ zebra-ldp/lib/if.h  2003-02-26 15:47:30.000000000 -0600
@@ -204,6 +204,9 @@
 struct connected  *connected_delete_by_prefix (struct interface *, struct prefix *);
 int ifc_pointopoint (struct connected *);
 
+struct interface *if_getfirst();
+struct interface *if_getnext(struct interface*);
+
 #ifndef HAVE_IF_NAMETOINDEX
 unsigned int if_nametoindex (const char *);
 #endif
diff --exclude=CVS -uNr zebra/lib/linklist.h zebra-ldp/lib/linklist.h
--- zebra/lib/linklist.h        2003-03-14 08:44:41.000000000 -0600
+++ zebra-ldp/lib/linklist.h    2003-02-26 15:47:31.000000000 -0600
@@ -43,6 +43,7 @@
 
 #define nextnode(X) ((X) = (X)->next)
 #define listhead(X) ((X)->head)
+#define listtail(X) ((X)->tail)
 #define listcount(X) ((X)->count)
 #define list_isempty(X) ((X)->head == NULL && (X)->tail == NULL)
 #define getdata(X) ((X)->data)
diff --exclude=CVS -uNr zebra/lib/log.c zebra-ldp/lib/log.c
--- zebra/lib/log.c     2003-03-14 08:44:41.000000000 -0600
+++ zebra-ldp/lib/log.c 2003-02-26 15:47:31.000000000 -0600
@@ -37,6 +37,7 @@
   "OSPF",
   "RIPNG",
   "OSPF6",
+  "MPLS",
   "MASC",
   NULL,
 };
diff --exclude=CVS -uNr zebra/lib/log.h zebra-ldp/lib/log.h
--- zebra/lib/log.h     2003-03-14 08:44:41.000000000 -0600
+++ zebra-ldp/lib/log.h 2003-02-26 15:47:31.000000000 -0600
@@ -47,6 +47,7 @@
   ZLOG_OSPF,
   ZLOG_RIPNG,  
   ZLOG_OSPF6,
+  ZLOG_MPLS,
   ZLOG_MASC
 } zlog_proto_t;
 
diff --exclude=CVS -uNr zebra/lib/memory.c zebra-ldp/lib/memory.c
--- zebra/lib/memory.c  2003-03-14 08:44:41.000000000 -0600
+++ zebra-ldp/lib/memory.c      2003-02-26 15:47:31.000000000 -0600
@@ -373,6 +373,16 @@
   { -1, NULL },
 };
 
+struct memory_list memory_list_mpls[] =
+{
+  { MTYPE_MPLS_TOP,           "MPLS              " },
+  { MTYPE_MPLS_IF,            "MPLS IF           " },
+  { MTYPE_MPLS_STATIC,        "MPLS static       " },
+  { MTYPE_MPLS_LDP,           "LDP               " },
+  { MTYPE_MPLS_RIB,           "RIB               " },
+  { -1, NULL },
+};
+
 struct memory_list memory_list_separator[] =
 {
   { 0, NULL},
@@ -407,6 +417,7 @@
   show_memory_vty (vty, memory_list_ospf6);
   show_memory_vty (vty, memory_list_separator);
   show_memory_vty (vty, memory_list_bgp);
+  show_memory_vty (vty, memory_list_mpls);
 
   return CMD_SUCCESS;
 }
@@ -450,6 +461,17 @@
   return CMD_SUCCESS;
 }
 
+DEFUN (show_memory_mpls,
+       show_memory_mpls_cmd,
+       "show memory mpls",
+       SHOW_STR
+       "Memory statistics\n"
+       "MPLS memory\n")
+{
+  show_memory_vty (vty, memory_list_mpls);
+  return CMD_SUCCESS;
+}
+
 DEFUN (show_memory_ospf,
        show_memory_ospf_cmd,
        "show memory ospf",
@@ -480,6 +502,7 @@
   install_element (VIEW_NODE, &show_memory_lib_cmd);
   install_element (VIEW_NODE, &show_memory_rip_cmd);
   install_element (VIEW_NODE, &show_memory_bgp_cmd);
+  install_element (VIEW_NODE, &show_memory_mpls_cmd);
   install_element (VIEW_NODE, &show_memory_ospf_cmd);
   install_element (VIEW_NODE, &show_memory_ospf6_cmd);
 
@@ -488,6 +511,7 @@
   install_element (ENABLE_NODE, &show_memory_lib_cmd);
   install_element (ENABLE_NODE, &show_memory_rip_cmd);
   install_element (ENABLE_NODE, &show_memory_bgp_cmd);
+  install_element (ENABLE_NODE, &show_memory_mpls_cmd);
   install_element (ENABLE_NODE, &show_memory_ospf_cmd);
   install_element (ENABLE_NODE, &show_memory_ospf6_cmd);
 }
diff --exclude=CVS -uNr zebra/lib/memory.h zebra-ldp/lib/memory.h
--- zebra/lib/memory.h  2003-03-14 08:44:41.000000000 -0600
+++ zebra-ldp/lib/memory.h      2003-02-26 22:35:13.000000000 -0600
@@ -170,6 +170,12 @@
   MTYPE_COMMUNITY_LIST_ENTRY,
   MTYPE_COMMUNITY_LIST_CONFIG,
 
+  MTYPE_MPLS_TOP,
+  MTYPE_MPLS_IF,
+  MTYPE_MPLS_STATIC,
+  MTYPE_MPLS_LDP,
+  MTYPE_MPLS_RIB,
+
   MTYPE_RIP,
   MTYPE_RIP_INTERFACE,
   MTYPE_RIP_DISTANCE,
diff --exclude=CVS -uNr zebra/lib/table.c zebra-ldp/lib/table.c
--- zebra/lib/table.c   2003-03-14 08:44:46.000000000 -0600
+++ zebra-ldp/lib/table.c       2003-02-26 15:47:40.000000000 -0600
@@ -311,6 +311,36 @@
   return NULL;
 }
 
+struct route_node *
+route_node_lookup2 (struct route_table *table, struct prefix *p)
+{
+  struct route_node *rn_in, *rn_tmp;
+
+  if (!(rn_in = route_node_lookup(table,p))) {
+    /* walk as far down the tree as we can */
+    rn_in = table->top;
+    while (rn_in && rn_in->p.prefixlen <= p->prefixlen &&
+      prefix_match(&rn_in->p, p)) {
+      rn_tmp = rn_in->link[check_bit(&p->u.prefix, rn_in->p.prefixlen)];
+      if (!rn_tmp) {
+        break;
+      }
+      rn_in = rn_tmp;
+    }
+    route_lock_node(rn_in);
+
+    /* rn_in is either the actual node or the furthest node in the tree */
+    /* so get the 'next' one with 'info' */
+    rn_in = route_next2(rn_in);
+  }
+
+  if (rn_in && !rn_in->info) {
+    route_unlock_node(rn_in);
+    rn_in = NULL;
+  }
+  return rn_in;
+}
+
 /* Add node to routing table. */
 struct route_node *
 route_node_get (struct route_table *table, struct prefix *p)
@@ -461,6 +491,22 @@
   return NULL;
 }
 
+struct route_node *
+route_next2 (struct route_node *rn_in)
+{
+  struct route_node *rn = rn_in;
+  struct route_node *rn2;
+  do {
+    rn2 = route_next(rn);
+    rn = rn2;
+  } while(rn && !rn->info);
+
+  if (rn && rn->info) {
+    return rn;
+  }
+  return NULL;
+}
+
 /* Unlock current node and lock next node until limit. */
 struct route_node *
 route_next_until (struct route_node *node, struct route_node *limit)
diff --exclude=CVS -uNr zebra/lib/table.h zebra-ldp/lib/table.h
--- zebra/lib/table.h   2003-03-14 08:44:46.000000000 -0600
+++ zebra-ldp/lib/table.h       2003-02-26 15:47:40.000000000 -0600
@@ -23,6 +23,8 @@
 #ifndef _ZEBRA_TABLE_H
 #define _ZEBRA_TABLE_H
 
+#include "prefix.h"
+
 /* Routing table top structure. */
 struct route_table
 {
@@ -59,9 +61,11 @@
 void route_node_delete (struct route_node *node);
 struct route_node *route_top (struct route_table *);
 struct route_node *route_next (struct route_node *);
+struct route_node *route_next2 (struct route_node *);
 struct route_node *route_next_until (struct route_node *, struct route_node *);
 struct route_node *route_node_get (struct route_table *, struct prefix *);
 struct route_node *route_node_lookup (struct route_table *, struct prefix *);
+struct route_node *route_node_lookup2 (struct route_table *, struct prefix *);
 struct route_node *route_lock_node (struct route_node *node);
 struct route_node *route_node_match (struct route_table *, struct prefix *);
 struct route_node *route_node_match_ipv4 (struct route_table *,
diff --exclude=CVS -uNr zebra/lib/thread.c zebra-ldp/lib/thread.c
--- zebra/lib/thread.c  2003-03-14 08:44:46.000000000 -0600
+++ zebra-ldp/lib/thread.c      2003-02-26 15:47:40.000000000 -0600
@@ -117,10 +117,26 @@
                                           sizeof (struct thread_master));
 }
 
+static int thread_in_list(struct thread_list *list, struct thread *thread)
+{
+  struct thread *tt;
+
+  for (tt = list->head; tt; tt = tt->next)
+  {
+    if (tt == thread)
+    {
+      return 1;
+    }
+  }
+  return 0;
+}
+
 /* Add a new thread to the list.  */
 static void
 thread_list_add (struct thread_list *list, struct thread *thread)
 {
+  assert(!thread_in_list(list,thread));
+
   thread->next = NULL;
   thread->prev = list->tail;
   if (list->tail)
@@ -137,6 +153,8 @@
                        struct thread *point, 
                        struct thread *thread)
 {
+  assert(!thread_in_list(list,thread));
+
   thread->next = point;
   thread->prev = point->prev;
   if (point->prev)
@@ -151,6 +169,8 @@
 static struct thread *
 thread_list_delete (struct thread_list *list, struct thread *thread)
 {
+  assert(thread_in_list(list,thread));
+
   if (thread->next)
     thread->next->prev = thread->prev;
   else
diff --exclude=CVS -uNr zebra/lib/vty.c zebra-ldp/lib/vty.c
--- zebra/lib/vty.c     2003-03-14 08:44:47.000000000 -0600
+++ zebra-ldp/lib/vty.c 2003-02-26 22:35:32.000000000 -0600
@@ -624,6 +624,11 @@
     case RMAP_NODE:
     case OSPF_NODE:
     case OSPF6_NODE:
+    case MPLS_IF_NODE:
+    case MPLS_IN_INSTR_NODE:
+    case MPLS_OUT_INSTR_NODE:
+    case MPLS_STATIC_NODE:
+    case MPLS_LDP_NODE:
     case KEYCHAIN_NODE:
     case KEYCHAIN_KEY_NODE:
     case MASC_NODE:
@@ -1028,6 +1033,11 @@
     case RMAP_NODE:
     case OSPF_NODE:
     case OSPF6_NODE:
+    case MPLS_IF_NODE:
+    case MPLS_IN_INSTR_NODE:
+    case MPLS_OUT_INSTR_NODE:
+    case MPLS_STATIC_NODE:
+    case MPLS_LDP_NODE:
     case KEYCHAIN_NODE:
     case KEYCHAIN_KEY_NODE:
     case MASC_NODE:
diff --exclude=CVS -uNr zebra/lib/zclient.c zebra-ldp/lib/zclient.c
--- zebra/lib/zclient.c 2003-03-14 08:44:47.000000000 -0600
+++ zebra-ldp/lib/zclient.c     2003-02-26 22:35:38.000000000 -0600
@@ -260,6 +260,9 @@
   /* We need interface information. */
   zebra_message_send (zclient, ZEBRA_INTERFACE_ADD);
 
+  /* We need router-id information. */
+  zebra_message_send (zclient, ZEBRA_ROUTER_ID_ADD);
+
   /* Flush all redistribute request. */
   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
     if (i != zclient->redist_default && zclient->redist[i])
@@ -289,6 +292,38 @@
 }
 \f
 int
+zapi_ipv4_set_mplsindex (struct zclient *zclient, struct prefix_ipv4 *p,
+               struct in_addr *nexthop, unsigned int ifindex,
+               unsigned int mplsindex)
+{
+  int psize;
+  struct stream *s;
+
+  /* Reset stream. */
+  s = zclient->obuf;
+  stream_reset (s);
+
+  /* Length place holder. */
+  stream_putw (s, 0);
+
+  /* Put command, type and nexthop. */
+  stream_putc (s, ZEBRA_IPV4_SET_MPLSINDEX);
+
+  /* Put prefix information. */
+  psize = PSIZE (p->prefixlen);
+  stream_putc (s, p->prefixlen);
+  stream_write (s, (u_char *)&p->prefix, psize);
+  stream_put_in_addr (s, nexthop);
+  stream_putl (s, ifindex);
+  stream_putl (s, mplsindex);
+
+  /* Put length at the first point of the stream. */
+  stream_putw_at (s, 0, stream_get_endp (s));
+
+  return writen (zclient->sock, s->data, stream_get_endp (s));
+}
+\f
+int
 zapi_ipv4_add (struct zclient *zclient, struct prefix_ipv4 *p,
               struct zapi_ipv4 *api)
 {
@@ -540,6 +575,20 @@
   return ret;
 }
 
+/* Router-id update from zebra daemon. */
+void
+zebra_router_id_update_read (struct stream *s, struct prefix *rid)
+{
+  int plen;
+
+  /* Fetch interface address. */
+  rid->family = stream_getc (s);
+
+  plen = prefix_blen (rid);
+  stream_get (&rid->u.prefix, s, plen);
+  rid->prefixlen = stream_getc (s);
+}
+
 /* Interface addition from zebra daemon. */
 struct interface *
 zebra_interface_add_read (struct stream *s)
@@ -608,6 +657,19 @@
   return ifp;
 }
 
+void
+zebra_interface_if_set_value (struct stream *s, struct interface *ifp)
+{
+  /* Read interface's index. */
+  ifp->ifindex = stream_getl (s);
+
+  /* Read interface's value. */
+  ifp->flags = stream_getl (s);
+  ifp->metric = stream_getl (s);
+  ifp->mtu = stream_getl (s);
+  ifp->bandwidth = stream_getl (s);
+}
+
 struct connected *
 zebra_interface_address_add_read (struct stream *s)
 {
@@ -772,6 +834,10 @@
 
   switch (command)
     {
+    case ZEBRA_ROUTER_ID_UPDATE:
+      if (zclient->router_id_update)
+       ret = (*zclient->router_id_update) (command, zclient, length);
+      break;
     case ZEBRA_INTERFACE_ADD:
       if (zclient->interface_add)
        ret = (*zclient->interface_add) (command, zclient, length);
diff --exclude=CVS -uNr zebra/lib/zclient.h zebra-ldp/lib/zclient.h
--- zebra/lib/zclient.h 2003-03-14 08:44:47.000000000 -0600
+++ zebra-ldp/lib/zclient.h     2003-02-26 15:47:42.000000000 -0600
@@ -24,6 +24,7 @@
 
 /* For struct interface and struct connected. */
 #include "if.h"
+#include "prefix.h"
 
 /* For input/output buffer to zebra. */
 #define ZEBRA_MAX_PACKET_SIZ          4096
@@ -62,6 +63,7 @@
   u_char default_information;
 
   /* Pointer to the callback functions. */
+  int (*router_id_update) (int, struct zclient *, zebra_size_t);
   int (*interface_add) (int, struct zclient *, zebra_size_t);
   int (*interface_delete) (int, struct zclient *, zebra_size_t);
   int (*interface_up) (int, struct zclient *, zebra_size_t);
@@ -100,6 +102,9 @@
   u_int32_t metric;
 };
 
+int zapi_ipv4_set_mplsindex (struct zclient *, struct prefix_ipv4 *,
+       struct in_addr*, unsigned int, unsigned int);
+
 int
 zapi_ipv4_add (struct zclient *, struct prefix_ipv4 *, struct zapi_ipv4 *);
 
@@ -127,8 +132,11 @@
 
 struct interface *zebra_interface_add_read (struct stream *);
 struct interface *zebra_interface_state_read (struct stream *s);
+void zebra_interface_if_set_value (struct stream *, struct interface *);
 struct connected *zebra_interface_address_add_read (struct stream *);
 struct connected *zebra_interface_address_delete_read (struct stream *);
+void zebra_router_id_update_read (struct stream *s, struct prefix *rid);
+
 
 #ifdef HAVE_IPV6
 /* IPv6 prefix add and delete function prototype. */
diff --exclude=CVS -uNr zebra/lib/zebra.h zebra-ldp/lib/zebra.h
--- zebra/lib/zebra.h   2003-03-14 08:44:47.000000000 -0600
+++ zebra-ldp/lib/zebra.h       2003-03-13 23:28:36.000000000 -0600
@@ -226,7 +226,11 @@
 #define ZEBRA_IPV6_NEXTHOP_LOOKUP         16
 #define ZEBRA_IPV4_IMPORT_LOOKUP          17
 #define ZEBRA_IPV6_IMPORT_LOOKUP          18
-#define ZEBRA_MESSAGE_MAX                 19
+#define ZEBRA_ROUTER_ID_ADD               19
+#define ZEBRA_ROUTER_ID_DELETE            20
+#define ZEBRA_ROUTER_ID_UPDATE            21
+#define ZEBRA_IPV4_SET_MPLSINDEX         22
+#define ZEBRA_MESSAGE_MAX                 23
 
 /* Zebra route's types. */
 #define ZEBRA_ROUTE_SYSTEM               0
@@ -238,7 +242,8 @@
 #define ZEBRA_ROUTE_OSPF                 6
 #define ZEBRA_ROUTE_OSPF6                7
 #define ZEBRA_ROUTE_BGP                  8
-#define ZEBRA_ROUTE_MAX                  9
+#define ZEBRA_ROUTE_MPLS                 9
+#define ZEBRA_ROUTE_MAX                  10
 
 /* Zebra's family types. */
 #define ZEBRA_FAMILY_IPV4                1
@@ -259,6 +264,7 @@
 #define ZEBRA_FLAG_SELECTED           0x10
 #define ZEBRA_FLAG_CHANGED            0x20
 #define ZEBRA_FLAG_STATIC             0x40
+#define ZEBRA_FLAG_MPLS_CHANGED       0x80
 
 /* Zebra nexthop flags. */
 #define ZEBRA_NEXTHOP_IFINDEX            1
diff --exclude=CVS -uNr zebra/Makefile.am zebra-ldp/Makefile.am
--- zebra/Makefile.am   2003-03-14 08:44:20.000000000 -0600
+++ zebra-ldp/Makefile.am       2003-02-26 15:46:34.000000000 -0600
@@ -1,6 +1,6 @@
 ## Process this file with automake to produce Makefile.in.
 
-SUBDIRS = lib @ZEBRA@ @BGPD@ @RIPD@ @RIPNGD@ @OSPFD@ @OSPF6D@ @VTYSH@ doc
+SUBDIRS = lib @ZEBRA@ @BGPD@ @RIPD@ @RIPNGD@ @OSPFD@ @OSPF6D@ @MPLSD@ @VTYSH@ doc
 
 EXTRA_DIST = aclocal.m4 SERVICES TODO REPORTING-BUGS vtysh/Makefile.in \
        vtysh/Makefile.am update-autotools
diff --exclude=CVS -uNr zebra/mplsd/create-links zebra-ldp/mplsd/create-links
--- zebra/mplsd/create-links    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/create-links        2003-02-26 15:47:42.000000000 -0600
@@ -0,0 +1,104 @@
+#!/bin/sh
+
+SRC=/home/jleu/personal/p4all/ldp-portable
+
+ln -s $SRC/ldp/ldp_addr.c
+ln -s $SRC/ldp/ldp_addr.h
+ln -s $SRC/ldp/ldp_adj.c
+ln -s $SRC/ldp/ldp_adj.h
+ln -s $SRC/ldp/ldp_attr.c
+ln -s $SRC/ldp/ldp_attr.h
+ln -s $SRC/ldp/ldp_buf.c
+ln -s $SRC/ldp/ldp_buf.h
+ln -s $SRC/ldp/ldp_cfg.c
+ln -s $SRC/ldp/ldp_cfg.h
+ln -s $SRC/ldp/ldp_defaults.h
+ln -s $SRC/ldp/ldp_entity.c
+ln -s $SRC/ldp/ldp_entity.h
+ln -s $SRC/ldp/ldp_fec.c
+ln -s $SRC/ldp/ldp_fec.h
+ln -s $SRC/ldp/ldp_global.c
+ln -s $SRC/ldp/ldp_global.h
+ln -s $SRC/ldp/ldp_hello.c
+ln -s $SRC/ldp/ldp_hello.h
+ln -s $SRC/ldp/ldp_hop.c
+ln -s $SRC/ldp/ldp_hop.h
+ln -s $SRC/ldp/ldp_hop_list.c
+ln -s $SRC/ldp/ldp_hop_list.h
+ln -s $SRC/ldp/ldp_if.c
+ln -s $SRC/ldp/ldp_if.h
+ln -s $SRC/ldp/ldp_inet_addr.c
+ln -s $SRC/ldp/ldp_inet_addr.h
+ln -s $SRC/ldp/ldp_init.c
+ln -s $SRC/ldp/ldp_init.h
+ln -s $SRC/ldp/ldp_inlabel.c
+ln -s $SRC/ldp/ldp_inlabel.h
+ln -s $SRC/ldp/ldp_keepalive.c
+ln -s $SRC/ldp/ldp_keepalive.h
+ln -s $SRC/ldp/ldp_label_abort.c
+ln -s $SRC/ldp/ldp_label_abort.h
+ln -s $SRC/ldp/ldp_label_mapping.c
+ln -s $SRC/ldp/ldp_label_mapping.h
+ln -s $SRC/ldp/ldp_label_rel_with.c
+ln -s $SRC/ldp/ldp_label_rel_with.h
+ln -s $SRC/ldp/ldp_label_request.c
+ln -s $SRC/ldp/ldp_label_request.h
+ln -s $SRC/ldp/ldp_mesg.c
+ln -s $SRC/ldp/ldp_mesg.h
+ln -s $SRC/ldp/ldp_nortel.c
+ln -s $SRC/ldp/ldp_nortel.h
+ln -s $SRC/ldp/ldp_notif.c
+ln -s $SRC/ldp/ldp_notif.h
+ln -s $SRC/ldp/ldp_outlabel.c
+ln -s $SRC/ldp/ldp_outlabel.h
+ln -s $SRC/ldp/ldp_pdu.h
+ln -s $SRC/ldp/ldp_pdu_setup.c
+ln -s $SRC/ldp/ldp_pdu_setup.h
+ln -s $SRC/ldp/ldp_peer.c
+ln -s $SRC/ldp/ldp_peer.h
+ln -s $SRC/ldp/ldp_resource.c
+ln -s $SRC/ldp/ldp_resource.h
+ln -s $SRC/ldp/ldp_session.c
+ln -s $SRC/ldp/ldp_session.h
+ln -s $SRC/ldp/ldp_state_funcs.c
+ln -s $SRC/ldp/ldp_state_machine.c
+ln -s $SRC/ldp/ldp_state_machine.h
+ln -s $SRC/ldp/ldp_struct.h
+ln -s $SRC/ldp/ldp_tunnel.c
+ln -s $SRC/ldp/ldp_tunnel.h
+
+ln -s $SRC/lsr/lsr_cfg.c
+ln -s $SRC/lsr/lsr_cfg.h
+ln -s $SRC/lsr/lsr_defaults.h
+ln -s $SRC/lsr/lsr_global.c
+ln -s $SRC/lsr/lsr_global.h
+ln -s $SRC/lsr/lsr_if.c
+ln -s $SRC/lsr/lsr_if.h
+ln -s $SRC/lsr/lsr_insegment.c
+ln -s $SRC/lsr/lsr_insegment.h
+ln -s $SRC/lsr/lsr_labelmanager.c
+ln -s $SRC/lsr/lsr_labelmanager.h
+ln -s $SRC/lsr/lsr_outsegment.c
+ln -s $SRC/lsr/lsr_outsegment.h
+ln -s $SRC/lsr/lsr_struct.h
+ln -s $SRC/lsr/lsr_xconnect.c
+ln -s $SRC/lsr/lsr_xconnect.h
+ln -s $SRC/lsr/lsr_ftn.c
+ln -s $SRC/lsr/lsr_ftn.h
+
+ln -s $SRC/common/mpls_struct.h
+ln -s $SRC/common/mpls_assert.h
+ln -s $SRC/common/mpls_fib_impl.h
+ln -s $SRC/common/mpls_ifmgr_impl.h
+ln -s $SRC/common/mpls_mm_impl.h
+ln -s $SRC/common/mpls_mpls_impl.h
+ln -s $SRC/common/mpls_policy_impl.h
+ln -s $SRC/common/mpls_refcnt.h
+ln -s $SRC/common/mpls_socket_impl.h
+ln -s $SRC/common/mpls_timer_impl.h
+ln -s $SRC/common/mpls_trace_impl.h
+ln -s $SRC/common/mpls_tree_impl.h
+ln -s $SRC/common/mpls_list.h
+ln -s $SRC/common/mpls_lock_impl.h
+ln -s $SRC/common/mpls_compare.h
+ln -s $SRC/common/mpls_compare.c
diff --exclude=CVS -uNr zebra/mplsd/delete-links zebra-ldp/mplsd/delete-links
--- zebra/mplsd/delete-links    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/delete-links        2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,102 @@
+#!/bin/sh
+
+rm -f ldp_addr.c
+rm -f ldp_addr.h
+rm -f ldp_adj.c
+rm -f ldp_adj.h
+rm -f ldp_attr.c
+rm -f ldp_attr.h
+rm -f ldp_buf.c
+rm -f ldp_buf.h
+rm -f ldp_cfg.c
+rm -f ldp_cfg.h
+rm -f ldp_defaults.h
+rm -f ldp_entity.c
+rm -f ldp_entity.h
+rm -f ldp_fec.c
+rm -f ldp_fec.h
+rm -f ldp_global.c
+rm -f ldp_global.h
+rm -f ldp_hello.c
+rm -f ldp_hello.h
+rm -f ldp_hop.c
+rm -f ldp_hop.h
+rm -f ldp_hop_list.c
+rm -f ldp_hop_list.h
+rm -f ldp_if.c
+rm -f ldp_if.h
+rm -f ldp_inet_addr.c
+rm -f ldp_inet_addr.h
+rm -f ldp_init.c
+rm -f ldp_init.h
+rm -f ldp_inlabel.c
+rm -f ldp_inlabel.h
+rm -f ldp_keepalive.c
+rm -f ldp_keepalive.h
+rm -f ldp_label_abort.c
+rm -f ldp_label_abort.h
+rm -f ldp_label_mapping.c
+rm -f ldp_label_mapping.h
+rm -f ldp_label_rel_with.c
+rm -f ldp_label_rel_with.h
+rm -f ldp_label_request.c
+rm -f ldp_label_request.h
+rm -f ldp_mesg.c
+rm -f ldp_mesg.h
+rm -f ldp_nortel.c
+rm -f ldp_nortel.h
+rm -f ldp_notif.c
+rm -f ldp_notif.h
+rm -f ldp_outlabel.c
+rm -f ldp_outlabel.h
+rm -f ldp_pdu.h
+rm -f ldp_pdu_setup.c
+rm -f ldp_pdu_setup.h
+rm -f ldp_peer.c
+rm -f ldp_peer.h
+rm -f ldp_resource.c
+rm -f ldp_resource.h
+rm -f ldp_session.c
+rm -f ldp_session.h
+rm -f ldp_state_funcs.c
+rm -f ldp_state_machine.c
+rm -f ldp_state_machine.h
+rm -f ldp_struct.h
+rm -f ldp_tunnel.c
+rm -f ldp_tunnel.h
+
+rm -f lsr_cfg.c
+rm -f lsr_cfg.h
+rm -f lsr_defaults.h
+rm -f lsr_global.c
+rm -f lsr_global.h
+rm -f lsr_if.c
+rm -f lsr_if.h
+rm -f lsr_insegment.c
+rm -f lsr_insegment.h
+rm -f lsr_labelmanager.c
+rm -f lsr_labelmanager.h
+rm -f lsr_outsegment.c
+rm -f lsr_outsegment.h
+rm -f lsr_struct.h
+rm -f lsr_xconnect.c
+rm -f lsr_xconnect.h
+rm -f lsr_ftn.c
+rm -f lsr_ftn.h
+
+rm -f mpls_struct.h
+rm -f mpls_assert.h
+rm -f mpls_fib_impl.h
+rm -f mpls_ifmgr_impl.h
+rm -f mpls_mm_impl.h
+rm -f mpls_mpls_impl.h
+rm -f mpls_policy_impl.h
+rm -f mpls_refcnt.h
+rm -f mpls_socket_impl.h
+rm -f mpls_timer_impl.h
+rm -f mpls_trace_impl.h
+rm -f mpls_tree_impl.h
+rm -f mpls_list.h
+rm -f mpls_lock_impl.h
+rm -f mpls_compare.h
+rm -f mpls_compare.c
diff --exclude=CVS -uNr zebra/mplsd/impl_fib.c zebra-ldp/mplsd/impl_fib.c
--- zebra/mplsd/impl_fib.c      1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_fib.c  2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,296 @@
+#include <zebra.h>
+#include "prefix.h"
+#include "table.h"
+#include "if.h"
+#include "memory.h"
+
+#include "mpls.h"
+#include "mpls_compare.h"
+
+#include "ldp.h"
+#include "ldp_struct.h"
+
+void mpls_fib_close(mpls_fib_handle handle)
+{
+}
+
+void mpls_fib_update_close(mpls_fib_handle handle)
+{
+}
+
+mpls_fib_handle mpls_fib_open(const mpls_instance_handle handle,
+  const mpls_cfg_handle cfg, ldp_fib_callback callback)
+{
+  struct mpls *mpls = mpls_get();
+  mpls->fib_callback = callback;
+  return mpls;
+}
+
+void mpls_fec2zebra_prefix(mpls_fec *lp, struct prefix *p)
+{
+  switch(lp->type) {
+    case MPLS_FEC_PREFIX:
+      p->prefixlen = lp->u.prefix.length;
+      p->u.prefix4.s_addr = htonl(lp->u.prefix.network.u.ipv4);
+      break;
+    case MPLS_FEC_HOST:
+      p->prefixlen = 32;
+      p->u.prefix4.s_addr = htonl(lp->u.host.u.ipv4);
+      break;
+    default:
+      break;
+  }
+}
+
+void zebra_prefix2mpls_fec(struct prefix *p, struct mpls_nexthop *nh, mpls_fec *fec)
+{
+  fec->u.prefix.length = p->prefixlen;
+  fec->type = MPLS_FEC_PREFIX;
+  fec->u.prefix.network.type = MPLS_FAMILY_IPV4;
+  fec->u.prefix.network.u.ipv4 = ntohl(p->u.prefix4.s_addr);
+  memcpy(&fec->nh, nh, sizeof(struct mpls_nexthop));
+}
+
+int list2fec(struct list *list, struct prefix *p, mpls_fec *entry, int num) {
+  struct listnode* ln;
+  struct mpls_nexthop* head;
+  struct mpls_nexthop* nh;
+  int count = 0;
+
+  head = listhead(list) ? getdata(listhead(list)) : NULL;
+
+  LIST_LOOP(list, nh, ln) {
+    if (head->distance == nh->distance && head->metric == nh->metric) {
+      zebra_prefix2mpls_fec(p,nh,&entry[count]);
+    } else {
+      break;
+    }
+    count++;
+    if (count >= num) {
+      break;
+    }
+  }
+  return count;
+}
+
+int mpls_fib_get_route(mpls_fib_handle handle, const int num,
+  const mpls_fec * fec, mpls_fec * entry)
+{
+  struct prefix p;
+  struct route_node *rn;
+  int count = 0;
+
+  mpls_fec2zebra_prefix((mpls_fec*)fec,&p);
+
+  if ((rn = route_node_lookup(handle->table,&p))) {
+    count = list2fec((struct list*)rn->info,&rn->p,entry,num);
+    route_unlock_node(rn);
+    return count;
+  }
+  return 0;
+}
+
+int mpls_fib_get_best_route(mpls_fib_handle handle, const int num,
+  const mpls_fec * dest, mpls_fec * entry)
+{
+  struct route_node *rn;
+  struct prefix p;
+  int count = 0;
+  int len;
+
+  mpls_fec2zebra_prefix((mpls_fec*)dest,&p);
+
+  for (len = 32; len >= 0 ; len--) {
+    p.prefixlen = len;
+    if ((rn = route_node_lookup(handle->table,&p))) {
+      count = list2fec((struct list*)rn->info,&rn->p,entry,num);
+      route_unlock_node(rn);
+    }
+  }
+  return count;
+}
+
+mpls_return_enum mpls_fib_getfirst_route(mpls_fib_handle handle, mpls_fec * dest)
+{
+  struct route_node *rn;
+
+  if ((rn = route_top(handle->table))) {
+    if (!rn->info) {
+      rn = route_next2(rn);
+    }
+
+    if (rn) {
+      list2fec((struct list*)rn->info,&rn->p,dest,1);
+      route_unlock_node(rn);
+      return MPLS_SUCCESS;
+    }
+  }
+    
+  return MPLS_FAILURE;
+}
+
+mpls_return_enum mpls_fib_getnext_route(mpls_fib_handle handle, mpls_fec * dest)
+{
+  struct route_node *rn_in;
+  struct listnode* ln;
+  struct list* list;
+  struct mpls_nexthop* nh;
+  struct prefix p;
+  int next = 0;
+
+  mpls_fec2zebra_prefix(dest,&p);
+
+  if (!(rn_in = route_node_lookup2(handle->table,&p))) {
+    return MPLS_FAILURE;
+  }
+
+  list = (struct list*)rn_in->info;
+  LIST_LOOP(list, nh, ln) {
+    if (next) {
+      zebra_prefix2mpls_fec(&p, nh, dest);
+      route_unlock_node(rn_in);
+      return MPLS_SUCCESS;
+    }
+    if (!mpls_nexthop_compare(nh,&dest->nh)) {
+      next = 1;
+    }
+  }
+
+  if ((rn_in = route_next2(rn_in))) {
+    list2fec((struct list*)rn_in->info,&rn_in->p,dest,1);
+    route_unlock_node(rn_in);
+    return MPLS_SUCCESS;
+  }
+
+  return MPLS_FAILURE;
+}
+
+static struct mpls_nexthop* mpls_nexthop_create(struct mpls_nexthop* dup) {
+  struct mpls_nexthop *nh;
+  nh = XMALLOC (MTYPE_MPLS_TOP, sizeof (struct mpls_nexthop));
+  if (dup) {
+    memcpy(nh, dup, sizeof(struct mpls_nexthop));
+  } else {
+    memset(nh, 0, sizeof(struct mpls_nexthop));
+  }
+  return nh;
+}
+
+static void mpls_nexthop_delete(void* v) {
+  XFREE(MTYPE_MPLS_TOP, v);
+}
+
+static int local_mpls_nexthop_compare(void* a,void* b) {
+  return mpls_nexthop_compare((struct mpls_nexthop*)a,(struct mpls_nexthop*)b);
+}
+
+void ldp_ipv4_add(struct mpls *mpls, struct prefix_ipv4 *p,
+  struct mpls_nexthop *nexthop) {
+  mpls_fec dest;
+  struct route_node *rn;
+  struct list *list;
+  struct mpls_nexthop *active;
+  struct mpls_nexthop *head;
+  struct mpls_nexthop *nh = mpls_nexthop_create(nexthop);
+
+  if ((rn = route_node_lookup(mpls->table,(struct prefix*)p))) {
+    list = (struct list*)rn->info;
+    active = listhead(list) ? getdata(listhead(list)) : NULL;
+  } else {
+    rn = route_node_get(mpls->table,(struct prefix*)p);
+    route_lock_node(rn);
+    list = list_new();
+    rn->info = list;
+    active = NULL;
+    list->cmp = local_mpls_nexthop_compare;
+  }
+  listnode_add_sort(list, nh);
+  head = getdata(listhead(list));
+
+  /* if the new route isn't the active route, do nothing */
+  if (nh != head) {
+    if (rn) {
+      route_unlock_node(rn);
+    }
+    return;
+  }
+
+  /* we only get here is the new nh is the active one, which means we need
+   * to delete the only nh, THEN send in the new nh */
+  if (mpls->ldp && mpls->fib_callback) {
+    memset(&dest,0,sizeof(dest));
+
+    /* if their was a previouly active route, delete it */
+    if (active) {
+      zebra_prefix2mpls_fec((struct prefix*)p, active, &dest);
+      mpls->fib_callback(mpls->ldp->h, MPLS_UPDATE_DEL, &dest);
+    }
+
+    /* add the new route */
+    zebra_prefix2mpls_fec((struct prefix*)p, nh, &dest);
+    mpls->fib_callback(mpls->ldp->h, MPLS_UPDATE_ADD, &dest);
+  }
+  if (rn) {
+    route_unlock_node(rn);
+  }
+}
+
+void ldp_ipv4_delete(struct mpls* mpls, struct prefix_ipv4* p,
+  struct mpls_nexthop* nexthop) {
+  struct route_node* rn;
+  struct list* list = NULL;
+  struct listnode* ln;
+  struct mpls_nexthop *active = NULL;
+  struct mpls_nexthop *head = NULL;
+  struct mpls_nexthop* nh = NULL;
+  mpls_fec dest;
+
+  if ((rn = route_node_lookup(mpls->table,(struct prefix*)p))) {
+    list = (struct list*)rn->info;
+    active = listhead(list) ? getdata(listhead(list)) : NULL;
+    LIST_LOOP(list, nh, ln) {
+      /* if they match, remove it */
+      if (!mpls_nexthop_compare(nh, nexthop)) {
+        list_delete_node(list, ln);
+        break;
+      }
+    }
+    if (list_isempty(list)) {
+      rn->info = NULL;
+      route_unlock_node(rn);
+      list_free(list);
+      list = NULL;
+    }
+  }
+
+  head = (list && listhead(list)) ? getdata(listhead(list)) : NULL;
+
+  if (!nh) {
+    /* if we do not know about the route, do nothing */
+    if (rn) {
+      route_unlock_node(rn);
+    }
+    return;
+  }
+
+  /* otherwise, if we have a callback */
+  if (mpls->ldp && mpls->fib_callback) {
+    memset(&dest,0,sizeof(dest));
+
+    /* did we we just removed the active nexthop */
+    if (active == nh) {
+      /* if so send in a delete */
+      zebra_prefix2mpls_fec((struct prefix*)p, nexthop, &dest);
+      mpls->fib_callback(mpls->ldp->h, MPLS_UPDATE_DEL, &dest);
+      mpls_nexthop_delete(nh);
+
+      /* is there a active nexthop? */
+      if (head) {
+       /* if so, send in a add */
+        zebra_prefix2mpls_fec((struct prefix*)p, head, &dest);
+        mpls->fib_callback(mpls->ldp->h, MPLS_UPDATE_ADD, &dest);
+      }
+    }
+  }
+  route_unlock_node(rn);
+}
diff --exclude=CVS -uNr zebra/mplsd/impl_fib.h zebra-ldp/mplsd/impl_fib.h
--- zebra/mplsd/impl_fib.h      1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_fib.h  2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,16 @@
+#ifndef LDP_IMPL_FIB_H
+#define LDP_IMPL_FIB_H
+
+#include <zebra.h>
+
+#include "ldp_struct.h"
+#include "mpls.h"
+
+extern void mpls_fec2zebra_prefix(mpls_fec *lp, struct prefix *p);
+extern void zebra_prefix2mpls_fec(struct prefix *p, mpls_fec *lp);
+void ldp_ipv4_add(struct mpls *mpls, struct prefix_ipv4 *p,
+  struct mpls_nexthop *nexthop);
+void ldp_ipv4_delete(struct mpls *mpls, struct prefix_ipv4 *p,
+  struct mpls_nexthop *nexthop);
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/impl_ifmgr.c zebra-ldp/mplsd/impl_ifmgr.c
--- zebra/mplsd/impl_ifmgr.c    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_ifmgr.c        2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,163 @@
+#include <zebra.h>
+#include "if.h"
+
+#include "ldp.h"
+#include "ldp_struct.h"
+
+#include "mpls.h"
+
+static ldp_ifmgr_callback ifmgr_callback;
+static int opened = 0;
+
+static unsigned int mask_array[33] = { 0x00000000,
+  0x80000000, 0xC0000000, 0xE0000000, 0xF0000000,
+  0xF8000000, 0xFC000000, 0xFE000000, 0xFF000000,
+  0xFF800000, 0xFFC00000, 0xFFE00000, 0xFFF00000,
+  0xFFF80000, 0xFFFC0000, 0xFFFE0000, 0xFFFF0000,
+  0xFFFF8000, 0xFFFFC000, 0xFFFFE000, 0xFFFFF000,
+  0xFFFFF800, 0xFFFFFC00, 0xFFFFFE00, 0xFFFFFF00,
+  0xFFFFFF80, 0xFFFFFFC0, 0xFFFFFFE0, 0xFFFFFFF0,
+  0xFFFFFFF8, 0xFFFFFFFC, 0xFFFFFFFE, 0xFFFFFFFF };
+
+mpls_ifmgr_handle mpls_ifmgr_open(mpls_instance_handle handle,
+  mpls_cfg_handle cfg, ldp_ifmgr_callback callback)
+{
+  if (callback) {
+    ifmgr_callback = callback;
+    opened = 1;
+  }
+  return 0xdeadbeef;
+}
+
+void mpls_ifmgr_close(mpls_ifmgr_handle ifmgr_handle)
+{
+  opened = 0;
+}
+
+mpls_if_handle mpls_ifmgr_open_if(mpls_ifmgr_handle ifmgr_handle, const char *name)
+{
+  mpls_if_handle ifh;
+  char name2[IFNAMSIZ + 1];
+  strncpy(name2,name,IFNAMSIZ);
+
+  ifh = if_lookup_by_name(name2);
+
+  return ifh;
+}
+
+mpls_return_enum mpls_ifmgr_get_address(mpls_ifmgr_handle ifmgr_handle,
+  mpls_if_handle if_handle, mpls_inet_addr * addr, mpls_inet_addr * mask,
+  uint32_t * flags)
+{
+  struct connected *ifc;
+  listnode node;
+  int loop = 0;
+
+  if (flags) {
+    *flags = if_handle->flags;
+  }
+
+  for (node = listhead(if_handle->connected); node; nextnode(node)) {
+    ifc = getdata(node);
+    if (ifc->address->u.prefix4.s_addr == htonl(INADDR_LOOPBACK)) {
+      loop = 1;
+      continue;
+    }
+    if (!loop && (ifc->flags & ZEBRA_IFA_SECONDARY)) {
+      continue;
+    }
+    if (addr) {
+      addr->type = MPLS_FAMILY_IPV4;
+      addr->u.ipv4 = ntohl(ifc->address->u.prefix4.s_addr);
+    }
+    if (mask) {
+      mask->type = MPLS_FAMILY_IPV4;
+      mask->u.ipv4 = mask_array[ifc->address->prefixlen];
+    }
+    return MPLS_SUCCESS;
+  }
+  return MPLS_FAILURE;
+}
+
+mpls_return_enum mpls_ifmgr_get_mtu(mpls_ifmgr_handle ifmgr_handle,
+  mpls_if_handle if_handle, int *mtu)
+{
+  *mtu = if_handle->mtu;
+  return MPLS_SUCCESS;
+}
+
+void mpls_ifmgr_close_if(mpls_ifmgr_handle ifmgr_handle, mpls_if_handle if_handle)
+{
+}
+
+mpls_return_enum mpls_ifmgr_getnext_address(mpls_ifmgr_handle ifmgr_handle,
+  mpls_if_handle *handle, mpls_inet_addr *addr)
+{
+  struct connected *ifc;
+  listnode node;
+  int next = 0;
+
+  while ((*handle)) {
+    for (node = listhead((*handle)->connected); node; nextnode(node)) {
+      ifc = getdata(node);
+      if (ifc->address->u.prefix4.s_addr != htonl(INADDR_LOOPBACK)) {
+        if (next) {
+          addr->type = MPLS_FAMILY_IPV4;
+          addr->u.ipv4 = ntohl(ifc->address->u.prefix4.s_addr);
+          return MPLS_SUCCESS;
+        } else if (addr->u.ipv4 == ntohl(ifc->address->u.prefix4.s_addr)) {
+          next = 1;
+        }
+      }
+    }
+    (*handle) = if_getnext(*handle);
+    next = 1;
+  }
+  return MPLS_END_OF_LIST;
+}
+
+mpls_return_enum mpls_ifmgr_getfirst_address(mpls_ifmgr_handle ifmgr_handle,
+  mpls_if_handle *handle, mpls_inet_addr *addr)
+{
+  struct connected *ifc;
+  listnode node;
+
+  (*handle) = if_getfirst();
+  while ((*handle)) {
+    for (node = listhead((*handle)->connected); node; nextnode(node)) {
+      ifc = getdata(node);
+      if (ifc->address->u.prefix4.s_addr != htonl(INADDR_LOOPBACK)) {
+        addr->type = MPLS_FAMILY_IPV4;
+        addr->u.ipv4 = ntohl(ifc->address->u.prefix4.s_addr);
+        return MPLS_SUCCESS;
+      }
+    }
+    (*handle) = if_getnext(*handle);
+  }
+  return MPLS_END_OF_LIST;
+}
+
+int ldp_address_add_callback(struct mpls *mpls, struct connected *c) {
+  mpls_inet_addr addr;
+
+  if (opened) {
+    addr.type = MPLS_FAMILY_IPV4;
+    addr.u.ipv4 = ntohl(c->address->u.prefix4.s_addr);
+
+    ifmgr_callback(mpls->ldp->h,MPLS_UPDATE_ADD,&addr);
+  }
+
+  return 0;
+}
+
+int ldp_address_delete_callback(struct mpls *mpls, struct connected *c) {
+  mpls_inet_addr addr;
+
+  if (opened) {
+    addr.type = MPLS_FAMILY_IPV4;
+    addr.u.ipv4 = ntohl(c->address->u.prefix4.s_addr);
+
+    ifmgr_callback(mpls->ldp->h,MPLS_UPDATE_DEL,&addr);
+  }
+  return 0;
+}
diff --exclude=CVS -uNr zebra/mplsd/impl_ifmgr.h zebra-ldp/mplsd/impl_ifmgr.h
--- zebra/mplsd/impl_ifmgr.h    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_ifmgr.h        2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,10 @@
+#ifndef LDP_IMPL_IFMGR_H
+#define LDP_IMPL_IFMGR_H
+
+#include <zebra.h>
+#include "ldp_struct.h"
+
+int ldp_address_add_callback(struct mpls *mpls, struct connected *c);
+int ldp_address_delete_callback(struct mpls *mpls, struct connected *c);
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/impl_lock.c zebra-ldp/mplsd/impl_lock.c
--- zebra/mplsd/impl_lock.c     1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_lock.c 2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,28 @@
+#include "ldp_struct.h"
+#include "mpls_assert.h"
+#include "mpls_mm_impl.h"
+
+mpls_lock_handle mpls_lock_create(mpls_lock_key_type key)
+{
+  int *i = mpls_malloc(sizeof(int));
+
+  *i = 0;
+  return i;
+}
+
+void mpls_lock_get(mpls_lock_handle handle)
+{
+  MPLS_ASSERT(*handle == 0);
+  (*handle)++;
+}
+
+void mpls_lock_release(mpls_lock_handle handle)
+{
+  MPLS_ASSERT(*handle == 1);
+  (*handle)--;
+}
+
+void mpls_lock_delete(mpls_lock_handle handle)
+{
+  mpls_free(handle);
+}
diff --exclude=CVS -uNr zebra/mplsd/impl_mm.c zebra-ldp/mplsd/impl_mm.c
--- zebra/mplsd/impl_mm.c       1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_mm.c   2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,28 @@
+#include "ldp_struct.h"
+#include "mpls_mm_impl.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "memory.h"
+
+static int _mm_count = 0;
+
+void *mpls_malloc(mpls_size_type size)
+{
+  void *mem = XMALLOC(MTYPE_MPLS_LDP, size);
+  if (mem) {
+    _mm_count++;
+  }
+  return mem;
+}
+
+void mpls_free(void *mem)
+{
+  _mm_count--;
+  XFREE(MTYPE_MPLS_LDP,mem);
+}
+
+void mpls_mm_results()
+{
+  fprintf(stderr, "LDP MM RESULTS: %d\n", _mm_count);
+}
diff --exclude=CVS -uNr zebra/mplsd/impl_mpls.c zebra-ldp/mplsd/impl_mpls.c
--- zebra/mplsd/impl_mpls.c     1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_mpls.c 2003-03-12 22:53:25.000000000 -0600
@@ -0,0 +1,262 @@
+#include <mplsd/ldp.h>
+#include <zebra.h>
+
+#include "stream.h"
+#include "prefix.h"
+#include "log.h"
+#include "zclient.h"
+#include "if.h"
+
+#include "ldp_struct.h"
+#include "ldp_entity.h"
+#include "mpls_mpls_impl.h"
+#include "mpls_socket_impl.h"
+#include <linux/mpls.h>
+
+#include "mpls_interface.h"
+#include "impl_fib.h"
+
+static int label = 10000;
+extern struct zclient *zclient;
+static int mplsd_socket = 0;
+
+#define MPLS_LINUX 1
+
+int mplsd_ioctl (u_long request, caddr_t buffer) {
+  int ret = 0;
+  int err = 0;
+  
+  if (!mplsd_socket) {
+    mplsd_socket = socket (AF_INET, SOCK_DGRAM, 0);
+    if (mplsd_socket < 0) {
+      perror ("socket");
+      exit (1);
+    }
+  }
+
+  ret = ioctl (mplsd_socket, request, buffer);
+  if (ret < 0) {
+    err = errno;
+  }
+
+  if (ret < 0) {
+    errno = err;
+    return ret;
+  }
+  return 0;
+}
+
+int do_mpls_labelspace(struct mpls_interface *mi) {
+  struct mpls_labelspace_req mls;
+
+  if (!mi || !mi->ifp->ifindex) {
+    return 1;
+  }
+
+  memset(&mls,0,sizeof(struct mpls_labelspace_req));
+  mls.mls_ifindex = mi->ifp->ifindex;
+  mls.mls_labelspace = mi->labelspace;
+  if (mplsd_ioctl(SIOCSLABELSPACEMPLS,(caddr_t)&mls)) {
+    return 1;
+  }
+
+  return 0;
+}
+
+mpls_mpls_handle mpls_mpls_open(mpls_instance_handle user_data)
+{
+  return socket(AF_INET, SOCK_STREAM, 0);
+}
+
+void mpls_mpls_close(mpls_mpls_handle handle)
+{
+  close(handle);
+}
+
+mpls_return_enum mpls_mpls_outsegment_add(mpls_mpls_handle handle, mpls_outsegment * o)
+{
+#ifdef MPLS_LINUX
+  struct mpls_out_label_req oreq;
+  struct mpls_instruction_req mir;
+  struct sockaddr_in sin;
+  int result;
+
+  memset(&oreq,0,sizeof(oreq));
+  memset(&mir,0,sizeof(mir));
+  oreq.mol_label.ml_type = MPLS_LABEL_KEY;
+  result = ioctl(handle,SIOCMPLSNHLFEADD,&oreq);
+  o->handle = oreq.mol_label.u.ml_key;
+
+  mir.mir_direction = MPLS_OUT;
+  mir.mir_label.ml_type = MPLS_LABEL_KEY;
+  mir.mir_label.u.ml_key = o->handle;
+  mir.mir_instruction[0].mir_opcode = MPLS_OP_PUSH;
+  mir.mir_instruction[0].mir_data.push.ml_type = MPLS_LABEL_GEN;
+  mir.mir_instruction[0].mir_data.push.u.ml_gen = o->label.u.gen;
+
+  mir.mir_instruction[1].mir_opcode = MPLS_OP_SET;
+  mir.mir_instruction[1].mir_data.set.mni_if = o->nexthop.if_handle->ifindex;
+  sin.sin_addr.s_addr = htonl(o->nexthop.ip.u.ipv4);
+  sin.sin_family = AF_INET;
+  memcpy(&mir.mir_instruction[1].mir_data.set.mni_addr,
+    &sin,sizeof(struct sockaddr));
+
+  mir.mir_instruction_length = 2;
+  result = ioctl(handle,SIOCSMPLSOUTINSTR,&mir);
+
+#if 0
+  struct ifreq ifr;
+  sprintf(ifr.ifr_name,"mpls%d",o->handle);
+  memcpy(&ifr.ifr_data,&oreq.mol_label,sizeof(struct mpls_label));
+  result = ioctl(handle,SIOCMPLSTUNNELADD,&ifr);
+  ifr.ifr_flags = IFF_UP | IFF_POINTOPOINT | IFF_NOARP | IFF_RUNNING;
+  result = ioctl(handle,SIOCSIFFLAGS,&ifr);
+#endif
+#endif
+  return MPLS_SUCCESS;
+}
+
+void mpls_mpls_outsegment_del(mpls_mpls_handle handle, mpls_outsegment * o)
+{
+#ifdef MPLS_LINUX
+  struct mpls_out_label_req oreq;
+  int result;
+
+#if 0
+  struct ifreq ifr;
+  sprintf(ifr.ifr_name,"mpls%d",o->handle);
+  result = ioctl(handle,SIOCMPLSTUNNELDEL,&ifr);
+#endif
+
+  oreq.mol_label.ml_type = MPLS_LABEL_KEY;
+  oreq.mol_label.u.ml_key = o->handle;
+  result = ioctl(handle,SIOCMPLSNHLFEDEL,&oreq);
+
+#endif
+}
+
+mpls_return_enum mpls_mpls_insegment_add(mpls_mpls_handle handle,
+  mpls_insegment * i)
+{
+#ifdef MPLS_LINUX
+  struct mpls_in_label_req ireq;
+  int result;
+#endif
+
+  if (i->label.type == MPLS_LABEL_TYPE_NONE) {
+    i->label.type = MPLS_LABEL_TYPE_GENERIC;
+    i->label.u.gen = label++;
+  }
+
+#ifdef MPLS_LINUX
+  ireq.mil_label.ml_type = MPLS_LABEL_GEN;
+  ireq.mil_label.u.ml_gen = i->label.u.gen;
+  ireq.mil_label.ml_index = i->labelspace;
+  i->handle = 0;
+
+  result = ioctl(handle,SIOCMPLSILMADD,&ireq);
+
+#endif
+  return MPLS_SUCCESS;
+}
+
+void mpls_mpls_insegment_del(mpls_mpls_handle handle, mpls_insegment * i)
+{
+#ifdef MPLS_LINUX
+  struct mpls_in_label_req ireq;
+  int result;
+
+  ireq.mil_label.ml_type = MPLS_LABEL_GEN;
+  ireq.mil_label.u.ml_gen = i->label.u.gen;
+  ireq.mil_label.ml_index = i->labelspace;
+
+  result = ioctl(handle,SIOCMPLSILMDEL,&ireq);
+#endif
+}
+
+mpls_return_enum mpls_mpls_xconnect_add(mpls_mpls_handle handle, mpls_insegment * i, mpls_outsegment * o)
+{
+#ifdef MPLS_LINUX
+  struct mpls_xconnect_req xreq;
+  int result;
+
+  xreq.mx_in.ml_type = MPLS_LABEL_GEN;
+  xreq.mx_in.u.ml_gen = i->label.u.gen;
+  xreq.mx_in.ml_index = i->labelspace;
+
+  xreq.mx_out.ml_type = MPLS_LABEL_KEY;
+  xreq.mx_out.u.ml_key = o->handle;
+
+  result = ioctl(handle,SIOCMPLSXCADD,&xreq);
+
+#endif
+
+  return MPLS_SUCCESS;
+}
+
+void mpls_mpls_xconnect_del(mpls_mpls_handle handle, mpls_insegment * i,
+  mpls_outsegment * o)
+{
+#ifdef MPLS_LINUX
+  struct mpls_xconnect_req xreq;
+  int result;
+
+  xreq.mx_in.ml_type = MPLS_LABEL_GEN;
+  xreq.mx_in.u.ml_gen = i->label.u.gen;
+  xreq.mx_in.ml_index = i->labelspace;
+
+  xreq.mx_out.ml_type = MPLS_LABEL_KEY;
+  xreq.mx_out.u.ml_key = o->handle;
+
+  result = ioctl(handle,SIOCMPLSXCDEL,&xreq);
+
+#endif
+}
+
+mpls_return_enum mpls_mpls_fec2out_add(mpls_mpls_handle handle, mpls_fec * f,
+  mpls_outsegment * o)
+{
+  struct prefix p;
+  struct in_addr addr;
+  unsigned int ifindex;
+  unsigned int mplsindex;
+  int retval;
+
+  mplsindex = o->handle;
+  ifindex = o->nexthop.if_handle->ifindex;
+  addr.s_addr = htonl(o->nexthop.ip.u.ipv4);
+
+  mpls_fec2zebra_prefix(f,&p);
+  retval = zapi_ipv4_set_mplsindex(zclient,(struct prefix_ipv4*)&p,
+    &addr,ifindex,mplsindex);
+
+  return MPLS_SUCCESS;
+}
+
+void mpls_mpls_fec2out_del(mpls_mpls_handle handle, mpls_fec * f,
+  mpls_outsegment * o)
+{
+  struct prefix p;
+  struct in_addr addr;
+  unsigned int ifindex;
+  unsigned int mplsindex;
+  int retval;
+
+  mplsindex = o->handle;
+  ifindex = o->nexthop.if_handle->ifindex;
+  addr.s_addr = htonl(o->nexthop.ip.u.ipv4);
+
+  mpls_fec2zebra_prefix(f,&p);
+  retval = zapi_ipv4_set_mplsindex(zclient,(struct prefix_ipv4*)&p,
+    &addr,ifindex,0);
+}
+
+mpls_return_enum mpls_mpls_get_label_space_range(mpls_mpls_handle handle,
+  mpls_range * r)
+{
+  r->type = MPLS_LABEL_RANGE_GENERIC;
+  r->min.u.gen = 16;
+  r->max.u.gen = 0xFFFFF;
+
+  return MPLS_SUCCESS;
+}
diff --exclude=CVS -uNr zebra/mplsd/impl_mpls.h zebra-ldp/mplsd/impl_mpls.h
--- zebra/mplsd/impl_mpls.h     1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_mpls.h 2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,6 @@
+#ifndef IMPL_MPLS_H
+#define IMPL_MPLS_H
+
+int do_mpls_labelspace(struct mpls_interface *mi);
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/impl_policy.c zebra-ldp/mplsd/impl_policy.c
--- zebra/mplsd/impl_policy.c   1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_policy.c       2003-02-26 23:24:44.000000000 -0600
@@ -0,0 +1,87 @@
+#include <zebra.h>
+
+#include "ldp_struct.h"
+#include "mpls_interface.h"
+#include "impl_fib.h"
+#include "table.h"
+
+mpls_bool mpls_policy_import_check(mpls_instance_handle handle, mpls_fec * f,
+  ldp_addr * nh)
+{
+  return MPLS_BOOL_TRUE;
+}
+
+mpls_bool mpls_policy_ingress_check(mpls_instance_handle handle, mpls_fec * f, ldp_addr * nh)
+{
+  return MPLS_BOOL_TRUE;
+}
+
+mpls_bool mpls_policy_egress_check(mpls_instance_handle handle, mpls_fec * fec)
+{
+  struct ldp *ldp = handle;
+  int result = MPLS_BOOL_FALSE;
+
+  switch(ldp->egress) {
+    case LDP_EGRESS_ALL:
+      result = MPLS_BOOL_TRUE;
+      break;
+    case LDP_EGRESS_LSRID:
+    case LDP_EGRESS_CONNECTED:
+    {
+      struct route_node *rn;
+      struct prefix p;
+
+      mpls_fec2zebra_prefix(fec,&p);
+      if ((rn = route_node_lookup(ldp->mpls->table,&p))) {
+        if (ldp->egress == LDP_EGRESS_LSRID) {
+          if (prefix_match(&rn->p, &ldp->mpls->router_id)) {
+            result = MPLS_BOOL_TRUE;
+          }
+        } else {
+         struct mpls_nexthop* nh =
+            (struct mpls_nexthop*)getdata(listhead((struct list*)rn->info));
+         result = nh->attached;
+        }
+        route_unlock_node(rn);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return result;
+}
+
+mpls_bool mpls_policy_export_check(mpls_instance_handle handle, mpls_fec  * f, ldp_addr * nh)
+{
+  return MPLS_BOOL_TRUE;
+}
+
+mpls_bool mpls_policy_address_export_check(mpls_instance_handle handle,
+  mpls_inet_addr *addr) {
+  struct ldp *ldp = handle;
+  mpls_bool flag = MPLS_BOOL_FALSE; 
+  struct interface *ifp;
+  struct in_addr in;
+
+  in.s_addr = htonl(addr->u.ipv4);
+
+
+  switch (ldp->address) {
+    case LDP_ADDRESS_LDP:
+      if ((ifp = if_lookup_exact_address(in)) && 
+         ((struct mpls_interface*)(ifp->info))->ldp) {
+        flag = MPLS_BOOL_TRUE;
+      }
+      /* fall through */
+    case LDP_ADDRESS_LSRID:
+      if (in.s_addr == ldp->mpls->router_id.u.prefix4.s_addr) {
+        flag = MPLS_BOOL_TRUE;
+      }
+      break;
+    case LDP_ADDRESS_ALL:
+      flag = MPLS_BOOL_TRUE;
+      break;
+  }
+  return flag;
+}
diff --exclude=CVS -uNr zebra/mplsd/impl_socket.c zebra-ldp/mplsd/impl_socket.c
--- zebra/mplsd/impl_socket.c   1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_socket.c       2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,435 @@
+#include <zebra.h>
+#include "thread.h"
+#include "sockopt.h"
+
+#include "mpls.h"
+
+#include "ldp_struct.h"
+#include "ldp_state_machine.h"
+#include "mpls_mm_impl.h"
+
+extern struct thread_master *master;
+
+struct mpls_socket {
+    int fd;
+    int type;
+    struct thread *read;
+    struct thread *write;
+    void *extra;
+};
+
+void _sockaddr2mpls_dest(const struct sockaddr *addr, mpls_dest * dest)
+{
+  dest->addr.type = MPLS_FAMILY_IPV4;
+  switch (dest->addr.type) {
+    case MPLS_FAMILY_IPV4:
+      dest->port = ntohs(((struct sockaddr_in *)addr)->sin_port);
+      dest->addr.u.ipv4 = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
+      break;
+    default:
+      assert(0);
+  }
+}
+
+void _mpls_dest2sockaddr(const mpls_dest * dest, struct sockaddr *addr)
+{
+  memset(addr, 0, sizeof(struct sockaddr));
+
+  switch (dest->addr.type) {
+    case MPLS_FAMILY_IPV4:
+      {
+        addr->sa_family = AF_INET;
+        ((struct sockaddr_in *)addr)->sin_port = htons(dest->port);
+        ((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(dest->addr.u.ipv4);
+        break;
+      }
+    default:
+      {
+        assert(0);
+      }
+  }
+}
+
+int mplsd_read(struct thread *thread) {
+  int retval;
+  struct mpls *mpls = mpls_get();
+  mpls_socket_handle socket = THREAD_ARG(thread);
+
+  socket->read = thread_add_read(master,mplsd_read,socket,socket->fd);
+
+  if (!mpls || !mpls->ldp) {
+    return 0;
+  }
+
+  switch (socket->type) {
+    case MPLS_SOCKET_TCP_DATA:
+    {
+      retval = ldp_event(mpls->ldp->h, socket, socket->extra,
+        LDP_EVENT_TCP_DATA);
+      break;
+    }
+    case MPLS_SOCKET_TCP_LISTEN:
+    {
+      retval = ldp_event(mpls->ldp->h, socket, socket->extra,
+        LDP_EVENT_TCP_LISTEN);
+      break;
+    }
+    case MPLS_SOCKET_UDP_DATA:
+    {
+      retval = ldp_event(mpls->ldp->h, socket, socket->extra,
+        LDP_EVENT_UDP_DATA);
+      break;
+    }
+    default:
+    {
+      assert(0);
+    }
+  }
+  return 0;
+}
+
+int mplsd_write(struct thread *thread) {
+  struct mpls *mpls = mpls_get();
+  int retval;
+  mpls_socket_handle socket = THREAD_ARG(thread);
+  socket->write = thread_add_write(master,mplsd_write,socket,socket->fd);
+  if (socket->type != MPLS_SOCKET_TCP_CONNECT) {
+    assert(0);
+  }
+  retval = ldp_event(mpls->ldp->h, socket, socket->extra,
+    LDP_EVENT_TCP_CONNECT);
+
+  return 0;
+}
+
+mpls_socket_mgr_handle mpls_socket_mgr_open(mpls_instance_handle user_data)
+{
+  return 0xdeadbeef;
+}
+
+void mpls_socket_mgr_close(mpls_socket_mgr_handle handle)
+{
+}
+
+void mpls_socket_close(mpls_socket_mgr_handle handle, mpls_socket_handle socket)
+{
+  if (socket) {
+    close(socket->fd);
+    mpls_free(socket);
+  }
+}
+
+mpls_socket_handle mpls_socket_create_tcp(mpls_socket_mgr_handle handle)
+{
+  struct mpls_socket *sock;
+  sock = mpls_malloc(sizeof(struct mpls_socket));
+  memset(sock,0,sizeof(struct mpls_socket));
+  sock->fd = socket(AF_INET, SOCK_STREAM, 0);
+  MPLS_ASSERT(sock->fd > -1);
+  return sock;
+}
+
+mpls_socket_handle mpls_socket_create_udp(mpls_socket_mgr_handle handle)
+{
+  struct mpls_socket *sock;
+  u_char one = 1;
+
+  sock = mpls_malloc(sizeof(struct mpls_socket));
+  memset(sock,0,sizeof(struct mpls_socket));
+  sock->fd = socket(AF_INET, SOCK_DGRAM, 0);
+  MPLS_ASSERT(sock->fd > -1);
+  if (setsockopt(sock->fd,IPPROTO_IP,IP_PKTINFO,&one,sizeof(one)) < 0) {
+    perror("PKTINFO");
+    mpls_free(sock);
+    return NULL;
+  }
+  return sock;
+}
+
+mpls_socket_handle mpls_socket_tcp_accept(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, mpls_dest * from)
+{
+  struct mpls_socket *sock = mpls_malloc(sizeof(struct mpls_socket));
+  struct sockaddr addr;
+  int size = sizeof(addr);
+
+  if ((sock->fd = accept(socket->fd,&addr,&size)) < 0) {
+    return NULL;
+  }
+
+  _sockaddr2mpls_dest(&addr, from);
+  return sock;
+}
+
+mpls_return_enum mpls_socket_bind(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, const mpls_dest * local)
+{
+  struct sockaddr addr;
+
+  _mpls_dest2sockaddr(local, &addr);
+
+  if (bind(socket->fd, &addr, sizeof(struct sockaddr_in)) < 0) {
+    return MPLS_FAILURE;
+  }
+
+  return MPLS_SUCCESS;
+}
+
+mpls_return_enum mpls_socket_tcp_listen(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, int depth)
+{
+  if (listen(socket->fd, depth) < 0) {
+    return MPLS_FAILURE;
+  }
+  return MPLS_SUCCESS;
+}
+
+mpls_return_enum mpls_socket_tcp_connect(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, const mpls_dest * to)
+{
+  struct sockaddr addr, *iaddr = NULL;
+
+  if (to != NULL) {
+    _mpls_dest2sockaddr(to, &addr);
+    iaddr = &addr;
+  } else {
+    iaddr = NULL;
+  }
+
+  if (connect(socket->fd, iaddr, sizeof(struct sockaddr)) < 0) {
+    if (errno == EINPROGRESS) {
+      return MPLS_NON_BLOCKING;
+    }
+
+    if (errno == EALREADY) {
+      return MPLS_SUCCESS;
+    }
+    perror("connect");
+    return MPLS_FAILURE;
+  }
+  return MPLS_SUCCESS;
+}
+
+mpls_return_enum mpls_socket_connect_status(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket)
+{
+  int size = sizeof(int);
+  int num = 1;
+
+  if (getsockopt(socket->fd, SOL_SOCKET, SO_ERROR, &num, &size) < 0) {
+    perror("getsockopt");
+    return MPLS_FAILURE;
+  }
+  if (!num) {
+    return MPLS_SUCCESS;
+  }
+  perror("getsockopt");
+  return MPLS_NON_BLOCKING;
+}
+
+int mpls_socket_get_errno(const mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket)
+{
+  return errno;
+}
+
+mpls_return_enum mpls_socket_options(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, uint32_t flag)
+{
+  int one = 1;
+
+  if (flag & MPLS_SOCKOP_REUSE) {
+    if (setsockopt(socket->fd, SOL_SOCKET, SO_REUSEADDR, (char *)&one,
+        sizeof(one)) < 0) {
+      return MPLS_FAILURE;
+    }
+  }
+  if (flag & MPLS_SOCKOP_NONBLOCK) {
+    if (fcntl(socket->fd, F_SETFL, O_NONBLOCK) < 0) {
+      return MPLS_FAILURE;
+    }
+  }
+  return MPLS_SUCCESS;
+}
+
+mpls_return_enum mpls_socket_multicast_options(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, int ttl, int loop)
+{
+  int zero = loop;
+  int one = ttl;
+
+  if (setsockopt(socket->fd,IPPROTO_IP,IP_MULTICAST_TTL,&one,sizeof(one))<0) {
+    return MPLS_FAILURE;
+  }
+
+  if (setsockopt(socket->fd,IPPROTO_IP,IP_MULTICAST_LOOP,&zero,sizeof(zero))<0) {
+    return MPLS_FAILURE;
+  }
+
+  return MPLS_SUCCESS;
+}
+
+mpls_return_enum mpls_socket_multicast_if_tx(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, const ldp_if * iff)
+{
+  struct in_addr addr;
+  unsigned int ifindex = 0;
+  addr.s_addr = 0;
+
+  if (iff == NULL) {
+    addr.s_addr = ntohl(INADDR_ANY);
+  } else {
+    ifindex = iff->handle->ifindex;
+  }
+
+  if (setsockopt_multicast_ipv4(socket->fd,IP_MULTICAST_IF,addr,0,ifindex)<0) {
+    return MPLS_FAILURE;
+  }
+
+  return MPLS_SUCCESS;
+}
+
+mpls_return_enum mpls_socket_multicast_if_join(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, const ldp_if * iff, const mpls_inet_addr * mult)
+{
+  struct in_addr addr;
+  unsigned int ifindex = 0;
+  addr.s_addr = 0;
+
+  if (iff == NULL) {
+    addr.s_addr = ntohl(INADDR_ANY);
+  } else {
+    ifindex = iff->handle->ifindex;
+  }
+
+  if (setsockopt_multicast_ipv4(socket->fd,IP_ADD_MEMBERSHIP,addr,
+    htonl(mult->u.ipv4),ifindex)<0) {
+    return MPLS_FAILURE;
+  }
+
+  return MPLS_SUCCESS;
+}
+
+void mpls_socket_multicast_if_drop(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, const ldp_if * iff, const mpls_inet_addr * mult)
+{
+  struct in_addr addr;
+  unsigned int ifindex = 0;
+  addr.s_addr = 0;
+
+  if (iff == NULL) {
+    addr.s_addr = ntohl(INADDR_ANY);
+  } else {
+    ifindex = iff->handle->ifindex;
+  }
+
+  if (setsockopt_multicast_ipv4(socket->fd,IP_DROP_MEMBERSHIP,addr,
+    htonl(mult->u.ipv4),ifindex)<0) {
+    return;
+  }
+
+  return;
+}
+
+mpls_return_enum mpls_socket_readlist_add(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, void *extra, mpls_socket_enum type)
+{
+  socket->type = type;
+  socket->extra = extra;
+  socket->read = thread_add_read(master,mplsd_read,socket,socket->fd);
+  MPLS_ASSERT(socket->read);
+  return MPLS_SUCCESS;
+}
+
+void mpls_socket_readlist_del(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket)
+{
+  if (socket && socket->read) {
+    thread_cancel(socket->read);
+    socket->read = NULL;
+  }
+}
+
+mpls_return_enum mpls_socket_writelist_add(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, void *extra, mpls_socket_enum type)
+{
+  socket->type = type;
+  socket->extra = extra;
+  socket->write = thread_add_write(master,mplsd_write,socket,socket->fd);
+  MPLS_ASSERT(socket->write);
+  return MPLS_SUCCESS;
+}
+
+void mpls_socket_writelist_del(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket)
+{
+  if (socket) {
+    thread_cancel(socket->write);
+    socket->write = NULL;
+  }
+}
+  
+int mpls_socket_tcp_read(mpls_socket_mgr_handle handle, mpls_socket_handle socket,
+  uint8_t * buffer, int size)
+{
+  int ret = read(socket->fd,buffer,size);
+  if (ret < 0 && errno != EAGAIN) {
+    perror("mpls_socket_tcp_read");
+    return 0;
+  }
+  return ret;
+}
+
+int mpls_socket_tcp_write(mpls_socket_mgr_handle handle, mpls_socket_handle socket,
+  uint8_t * buffer, int size)
+{
+  return write(socket->fd,buffer,size);
+}
+
+int mpls_socket_udp_sendto(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, uint8_t * buffer, int size, const mpls_dest * to)
+{
+  struct sockaddr addr;
+  int retval;
+
+  _mpls_dest2sockaddr(to, &addr);
+
+  retval = sendto(socket->fd,buffer,size,0,&addr,sizeof(struct sockaddr));
+
+  return retval;
+}
+
+int mpls_socket_udp_recvfrom(mpls_socket_mgr_handle handle,
+  mpls_socket_handle socket, uint8_t * buffer, int size, mpls_dest * from)
+{
+  int ret;
+  unsigned int ifindex = 0;
+  struct iovec iov;
+  struct cmsghdr *cmsg;
+  struct in_pktinfo *pktinfo;
+  struct sockaddr addr;
+  char buff [sizeof (*cmsg) + sizeof (*pktinfo)];
+  struct msghdr msgh = {&addr, sizeof(struct sockaddr), &iov, 1, buff,
+                        sizeof (*cmsg) + sizeof (*pktinfo), 0};
+
+  iov.iov_base = buffer;
+  iov.iov_len = size;
+  ret = recvmsg(socket->fd,&msgh,0);
+
+  if (ret < 0 && errno != EAGAIN) {
+    return 0;
+  }
+
+  cmsg = CMSG_FIRSTHDR(&msgh);
+
+  if (cmsg != NULL &&
+      cmsg->cmsg_level == IPPROTO_IP &&
+      cmsg->cmsg_type == IP_PKTINFO) {
+      pktinfo = (struct in_pktinfo *)CMSG_DATA(cmsg);
+      ifindex = pktinfo->ipi_ifindex;
+      from->if_handle = if_lookup_by_index(ifindex);
+      _sockaddr2mpls_dest((const struct sockaddr*)&addr, from);
+  }
+
+  return ret;
+}
diff --exclude=CVS -uNr zebra/mplsd/impl_timer.c zebra-ldp/mplsd/impl_timer.c
--- zebra/mplsd/impl_timer.c    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_timer.c        2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,93 @@
+#include "ldp_struct.h"
+#include "mpls_timer_impl.h"
+#include "mpls_mm_impl.h"
+
+#include "thread.h"
+
+struct mpls_timer {
+    struct thread *timer;
+    mpls_time_unit_enum unit;
+    int duration;
+    int type;
+    void *extra;
+    mpls_cfg_handle g;
+    void (*callback) (mpls_timer_handle timer, void *extra, mpls_cfg_handle g);
+    int active;
+};
+
+extern struct thread_master *master;
+
+int mpls_timer(struct thread* thread) {
+  mpls_timer_handle timer = THREAD_ARG(thread);
+
+  timer->active = 0;
+  if (timer->type == MPLS_TIMER_REOCCURRING) {
+    timer->timer = thread_add_timer(master,mpls_timer,timer,timer->duration);
+    timer->active = 1;
+  }
+  timer->callback(timer,timer->extra,timer->g);
+
+  return 0;
+}
+
+mpls_timer_mgr_handle mpls_timer_open(mpls_instance_handle user_data)
+{
+  return 0xdeadbeef;
+}
+
+void mpls_timer_close(mpls_timer_mgr_handle handle)
+{
+}
+
+mpls_timer_handle mpls_timer_create(mpls_timer_mgr_handle handle,
+  mpls_time_unit_enum unit, int duration, void *extra, mpls_cfg_handle g,
+  void (*callback) (mpls_timer_handle timer, void *extra, mpls_cfg_handle g))
+{
+  struct mpls_timer *timer;
+  timer = mpls_malloc(sizeof(struct mpls_timer));
+  timer->unit = unit;
+  timer->duration = duration;
+  timer->extra = extra;
+  timer->g = g;
+  timer->callback = callback;
+  timer->active = 0;
+
+  return timer;
+}
+
+mpls_return_enum mpls_timer_modify(mpls_timer_mgr_handle handle,
+  mpls_timer_handle timer, int duration)
+{
+  if (!timer) {
+    return MPLS_FAILURE;
+  }
+  timer->duration = duration;
+  return MPLS_SUCCESS;
+}
+
+void mpls_timer_delete(mpls_timer_mgr_handle handle, mpls_timer_handle timer)
+{
+  if (timer) {
+    mpls_free(timer);
+  }
+}
+
+mpls_return_enum mpls_timer_start(mpls_timer_mgr_handle handle,
+  mpls_timer_handle timer, mpls_timer_type_enum type)
+{
+  if (!timer) {
+    return MPLS_FAILURE;
+  }
+  timer->type = type;
+  timer->timer = thread_add_timer(master,mpls_timer,timer,timer->duration);
+  timer->active = 1;
+  return MPLS_SUCCESS;
+}
+
+void mpls_timer_stop(mpls_timer_mgr_handle handle, mpls_timer_handle timer)
+{
+  if (timer && timer->active) {
+    thread_cancel(timer->timer);
+    timer->timer = NULL;
+  }
+}
diff --exclude=CVS -uNr zebra/mplsd/impl_tree.c zebra-ldp/mplsd/impl_tree.c
--- zebra/mplsd/impl_tree.c     1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/impl_tree.c 2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,158 @@
+#include <zebra.h>
+#include "table.h"
+
+#include "ldp_struct.h"
+#include "mpls_mm_impl.h"
+#include "mpls_tree_impl.h"
+
+mpls_tree_handle mpls_tree_create(int depth)
+{
+  return route_table_init();
+}
+
+mpls_return_enum mpls_tree_insert(mpls_tree_handle tree, uint32_t key, int length,
+  void *info)
+{
+  struct route_node *node;
+  struct prefix p;
+
+  p.family = AF_INET;
+  p.prefixlen = length;
+  p.u.prefix4.s_addr = key;
+
+  if ((node = route_node_get(tree,&p))) {
+    /* result is that the node is 'held', it will be held */
+    /* until it is deleted from the tree */
+    node->info = info;
+    return MPLS_SUCCESS;
+  }
+  return MPLS_FAILURE;
+}
+
+mpls_return_enum mpls_tree_remove(mpls_tree_handle tree, uint32_t key, int length,
+  void **info)
+{
+  struct route_node *node;
+  struct prefix p;
+
+  p.family = AF_INET;
+  p.prefixlen = length;
+  p.u.prefix4.s_addr = key;
+
+  if ((node = route_node_lookup(tree,&p))) {
+    *info = node->info;
+    node->info = NULL;
+    route_unlock_node(node);
+    route_unlock_node(node);
+    return MPLS_SUCCESS;
+  }
+  return MPLS_FAILURE;
+}
+
+mpls_return_enum mpls_tree_replace(mpls_tree_handle tree, uint32_t key, int length,
+  void *new, void **old)
+{
+  struct route_node *node;
+  struct prefix p;
+
+  p.family = AF_INET;
+  p.prefixlen = length;
+  p.u.prefix4.s_addr = key;
+
+  if ((node = route_node_lookup(tree,&p))) {
+    *old = node->info;
+    node->info = new;
+    route_unlock_node(node);
+    return MPLS_SUCCESS;
+  }
+  return MPLS_FAILURE;
+}
+
+mpls_return_enum mpls_tree_get(mpls_tree_handle tree, uint32_t key, int length,
+  void **info)
+{
+  struct route_node *node;
+  struct prefix p;
+
+  p.family = AF_INET;
+  p.prefixlen = length;
+  p.u.prefix4.s_addr = key;
+
+  if ((node = route_node_lookup(tree,&p))) {
+    *info = node->info;
+    route_unlock_node(node);
+    return MPLS_SUCCESS;
+  }
+  return MPLS_FAILURE;
+}
+
+mpls_return_enum mpls_tree_get_longest(mpls_tree_handle tree, uint32_t key,
+  void **info)
+{
+  struct route_node *node;
+  struct prefix p;
+
+  p.family = AF_INET;
+  p.prefixlen = 0;
+  p.u.prefix4.s_addr = key;
+
+  if ((node = route_node_match(tree,&p))) {
+    *info = node->info;
+    route_unlock_node(node);
+    return MPLS_SUCCESS;
+  }
+  return MPLS_FAILURE;
+}
+
+void mpls_tree_dump(const mpls_tree_handle tree, ldp_tree_callback callback)
+{
+}
+
+void mpls_tree_delete(mpls_tree_handle tree)
+{
+  route_table_finish(tree);
+}
+
+mpls_return_enum mpls_tree_getfirst(mpls_tree_handle tree, uint32_t * key,
+  int *length, void **info)
+{
+  struct route_node *node;
+  struct prefix p;
+
+  p.family = AF_INET;
+  p.prefixlen = 0;
+  p.u.prefix4.s_addr = 0;
+
+  if ((node = route_node_match(tree,&p))) {
+    *info = node->info;
+    *length = node->p.prefixlen;
+    *key = node->p.u.prefix4.s_addr;
+    route_unlock_node(node);
+    return MPLS_SUCCESS;
+  }
+  return MPLS_FAILURE;
+}
+
+mpls_return_enum mpls_tree_getnext(mpls_tree_handle tree, uint32_t * key,
+  int *length, void **info)
+{
+  struct route_node *node;
+  struct prefix p;
+
+  p.family = AF_INET;
+  p.prefixlen = *length;
+  p.u.prefix4.s_addr = *key;
+
+  if (!(node = route_node_match(tree,&p))) {
+    return MPLS_FAILURE;
+  }
+
+  if ((node = route_next(node))) {
+    *info = node->info;
+    *length = node->p.prefixlen;
+    *key = node->p.u.prefix4.s_addr;
+    route_unlock_node(node);
+    return MPLS_SUCCESS;
+  }
+  return MPLS_FAILURE;
+}
diff --exclude=CVS -uNr zebra/mplsd/ldp.c zebra-ldp/mplsd/ldp.c
--- zebra/mplsd/ldp.c   1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/ldp.c       2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,129 @@
+#include <zebra.h>
+
+#include "memory.h"
+#include "log.h"
+
+#include "ldp.h"
+#include "ldp_cfg.h"
+#include "ldp_struct.h"
+#include "ldp_interface.h"
+
+#include "mpls.h"
+#include "mpls_interface.h"
+
+int ldp_shutdown(struct ldp *ldp) {
+  ldp_global g;
+
+  g.admin_state = MPLS_ADMIN_DISABLE;
+  return ldp_cfg_global_set(ldp->h,&g,LDP_GLOBAL_CFG_ADMIN_STATE);
+}
+
+int ldp_startup(struct ldp *ldp) {
+  ldp_global g;
+
+  g.admin_state = MPLS_ADMIN_ENABLE;
+  return ldp_cfg_global_set(ldp->h,&g,LDP_GLOBAL_CFG_ADMIN_STATE);
+}
+
+int ldp_admin_state_start(struct ldp *ldp) {
+  if (ldp->admin_up == MPLS_BOOL_TRUE) {
+    return ldp_shutdown(ldp);
+  }
+  return MPLS_SUCCESS;
+}
+
+int ldp_admin_state_finish(struct ldp *ldp) {
+  if (ldp->admin_up == MPLS_BOOL_TRUE) {
+    return ldp_startup(ldp);
+  }
+  return MPLS_SUCCESS;
+}
+
+int do_ldp_router_id_update(struct ldp *ldp, unsigned int router_id) {
+    ldp_global g;
+    g.lsr_identifier.type = MPLS_FAMILY_IPV4;
+    g.lsr_identifier.u.ipv4 = router_id;
+    return ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_LSR_IDENTIFIER);
+}
+
+int ldp_router_id_update(struct ldp *ldp, struct prefix *router_id) {
+
+  zlog_info("router-id update %s", inet_ntoa(router_id->u.prefix4));
+
+  if (!ldp->lsr_id_is_static) {
+    ldp_admin_state_start(ldp);
+
+    do_ldp_router_id_update(ldp, ntohl(router_id->u.prefix4.s_addr));
+
+    ldp_admin_state_finish(ldp);
+  }
+  return 0;
+}
+
+static struct ldp *ldp_new(struct mpls *mpls) {
+    struct ldp *new = XMALLOC(MTYPE_MPLS_LDP, sizeof(struct ldp));
+    ldp_global g;
+
+    memset(new,0,sizeof(*new));
+
+    new->h = ldp_cfg_open(new);
+    new->admin_up = MPLS_BOOL_TRUE;
+    new->lsr_id_is_static = 0;
+    new->mpls = mpls;
+    new->egress = LDP_EGRESS_CONNECTED;
+    new->address = LDP_ADDRESS_ALL;
+
+    g.lsr_identifier.type = MPLS_FAMILY_IPV4;
+    g.lsr_identifier.u.ipv4 = ntohl(mpls->router_id.u.prefix4.s_addr);
+    g.admin_state = MPLS_ADMIN_ENABLE;
+#if MPLS_USE_LSR
+    g.lsr_handle = mpls->h;
+#endif
+    ldp_cfg_global_set(new->h,&g,
+      LDP_GLOBAL_CFG_LSR_IDENTIFIER|LDP_GLOBAL_CFG_LSR_HANDLE|
+      LDP_GLOBAL_CFG_ADMIN_STATE);
+
+    return new;
+}
+
+struct ldp *ldp_get() {
+    struct mpls_interface *mi;
+    struct interface *ifp;
+    listnode node;
+
+    struct mpls *mpls = mpls_get();
+    if (mpls->ldp) {
+       return mpls->ldp;
+    }
+
+    mpls->ldp = ldp_new(mpls); 
+    for (node = listhead(mpls->iflist); node; nextnode(node)) {
+        ifp = getdata(node);
+        mi = (struct mpls_interface*)ifp->info;
+        if (mi->ldp && mi->ldp->create_on_hold == MPLS_BOOL_TRUE) {
+            ldp_interface_create(mi);
+        }
+    }
+
+    return mpls->ldp;
+}
+
+void ldp_finish(struct ldp *ldp) {
+    struct mpls *mpls = ldp->mpls;
+    struct interface *ifp;
+    struct mpls_interface *mi;
+    listnode node;
+
+    for (node = listhead(mpls->iflist); node; nextnode(node)) {
+        ifp = getdata(node);
+        mi = (struct mpls_interface*)ifp->info;
+        if (mi->ldp && mi->ldp->entity.index) {
+            ldp_interface_delete(mi);
+        }
+    }
+
+    ldp_admin_state_start(ldp);
+    ldp_cfg_close(ldp->h);
+    XFREE(MTYPE_MPLS_LDP,ldp);
+    mpls->ldp = NULL;
+}
diff --exclude=CVS -uNr zebra/mplsd/ldp.h zebra-ldp/mplsd/ldp.h
--- zebra/mplsd/ldp.h   1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/ldp.h       2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,41 @@
+#ifndef LDP_H
+#define LDP_H
+
+#include <zebra.h>
+#include "prefix.h"
+
+#include "ldp_struct.h"
+
+struct mpls;
+
+typedef enum {
+    LDP_EGRESS_ALL,
+    LDP_EGRESS_LSRID,
+    LDP_EGRESS_CONNECTED
+} ldp_egress_mode;
+
+typedef enum {
+    LDP_ADDRESS_ALL,
+    LDP_ADDRESS_LSRID,
+    LDP_ADDRESS_LDP
+} ldp_address_mode;
+
+struct ldp {
+    struct mpls *mpls;
+    mpls_cfg_handle h;
+    mpls_bool admin_up;
+    mpls_bool lsr_id_is_static;
+    ldp_egress_mode egress;
+    ldp_address_mode address;
+};
+
+struct ldp *ldp_get();
+void ldp_init();
+int ldp_router_id_update(struct ldp *ldp, struct prefix *router_id);
+int do_ldp_router_id_update(struct ldp *ldp, unsigned int router_id);
+void ldp_finish(struct ldp *ldp);
+
+int ldp_admin_state_start(struct ldp *ldp);
+int ldp_admin_state_finish(struct ldp *ldp);
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/ldp_interface.c zebra-ldp/mplsd/ldp_interface.c
--- zebra/mplsd/ldp_interface.c 1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/ldp_interface.c     2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,117 @@
+#include <zebra.h>
+#include "memory.h"
+
+#include "ldp.h"
+#include "ldp_cfg.h"
+#include "ldp_struct.h"
+
+#include "mpls.h"
+#include "mpls_interface.h"
+
+struct ldp_interface *ldp_if_new(struct mpls_interface *mi) {
+    struct ldp_interface *li;
+
+    li = XMALLOC(MTYPE_MPLS_LDP, sizeof(struct ldp_interface));
+    memset(li, 0, sizeof(struct ldp_interface));
+    li->mi = mi;
+
+    li->admin_up = MPLS_BOOL_TRUE;
+    li->create_on_hold = MPLS_BOOL_FALSE;
+    ldp_entity_set_defaults(&li->entity);
+
+    return li;
+}
+
+void ldp_if_free(struct ldp_interface *li) {
+    XFREE(MTYPE_MPLS_LDP, li);
+}
+
+void ldp_interface_create(struct mpls_interface *mi) {
+    struct ldp *ldp = mi->mpls->ldp;
+
+    mi->ldp->create_on_hold = MPLS_BOOL_FALSE;
+
+    strncpy(mi->ldp->iff.name,mi->ifp->name,IFNAMSIZ);
+    mi->ldp->iff.label_space = mi->labelspace;
+
+    ldp_cfg_if_set(ldp->h, &mi->ldp->iff, LDP_CFG_ADD | LDP_IF_CFG_LABEL_SPACE);
+
+    mi->ldp->entity.sub_index = mi->ldp->iff.index;
+    mi->ldp->entity.entity_type = LDP_DIRECT;
+    mi->ldp->entity.admin_state = MPLS_OPER_DOWN;
+
+    ldp_cfg_entity_set(ldp->h, &mi->ldp->entity,
+       LDP_CFG_ADD | LDP_ENTITY_CFG_SUB_INDEX | LDP_ENTITY_CFG_ADMIN_STATE);
+
+    ldp_cfg_entity_get(ldp->h, &mi->ldp->entity, 0xFFFFFFFF);
+    ldp_cfg_if_get(ldp->h, &mi->ldp->iff, 0xFFFFFFFF);
+
+    ldp_interface_admin_state_finish(mi);
+}
+
+void ldp_interface_delete(struct mpls_interface *mi) {
+    struct ldp *ldp = mi->mpls->ldp;
+
+    mi->ldp->create_on_hold = MPLS_BOOL_TRUE;
+    mi->ldp->entity.admin_state = MPLS_OPER_DOWN;
+
+    if (ldp) {
+       ldp_interface_admin_state_start(mi);
+       ldp_cfg_entity_set(ldp->h, &mi->ldp->entity, LDP_CFG_DEL);
+       ldp_cfg_if_set(ldp->h, &mi->ldp->iff, LDP_CFG_DEL);
+    }
+    mi->ldp->entity.index = 0;
+    mi->ldp->iff.index = 0;
+}
+
+int ldp_interface_startup(struct mpls_interface *mi) {
+    struct ldp *ldp = mi->mpls->ldp;
+
+    if (!mi->ldp->iff.index) {
+       return MPLS_FAILURE;
+    }
+
+    mi->ldp->entity.admin_state = MPLS_OPER_UP;
+    ldp_cfg_entity_set(ldp->h, &mi->ldp->entity, LDP_ENTITY_CFG_ADMIN_STATE);
+
+    return MPLS_SUCCESS;
+}
+
+int ldp_interface_shutdown(struct mpls_interface *mi) {
+    struct ldp *ldp = mi->mpls->ldp;
+
+    if (!mi->ldp->iff.index) {
+       return MPLS_FAILURE;
+    }
+
+    mi->ldp->entity.admin_state = MPLS_ADMIN_DISABLE;
+    ldp_cfg_entity_set(ldp->h, &mi->ldp->entity, LDP_ENTITY_CFG_ADMIN_STATE);
+
+    return MPLS_SUCCESS;
+}
+
+int ldp_interface_admin_state_start(struct mpls_interface *mi) {
+  if (mi->ldp->admin_up == MPLS_BOOL_TRUE && mpls_if_is_up(mi)) {
+    return ldp_interface_shutdown(mi);
+  }
+  return MPLS_SUCCESS;
+}
+
+int ldp_interface_admin_state_finish(struct mpls_interface *mi) {
+  if (mi->ldp->admin_up == MPLS_BOOL_TRUE && mpls_if_is_up(mi)) {
+    return ldp_interface_startup(mi);
+  }
+  return MPLS_SUCCESS;
+}
+
+void ldp_if_up(struct mpls_interface *mi) {
+    if (mi->ldp && mi->ldp->admin_up == MPLS_BOOL_TRUE) {
+       ldp_interface_startup(mi);
+    }
+}
+
+void ldp_if_down(struct mpls_interface *mi) {
+    if (mi->ldp && mi->ldp->admin_up == MPLS_BOOL_TRUE) {
+       ldp_interface_shutdown(mi);
+    }
+}
diff --exclude=CVS -uNr zebra/mplsd/ldp_interface.h zebra-ldp/mplsd/ldp_interface.h
--- zebra/mplsd/ldp_interface.h 1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/ldp_interface.h     2003-02-26 15:47:43.000000000 -0600
@@ -0,0 +1,31 @@
+#ifndef LDP_IF_H
+#define LDP_IF_H
+
+#include "ldp_struct.h"
+
+struct mpls_interface;
+
+struct ldp_interface {
+    struct mpls_interface *mi;
+    ldp_entity entity;
+    ldp_if iff;
+    mpls_bool admin_up;
+    mpls_bool create_on_hold;
+};
+
+struct ldp_interface *ldp_if_new(struct mpls_interface *mi);
+void ldp_if_free(struct ldp_interface *li);
+
+void ldp_if_up(struct mpls_interface *mi);
+void ldp_if_down(struct mpls_interface *mi);
+
+int ldp_interface_startup(struct mpls_interface *mi);
+int ldp_interface_shutdown(struct mpls_interface *mi);
+
+void ldp_interface_create(struct mpls_interface *mi);
+void ldp_interface_delete(struct mpls_interface *mi);
+int ldp_interface_admin_state_start(struct mpls_interface *mi);
+int ldp_interface_admin_state_finish(struct mpls_interface *mi);
+
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/ldp_vty.c zebra-ldp/mplsd/ldp_vty.c
--- zebra/mplsd/ldp_vty.c       1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/ldp_vty.c   2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,2054 @@
+#include <zebra.h>
+
+#include "ldp.h"
+#include "ldp_cfg.h"
+#include "ldp_struct.h"
+#include "ldp_interface.h"
+
+#include "impl_mpls.h"
+
+#include "mpls.h"
+#include "mpls_interface.h"
+
+#include "command.h"
+#include "zclient.h"
+#include "vty.h"
+
+uint32_t ldp_traceflags = 0;
+uint8_t trace_buffer[16834];
+int trace_buffer_len = 0;
+
+char *session_state[6] = { "NONE", "NON-EXIST", "INIT",
+                           "OPENSENT", "OPENRECV", "OPERATIONAL" };
+char *adj_role[3] = { "INVALID", "PASSIVE", "ACTIVE" };
+char *attr_state[12] = { "REQ_RECV", "REQ_SENT", "MAP_RECV", "MAP_SENT",
+                         "WITH_SENT", "WITH_RECV", "NO_LABEL_RESOURCE_SENT",
+                         "NO_LABEL_RESOURCE_RECV", "ABORT_SENT", "ABORT_RECV",
+                         "NOTIF_SENT", "NOTIF_RECV" };
+char *oper_state[2] = { "UP", "DOWN" };
+char *control_mode[3] = { "UNKNOWN", "INDEPENDENT", "ORDERED" };
+char *retention_mode[3] = { "UNKNOWN", "LIBERAL", "CONSERVATIVE" };
+char *repair_mode[3] = { "UNKNOWN", "LOCAL", "GLOBAL" };
+char *loop_detect_mode[5] = { "NONE", "HOPCOUNT", "PATHVECTOR",
+                              "HOPCOUNT PATHVECTOR", "OTHER" };
+char *bool[2] = { "FALSE", "TRUE" };
+char *admin_state[3] = { "NONE", "ENABLED", "DISABLED" };
+char *distribution_mode[2] = { "UNSOLICITED", "ONDEMAND" };
+
+extern struct zclient *zclient;
+
+DEFUN (mpls_ldp,
+       mpls_ldp_cmd,
+       "mpls ldp",
+       "MPLS configuration\n"
+       "Start LDP configuration\n") {
+
+    vty->node = MPLS_LDP_NODE;
+    vty->index = ldp_get();
+
+    return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp,
+       no_mpls_ldp_cmd,
+       "no mpls ldp",
+       NO_STR
+       "MPLS configuration\n"
+       "Global LDP configuration\n") {
+    struct mpls *mpls = mpls_get();
+
+    if (!mpls->ldp) {
+       vty_out (vty, "There isn't active an LDP instance.%s", VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    ldp_finish(mpls->ldp);
+    return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_lsrid,
+       mpls_ldp_lsrid_cmd,
+       "lsr-id A.B.C.D",
+       "LDP Label Switch Router Identifier\n"
+       "IP Address\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+
+  ldp->lsr_id_is_static = MPLS_BOOL_TRUE;
+
+  ldp_admin_state_start(ldp);
+  do_ldp_router_id_update(ldp, ntohl(inet_addr(argv[0])));
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_lsrid,
+       no_mpls_ldp_lsrid_cmd,
+       "no lsr-id",
+       NO_STR
+       "LDP LSRID\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+
+  ldp->lsr_id_is_static = MPLS_BOOL_FALSE;
+
+  ldp_admin_state_start(ldp);
+  do_ldp_router_id_update(ldp, ntohl(ldp->mpls->router_id.u.prefix4.s_addr));
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_disable,
+       mpls_ldp_disable_cmd,
+       "disable",
+       "Disable\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+
+  ldp_admin_state_start(ldp);
+  ldp->admin_up = MPLS_BOOL_FALSE;
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_disable,
+       no_mpls_ldp_disable_cmd,
+       "no disable",
+       NO_STR
+       "Disable\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+
+  ldp_admin_state_start(ldp);
+  ldp->admin_up = MPLS_BOOL_TRUE;
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_lsp_control_mode,
+       mpls_ldp_lsp_control_mode_cmd,
+       "lsp-control-mode (independent|ordered)",
+       "control mode\n"
+       "independent or ordered control mode\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  if (!strcmp(argv[0],"independent")) {
+    g.lsp_control_mode = LDP_CONTROL_INDEPENDENT;
+  } else if (!strcmp(argv[0],"ordered")) {
+    g.lsp_control_mode = LDP_CONTROL_ORDERED;
+  } else {
+    return CMD_WARNING;
+  }
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_CONTROL_MODE);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_lsp_control_mode,
+       no_mpls_ldp_lsp_control_mode_cmd,
+       "no lsp-control-mode",
+       NO_STR
+       "control mode\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.lsp_control_mode = LDP_GLOBAL_DEF_CONTROL_MODE;
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_CONTROL_MODE);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_label_retention_mode,
+       mpls_ldp_label_retention_mode_cmd,
+       "label-retention-mode (liberal|conservative)",
+       "label retention mode\n"
+       "liberal or conservative retention mode\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  if (!strcmp(argv[0],"liberal")) {
+    g.label_retention_mode = LDP_RETENTION_LIBERAL;
+  } else if (!strcmp(argv[0],"conservative")) {
+    g.label_retention_mode = LDP_RETENTION_CONSERVATIVE;
+  } else {
+    return CMD_WARNING;
+  }
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_RETENTION_MODE);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_label_retention_mode,
+       no_mpls_ldp_label_retention_mode_cmd,
+       "no label-retention-mode",
+       NO_STR
+       "label retiontion mode\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.label_retention_mode = LDP_GLOBAL_DEF_RETENTION_MODE;
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_RETENTION_MODE);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_lsp_repair_mode,
+       mpls_ldp_lsp_repair_mode_cmd,
+       "lsp-repair-mode (local|global)",
+       "repair mode\n"
+       "local or global repair mode\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  if (!strcmp(argv[0],"local")) {
+    g.lsp_repair_mode = LDP_REPAIR_LOCAL;
+  } else if (!strcmp(argv[0],"global")) {
+    g.lsp_repair_mode = LDP_REPAIR_GLOBAL;
+  } else {
+    return CMD_WARNING;
+  }
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_REPAIR_MODE);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_lsp_repair_mode,
+       no_mpls_ldp_lsp_repair_mode_cmd,
+       "no lsp-repair-mode",
+       NO_STR
+       "repair mode\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.lsp_repair_mode = LDP_GLOBAL_DEF_REPAIR_MODE;
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_REPAIR_MODE);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_propogate_release,
+       mpls_ldp_propogate_release_cmd,
+       "propagate-release",
+       "propagate release\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.propagate_release = MPLS_BOOL_TRUE;
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_PROPOGATE_RELEASE);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_propogate_release,
+       no_mpls_ldp_propogate_release_cmd,
+       "no propagate-release",
+       NO_STR
+       "propagate release\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.propagate_release = MPLS_BOOL_FALSE;
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_PROPOGATE_RELEASE);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_label_merge,
+       mpls_ldp_label_merge_cmd,
+       "label-merge",
+       "label merge\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.label_merge = MPLS_BOOL_TRUE;
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_LABEL_MERGE);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_label_merge,
+       no_mpls_ldp_label_merge_cmd,
+       "no label-merge",
+       NO_STR
+       "label merge\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.label_merge = MPLS_BOOL_FALSE;
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_LABEL_MERGE);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_loop_detection_mode,
+       mpls_ldp_loop_detection_mode_cmd,
+       "loop-detection-mode (hop|path|both)",
+       "loop detection\n"
+       "Path Vector, Hop Count, or both\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  if (!strncmp(argv[0],"hop",3)) {
+    g.loop_detection_mode = LDP_LOOP_HOPCOUNT;
+  } else if (!strncmp(argv[0],"path",4)) {
+    g.loop_detection_mode = LDP_LOOP_PATHVECTOR;
+  } else if (!strncmp(argv[0],"both",4)) {
+    g.loop_detection_mode = LDP_LOOP_HOPCOUNT_PATHVECTOR;
+  } else {
+    return CMD_WARNING;
+  }
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_LOOP_DETECTION_MODE);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_loop_detection_mode,
+       no_mpls_ldp_loop_detection_mode_cmd,
+       "no loop-detection-mode (path|hop|both)",
+       NO_STR
+       "loop detection\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.loop_detection_mode = LDP_LOOP_NONE;
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_LOOP_DETECTION_MODE);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_ttl_less_domain,
+       mpls_ldp_ttl_less_domain_cmd,
+       "ttl-less-domain",
+       "TTL-less domain\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.ttl_less_domain = MPLS_BOOL_TRUE;
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_TTLLESS_DOMAIN);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_ttl_less_domain,
+       no_mpls_ldp_ttl_less_domain_cmd,
+       "no ttl-less-domain",
+       NO_STR
+       "TTL-less domain\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.ttl_less_domain = MPLS_BOOL_FALSE;
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_TTLLESS_DOMAIN);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_local_tcp_port,
+       mpls_ldp_local_tcp_port_cmd,
+       "local-tcp-port <1-65535>",
+       "local TCP port\n"
+       "TCP port number\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.local_tcp_port = atoi(argv[0]);
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_LOCAL_TCP_PORT);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_local_tcp_port,
+       no_mpls_ldp_local_tcp_port_cmd,
+       "no local-tcp-port",
+       NO_STR
+       "local TCP port\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.local_tcp_port = LDP_GLOBAL_DEF_LOCAL_TCP_PORT;
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_LOCAL_TCP_PORT);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_local_udp_port,
+       mpls_ldp_local_udp_port_cmd,
+       "local-udp-port <1-65535>",
+       "local UDP port\n"
+       "UDP port number\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.local_udp_port = atoi(argv[0]);
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_LOCAL_UDP_PORT);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_local_udp_port,
+       no_mpls_ldp_local_udp_port_cmd,
+       "no local-udp-port",
+       NO_STR
+       "local UDP port\n") {
+  struct ldp *ldp = (struct ldp*)vty->index;
+  ldp_global g;
+
+  g.local_udp_port = LDP_GLOBAL_DEF_LOCAL_UDP_PORT;
+
+  ldp_admin_state_start(ldp);
+  ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_LOCAL_UDP_PORT);
+  ldp_admin_state_finish(ldp);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_address,
+       mpls_ldp_trace_address_cmd,
+       "trace address",
+       "LDP debugging\n"
+       "Address PDUs\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_ADDRESS;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_binding,
+       mpls_ldp_trace_binding_cmd,
+       "trace binding",
+       "LDP debugging\n"
+       "Label Bindings\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_BINDING;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_debug,
+       mpls_ldp_trace_debug_cmd,
+       "trace debug",
+       "LDP debugging\n"
+       "Debug Messages\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_DEBUG;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_error,
+       mpls_ldp_trace_error_cmd,
+       "trace error",
+       "LDP debugging\n"
+       "Error Conditions\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_ERROR;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_event,
+       mpls_ldp_trace_event_cmd,
+       "trace event",
+       "LDP debugging\n"
+       "LDP Events\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_EVENT;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_general,
+       mpls_ldp_trace_general_cmd,
+       "trace general",
+       "LDP debugging\n"
+       "General Messages\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_GENERAL;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_init,
+       mpls_ldp_trace_init_cmd,
+       "trace init",
+       "LDP debugging\n"
+       "Init PDUs\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_INIT;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_label,
+       mpls_ldp_trace_label_cmd,
+       "trace label",
+       "LDP debugging\n"
+       "Label PDUs\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_LABEL;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_normal,
+       mpls_ldp_trace_normal_cmd,
+       "trace normal",
+       "LDP debugging\n"
+       "Normal Messages\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_NORMAL;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_notif,
+       mpls_ldp_trace_notif_cmd,
+       "trace notification",
+       "LDP debugging\n"
+       "Notification PDUs\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_NOTIF;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_packet_dump,
+       mpls_ldp_trace_packet_dump_cmd,
+       "trace packet-dump",
+       "LDP debugging\n"
+       "Packet Dump\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_PACKET_DUMP;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_packet,
+       mpls_ldp_trace_packet_cmd,
+       "trace packet",
+       "LDP debugging\n"
+       "Packet tracing\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_PACKET;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_path,
+       mpls_ldp_trace_path_cmd,
+       "trace path",
+       "LDP debugging\n"
+       "PATH Info\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_PATH;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_periodic,
+       mpls_ldp_trace_periodic_cmd,
+       "trace periodic",
+       "LDP debugging\n"
+       "Periodic PDUs\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_PERIODIC;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_policy,
+       mpls_ldp_trace_policy_cmd,
+       "trace policy",
+       "LDP debugging\n"
+       "Policy tracing\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_POLICY;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_route,
+       mpls_ldp_trace_route_cmd,
+       "trace route",
+       "LDP debugging\n"
+       "Route Lookup tracing\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_ROUTE;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_state,
+       mpls_ldp_trace_state_cmd,
+       "trace state",
+       "LDP debugging\n"
+       "State transitions\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_STATE;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_task,
+       mpls_ldp_trace_task_cmd,
+       "trace task",
+       "LDP debugging\n"
+       "Task tracing\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_TASK;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_timer,
+       mpls_ldp_trace_timer_cmd,
+       "trace timer",
+       "LDP debugging\n"
+       "Timer tracing\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_TIMER;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_all,
+       mpls_ldp_trace_all_cmd,
+       "trace all",
+       "LDP debugging\n"
+       "All tracing\n") {
+  ldp_traceflags |= LDP_TRACE_FLAG_ALL;
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_trace_none,
+       mpls_ldp_trace_none_cmd,
+       "trace none",
+       "LDP debugging\n"
+       "Turn off all tracing\n") {
+  ldp_traceflags = 0;
+  return CMD_SUCCESS;
+}
+
+/* address and egress changes should result in an event which goes through
+   all of the existing FECs/addresses and decides which to withdrawl and then
+   ask the system for which additional FECs/addresses should be sent */
+
+DEFUN (mpls_ldp_address,
+       mpls_ldp_address_cmd,
+       "address-mode (lsr-id|ldp)",
+       "Addresses this LSR will announce\n"
+       "LSR-ID only\n"
+       "Only LDP interfaces\n") {
+    struct ldp *ldp = (struct ldp*)vty->index;
+    if (!strncmp(argv[0], "lsr-id",6)) {
+       ldp->address = LDP_ADDRESS_LSRID;
+    } else if (!strncmp(argv[0], "ldp",3)) {
+       ldp->address = LDP_ADDRESS_LDP;
+    } else {
+       return CMD_WARNING;
+    }
+    return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_address,
+       no_mpls_ldp_address_cmd,
+       "no address-mode",
+       NO_STR
+       "Addresses this LSR will announce\n") {
+    struct ldp *ldp = (struct ldp*)vty->index;
+    ldp->address = LDP_ADDRESS_ALL;
+    return CMD_SUCCESS;
+}
+
+DEFUN (mpls_ldp_egress,
+       mpls_ldp_egress_cmd,
+       "egress (lsr-id|connected)",
+       "Filter FECs this LSR will send mappings for\n"
+       "LSR-ID only\n"
+       "All connected subnets\n") {
+    struct ldp *ldp = (struct ldp*)vty->index;
+    if (!strncmp(argv[0], "lsr-id",6)) {
+       ldp->egress = LDP_EGRESS_LSRID;
+    } else if (!strncmp(argv[0], "connected", 9)) {
+       ldp->egress = LDP_EGRESS_CONNECTED;
+    } else {
+       return CMD_WARNING;
+    }
+    return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_egress,
+       no_mpls_ldp_egress_cmd,
+       "no egress",
+       NO_STR
+       "Filter FECs this LSR will send mappings for\n") {
+    struct ldp *ldp = (struct ldp*)vty->index;
+    ldp->egress = LDP_EGRESS_ALL;
+    return CMD_SUCCESS;
+}
+
+#if 0
+DEFUN (mpls_ldp_egress_list,
+       mpls_ldp_egress_list_cmd,
+       "egress access-list (<1-199>|<1300-2699>|WORD)",
+       "Filter FECs this LSR will send mappings for\n"
+       "IP access-list number\n"
+       "IP access-list number (expanded range)\n"
+       "IP Access-list name\n") {
+    return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_ldp_egress_list,
+       no_mpls_ldp_egress_list_cmd,
+       "no egress access-list (<1-199>|<1300-2699>|WORD)",
+       NO_STR
+       "Filter FECs this LSR will send mappings for\n"
+       "IP access-list number\n"
+       "IP access-list number (expanded range)\n"
+       "IP Access-list name\n") {
+    return CMD_SUCCESS;
+}
+#endif
+
+DEFUN (mpls_show_ldp, mpls_show_ldp_cmd,
+       "show ldp",
+       SHOW_STR
+       "LDP global setting\n") {
+    struct mpls *mpls = mpls_get();
+    ldp_global g;
+
+    if (!mpls->ldp) {
+       vty_out (vty, "There isn't an active LDP instance.%s", VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    ldp_cfg_global_get(mpls->ldp->h,&g,0xFFFFFFFF);
+
+    vty_out(vty, "LSR-ID: %08x Admin State: %s%s",
+      g.lsr_identifier.u.ipv4, admin_state[g.admin_state], VTY_NEWLINE);
+    vty_out(vty, "Transport Address: %08x%s", g.transport_address.u.ipv4,
+      VTY_NEWLINE);
+    vty_out(vty, "Control Mode: %s\tRepair Mode: %s%s",
+      control_mode[g.lsp_control_mode], repair_mode[g.lsp_repair_mode],
+      VTY_NEWLINE);
+    vty_out(vty, "Propogate Release: %s\tLabel Merge: %s%s",
+      bool[g.propagate_release], bool[g.label_merge], VTY_NEWLINE);
+    vty_out(vty, "Retention Mode: %s\tLoop Detection Mode: %s%s",
+      retention_mode[g.label_retention_mode],
+      loop_detect_mode[g.loop_detection_mode], VTY_NEWLINE);
+    vty_out(vty, "TTL-less-domain: %s%s", bool[g.ttl_less_domain],
+      VTY_NEWLINE);
+    vty_out(vty, "Local TCP Port: %d\tLocal UDP Port: %d%s",
+      g.local_tcp_port, g.local_udp_port, VTY_NEWLINE);
+    vty_out(vty, "Keep-alive Time: %d\tKeep-alive Interval: %d%s",
+      g.keepalive_timer, g.keepalive_interval, VTY_NEWLINE);
+    vty_out(vty, "Hello Time: %d\tHello Interval: %d%s",
+      g.hellotime_timer, g.hellotime_interval, VTY_NEWLINE);
+
+    return CMD_SUCCESS;
+}
+
+void convert_seconds_to_string(uint32_t secs, char* buf) {
+  div_t mins;
+  div_t hours;
+  div_t days;
+  int h = 0;
+  int m = 0;
+  int s = 0;
+
+  if (secs >= 60) {
+    mins = div(secs, 60);
+    if (mins.quot >= 60) {
+      hours = div(mins.quot, 60);
+      if (hours.quot >= 24) {
+        days = div(hours.quot, 24);
+        h = days.rem;
+        m = hours.rem;
+        s = mins.rem;
+        sprintf(buf, "%dd %02d:%02d:%02d", days.quot, h, m, s);
+        return;
+      } else {
+        h = hours.quot;
+        m = hours.rem;
+        s = mins.rem;
+      }
+    } else {
+      h = 0;
+      m = mins.quot;
+      s = mins.rem;
+    }
+  } else {
+    h = 0;
+    m = 0;
+    s = secs;
+  }
+  sprintf(buf,"%02d:%02d:%02d", h, m, s);
+}
+
+DEFUN (mpls_show_ldp_neighbor, mpls_show_ldp_neighbor_cmd,
+       "show ldp neighbor",
+       SHOW_STR
+       "LDP related commands\n"
+       "Discovered neighbors\n"
+       "LDP identifier\n") {
+  struct mpls *mpls = mpls_get();
+  struct ldp *ldp = mpls->ldp;
+  ldp_adj adj;
+  ldp_addr addr;
+  ldp_entity e;
+  ldp_global g;
+  ldp_session s;
+  int count;
+  int addr_count;
+  uint32_t time_now;
+  char time_buf[13];
+  struct in_addr lsr;
+  struct in_addr src;
+  struct in_addr tr;
+  int label_space = 0;
+  ldp_if iff;
+  ldp_peer peer;
+
+#if 0
+
+Peer LDP Ident: 7.1.1.1:0; Local LDP Ident 8.1.1.1:0
+        TCP connection: 7.1.1.1.646 - 8.1.1.1.11006
+        State: Oper; Msgs sent/rcvd: 4/411; Downstream
+        Up time: 00:00:52
+        LDP discovery sources:
+          Ethernet1/0/0
+        Addresses bound to peer LDP Ident:
+          2.0.0.29        7.1.1.1         59.0.0.199      212.10.1.1
+          10.205.0.9
+
+#endif
+
+    if (!ldp) {
+       vty_out (vty, "There isn't an active LDP instance.%s", VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    ldp_cfg_global_get(ldp->h,&g,0xFFFFFFFF);
+
+    count = 0;
+    adj.index = 0;
+    while (ldp_cfg_adj_getnext(ldp->h, &adj, 0xFFFFFFFF) ==
+      MPLS_SUCCESS) {
+      count++;
+
+      if (adj.entity_index) {
+        e.index = adj.entity_index;
+        ldp_cfg_entity_get(ldp->h,&e,0xFFFFFFFF);
+        if (e.entity_type == LDP_DIRECT) {
+          iff.index = e.sub_index;
+          ldp_cfg_if_get(ldp->h,&iff,0xFFFFFFFF);
+          label_space = iff.label_space;
+        } else {
+          peer.index = e.sub_index;
+          ldp_cfg_peer_get(ldp->h,&peer,0xFFFFFFFF);
+          label_space = peer.label_space;
+        }
+      }
+
+      lsr.s_addr = htonl(adj.remote_lsr_address.u.ipv4);
+      vty_out(vty, "Peer LDP Ident: %s:%d; Local LDP Ident: ", inet_ntoa(lsr),
+        adj.remote_label_space);
+      lsr.s_addr = htonl(g.lsr_identifier.u.ipv4);
+      vty_out(vty, "%s:%d%s", inet_ntoa(lsr), label_space, VTY_NEWLINE);
+
+      if (adj.session_index) {
+        s.index = adj.session_index;
+
+        if (ldp_cfg_session_get(ldp->h,&s,0xFFFFFFFF) != MPLS_SUCCESS) {
+         continue;
+        }
+
+        tr.s_addr = 0;
+        vty_out(vty, "\tTCP connection: %s.%d", inet_ntoa(tr),
+          g.local_tcp_port);
+
+        src.s_addr = htonl(s.remote_dest.addr.u.ipv4);
+        vty_out(vty, " - %s.%d%s", inet_ntoa(src), s.remote_dest.port,
+          VTY_NEWLINE);
+
+        vty_out(vty, "\tState: %s; Msgs sent/recv: %d/%d; %s%s",
+          session_state[s.state], s.mesg_tx, s.mesg_rx,
+          distribution_mode[s.oper_distribution_mode], VTY_NEWLINE);
+        time_now = time(NULL);
+        convert_seconds_to_string(time_now - s.oper_up, time_buf);
+        vty_out(vty, "\tUp time: %s%s", time_buf, VTY_NEWLINE);
+
+        vty_out(vty, "\tLDP discovery sources:%s", VTY_NEWLINE);
+      } else {
+        vty_out(vty, "\tTCP connection: %s%s", "n/a", VTY_NEWLINE);
+        vty_out(vty, "\tState: discovery; Msgs sent/recv: -/-;%s",VTY_NEWLINE);
+        vty_out(vty, "\tUp time: %s%s", "-", VTY_NEWLINE);
+        vty_out(vty, "\tLDP discovery sources:%s", VTY_NEWLINE);
+      }
+      vty_out(vty, "\t  ");
+
+      if (e.entity_type == LDP_DIRECT) {
+        vty_out(vty, "%s ", iff.name);
+      } else {
+        vty_out(vty, "%s ", peer.peer_name);
+      }
+      vty_out(vty, "%s", VTY_NEWLINE);
+
+      if (adj.session_index) {
+        vty_out(vty, "\tAddresses bound to peer:%s", VTY_NEWLINE);
+
+        addr.index = 0;
+        addr_count = 0;
+        while (ldp_cfg_session_raddr_getnext(ldp->h, &s, &addr, 0xFFFFFFFF) ==
+          MPLS_SUCCESS) {
+          lsr.s_addr = htonl(addr.address.u.ipv4);
+          vty_out(vty, "\t");
+          if (!addr_count) {
+            vty_out(vty, "  ");
+          }
+
+          vty_out(vty, "%s",inet_ntoa(lsr));
+          addr_count++;
+
+          if (addr_count == 4) {
+            vty_out(vty, "%s", VTY_NEWLINE);
+            addr_count = 0;
+          }
+        }
+        vty_out(vty, "%s", VTY_NEWLINE);
+      }
+    }
+    vty_out(vty, "%s", VTY_NEWLINE);
+    if (count == 0) {
+      vty_out(vty, "\tNo discovered neighbors%s", VTY_NEWLINE);
+    }
+  vty_out(vty, "%s", VTY_NEWLINE);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_show_ldp_session, mpls_show_ldp_session_cmd,
+       "show ldp session [A.B.C.D:E]",
+       SHOW_STR
+       "LDP related commands\n"
+       "Session information\n"
+       "LDP identifier\n") {
+  struct mpls *mpls = mpls_get();
+  struct ldp *ldp = mpls->ldp;
+  ldp_session session;
+  ldp_addr addr;
+  struct in_addr in;
+  int count = 0;
+
+    if (!ldp) {
+       vty_out (vty, "There isn't active LDP instance.%s", VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    session.index = 0;
+    while (ldp_cfg_session_getnext(ldp->h, &session, 0xFFFFFFFF) == MPLS_SUCCESS) {
+      count++;
+      in.s_addr = htonl(session.remote_dest.addr.u.ipv4);
+      vty_out(vty, "%-2d %s %-3d %s%s", session.index,
+        inet_ntoa(in), session.oper_keepalive,
+        session_state[session.state], VTY_NEWLINE);
+      addr.index = 0;
+      while (ldp_cfg_session_raddr_getnext(ldp->h, &session,
+        &addr, 0xFFFFFFFF) == MPLS_SUCCESS) {
+        in.s_addr = htonl(addr.address.u.ipv4);
+        vty_out(vty, "\t%s%s",inet_ntoa(in), VTY_NEWLINE);
+      }
+    }
+    if (count == 0) {
+      vty_out(vty, "    no established sessions%s", VTY_NEWLINE);
+    }
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (mpls_show_ldp_discovery, mpls_show_ldp_discovery_cmd,
+       "show ldp discovery",
+       SHOW_STR
+       "LDP related commands\n"
+       "Discovery information\n") {
+  struct mpls *mpls = mpls_get();
+  struct ldp *ldp = mpls->ldp;
+  ldp_if iff;
+  int count;
+  ldp_global g;
+  ldp_adj adj;
+  ldp_entity entity;
+  ldp_peer peer;
+  struct in_addr dst;
+  int first;
+
+    if (!ldp) {
+       vty_out (vty, "There isn't an active LDP instance.%s", VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+  vty_out(vty, "%s", VTY_NEWLINE);
+
+    ldp_cfg_global_get(ldp->h,&g,0xFFFFFFFF);
+    dst.s_addr = htonl(g.lsr_identifier.u.ipv4);
+    vty_out(vty, "Local LSR Identifier: %s%s", inet_ntoa(dst), VTY_NEWLINE);
+    vty_out(vty, "%s", VTY_NEWLINE);
+    vty_out(vty, "Interface Discovery Sources:%s", VTY_NEWLINE);
+
+    count = 0;
+    iff.index = 0;
+    while (ldp_cfg_if_getnext(ldp->h, &iff, 0xFFFFFFFF) == MPLS_SUCCESS) {
+      first = 1;
+      count++;
+      vty_out(vty, "\t%s: ", iff.name);
+      if (iff.oper_state != MPLS_OPER_UP) {
+        vty_out(vty, "down");
+      } else {
+        vty_out(vty, "xmit");
+        entity.index = iff.entity_index;
+       if (ldp_cfg_entity_get(ldp->h, &entity, 0xFFFFFFFF) != MPLS_SUCCESS) {
+          continue;
+       }
+        do {
+          adj.index = entity.adj_index;
+          if (ldp_cfg_adj_get(ldp->h, &adj, 0xFFFFFFFF) == MPLS_SUCCESS) {
+            if (first) {
+              vty_out(vty, "/recv%s", VTY_NEWLINE);
+              first = 0;
+            }
+            dst.s_addr = htonl(adj.remote_lsr_address.u.ipv4);
+            vty_out(vty, "\t    LDP Id: %s:%d%s ", inet_ntoa(dst),
+              adj.remote_label_space, VTY_NEWLINE);
+          }
+        } while (ldp_cfg_entity_adj_getnext(ldp->h, &entity) == MPLS_SUCCESS);
+      }
+      if (first) {
+        vty_out(vty, "%s", VTY_NEWLINE);
+      }
+    }
+    if (count == 0) {
+      vty_out(vty, "\tNo configured interfaces%s", VTY_NEWLINE);
+    }
+
+    vty_out(vty, "%s", VTY_NEWLINE);
+    vty_out(vty, "Targeted Discovery Sources:%s", VTY_NEWLINE);
+
+    count = 0;
+    peer.index = 0;
+    while (ldp_cfg_peer_getnext(ldp->h, &peer, 0xFFFFFFFF) ==
+      MPLS_SUCCESS) {
+      first = 1;
+      count++;
+      dst.s_addr = htonl(peer.dest.addr.u.ipv4);
+      vty_out(vty, "\t%s: xmit ", inet_ntoa(dst));
+      while (ldp_cfg_adj_getnext(ldp->h, &adj, 0xFFFFFFFF) == MPLS_SUCCESS) {
+        if (peer.entity_index == adj.entity_index) {
+          if (first) {
+            vty_out(vty, "/recv%s", VTY_NEWLINE);
+            first = 0;
+          }
+          dst.s_addr = htonl(adj.remote_lsr_address.u.ipv4);
+          vty_out(vty, "\t    LDP Id: %s:%d%s ", inet_ntoa(dst),
+            adj.remote_label_space, VTY_NEWLINE);
+        }
+      }
+      if (first) {
+        vty_out(vty, "%s", VTY_NEWLINE);
+      }
+    }
+    if (count == 0) {
+      vty_out(vty, "\tNo configured peers%s", VTY_NEWLINE);
+    }
+  vty_out(vty, "%s", VTY_NEWLINE);
+
+  return CMD_SUCCESS;
+}
+
+void ldp_print_label(struct vty *vty, mpls_label_struct *l) {
+  switch(l->type) {
+    case MPLS_LABEL_TYPE_NONE:
+      vty_out(vty, "label: unknown");
+      break;
+    case MPLS_LABEL_TYPE_GENERIC:
+      vty_out(vty, "label: gen %d",l->u.gen);
+      break;
+    case MPLS_LABEL_TYPE_ATM:
+      vty_out(vty, "label: atm %d/%d",l->u.atm.vpi,l->u.atm.vci);
+      break;
+    case MPLS_LABEL_TYPE_FR:
+      vty_out(vty, "label: dlci %d",l->u.fr.dlci);
+      break;
+  }
+}
+
+DEFUN (mpls_show_ldp_database, mpls_show_ldp_database_cmd,
+       "show ldp database [A.B.C.D:E]",
+       SHOW_STR
+       "LDP related commands\n"
+       "Labeling information\n"
+       "LDP identifier\n") {
+  struct mpls *mpls = mpls_get();
+  struct ldp *ldp = mpls->ldp;
+  ldp_session session;
+  ldp_outlabel out;
+  ldp_inlabel in;
+  ldp_attr attr;
+  ldp_adj adj;
+  int count = 0;
+  struct in_addr fec;
+
+    if (!ldp) {
+       vty_out (vty, "There isn't an active LDP instance.%s", VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    attr.index = 0;
+    while (ldp_cfg_attr_getnext(ldp->h, &attr, 0xFFFFFFFF) == MPLS_SUCCESS) {
+      count++;
+
+      fec.s_addr = htonl(attr.fecTlv.fecElArray[0].addressEl.address);
+
+      vty_out(vty, "  %s/%d  ", inet_ntoa(fec),
+        attr.fecTlv.fecElArray[0].addressEl.preLen);
+
+      session.index = attr.session_index;
+      if (ldp_cfg_session_get(ldp->h, &session, 0xFFFFFFFF) != MPLS_SUCCESS) {
+        vty_out(vty, "no session%s",VTY_NEWLINE);
+        continue;
+      }
+
+      adj.index = session.adj_index;
+      if (ldp_cfg_adj_get(ldp->h, &adj, 0xFFFFFFFF) != MPLS_SUCCESS) {
+        vty_out(vty, "no adj%s",VTY_NEWLINE);
+        continue;
+      }
+
+      switch(attr.state) {
+        case LDP_LSP_STATE_MAP_RECV:
+          vty_out(vty, "remote binding:  ");
+          out.index = attr.outlabel_index;
+          if (ldp_cfg_outlabel_get(ldp->h, &out, 0xFFFFFFFF) != MPLS_SUCCESS) {
+            vty_out(vty, "no outlabel");
+          } else {
+            ldp_print_label(vty,&out.info.label);
+          }
+          fec.s_addr = htonl(adj.remote_lsr_address.u.ipv4);
+          vty_out(vty, " lsr: %s:%d ", inet_ntoa(fec), adj.remote_label_space);
+          if (attr.ingress == MPLS_BOOL_TRUE) {
+            vty_out(vty, "ingress");
+          }
+          break;
+        case LDP_LSP_STATE_MAP_SENT:
+          in.index = attr.inlabel_index;
+          if (ldp_cfg_inlabel_get(ldp->h, &in, 0xFFFFFFFF) != MPLS_SUCCESS) {
+            vty_out(vty, "no inlabel%s", VTY_NEWLINE);
+            continue;
+          }
+          vty_out(vty, "local binding:   ");
+          ldp_print_label(vty,&in.info.label);
+          break;
+        case LDP_LSP_STATE_WITH_SENT:
+        case LDP_LSP_STATE_WITH_RECV:
+        case LDP_LSP_STATE_NO_LABEL_RESOURCE_SENT:
+        case LDP_LSP_STATE_NO_LABEL_RESOURCE_RECV:
+        case LDP_LSP_STATE_ABORT_SENT:
+        case LDP_LSP_STATE_ABORT_RECV:
+        case LDP_LSP_STATE_NOTIF_SENT:
+        case LDP_LSP_STATE_NOTIF_RECV:
+        case LDP_LSP_STATE_REQ_RECV:
+        case LDP_LSP_STATE_REQ_SENT:
+          vty_out(vty, "%s:\t", attr_state[attr.state]);
+          fec.s_addr = htonl(adj.remote_lsr_address.u.ipv4);
+          vty_out(vty, "lsr: %s:%d", inet_ntoa(fec), adj.remote_label_space);
+          break;
+        default:
+         break;
+      }
+      vty_out(vty, "%s", VTY_NEWLINE);
+    }
+    if (count == 0) {
+      vty_out(vty, "    no labeling info has been exchanged%s", VTY_NEWLINE);
+    }
+
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_intf,
+      ldp_intf_cmd,
+      "mpls ldp",
+      "MPLS interface configuration\n"
+      "Enable LDP\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct mpls *mpls = mi->mpls;
+
+  if (!mi->ldp) {
+    /* user is trying to create a new LDP interface */
+    /* if a labelspace hasn't been set yet, set it to 0 */
+    if (mi->labelspace == -1) {
+      mi->labelspace = 0;
+      do_mpls_labelspace(mi);
+    }
+    mi->ldp = ldp_if_new(mi);
+  }
+
+  /* if the global LDP has been created, go ahead and tell LDP about it
+   * otherwise just mark the interface as "on hold"
+   */
+  if (mpls->ldp) {
+    ldp_interface_create(mi);
+  } else {
+    mi->ldp->create_on_hold = MPLS_BOOL_TRUE;
+  }
+
+  vty->node = MPLS_LDP_IF_NODE;
+
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_intf,
+      no_ldp_intf_cmd,
+      "no mpls ldp",
+      NO_STR
+      "MPLS interface configuration\n"
+      "remove LDP\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+
+  if (mi->ldp) {
+    ldp_interface_delete(mi);
+    ldp_if_free(mi->ldp);
+    mi->ldp = NULL;
+  }
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_distribution_mode,
+      ldp_if_distribution_mode_cmd,
+      "distribution-mode (dod|du)",
+      "MPLS interface configuration\n"
+      "distribution mode\n"
+      "Downstream on Demand or Downstream unsolicited\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  if (!strncmp(argv[0],"dod",3)) {
+    li->entity.label_distribution_mode = LDP_DISTRIBUTION_ONDEMAND;
+  } else if (!strncmp(argv[0],"du",2)) {
+    li->entity.label_distribution_mode = LDP_DISTRIBUTION_UNSOLICITED;
+  } else {
+    return CMD_WARNING;
+  }
+
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+  ldp_interface_admin_state_start(mi);
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_DISTRIBUTION_MODE);
+  ldp_interface_admin_state_finish(mi);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_distribution_mode,
+      no_ldp_if_distribution_mode_cmd,
+      "no distribution-mode",
+      NO_STR
+      "MPLS interface configuration\n"
+      "distribution mode\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.label_distribution_mode = LDP_ENTITY_DEF_DISTRIBUTION_MODE;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_DISTRIBUTION_MODE);
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_remote_tcp_port,
+      ldp_if_remote_tcp_port_cmd,
+      "remote-tcp-port <1-65535>",
+      "MPLS interface configuration\n"
+      "remote LDP port\n"
+      "port number\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.remote_tcp_port = atoi(argv[0]);
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_REMOTE_TCP);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_remote_tcp_port,
+      no_ldp_if_remote_tcp_port_cmd,
+      "no remote-tcp-port",
+      NO_STR
+      "MPLS interface configuration\n"
+      "remote LDP port\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+
+  li->entity.remote_tcp_port = LDP_ENTITY_DEF_REMOTE_TCP;
+  if (!mpls->ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(mpls->ldp->h, &li->entity, LDP_ENTITY_CFG_REMOTE_TCP);
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_remote_udp_port,
+      ldp_if_remote_udp_port_cmd,
+      "remote-udp-port <1-65535>",
+      "MPLS interface configuration\n"
+      "remote LDP port\n"
+      "port number\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.remote_udp_port = atoi(argv[0]);
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_REMOTE_UDP);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_remote_udp_port,
+      no_ldp_if_remote_udp_port_cmd,
+      "no remote-udp-port",
+      NO_STR
+      "MPLS interface configuration\n"
+      "remote LDP port\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.remote_udp_port = LDP_ENTITY_DEF_REMOTE_UDP;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_REMOTE_UDP);
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_max_pdu,
+      ldp_if_max_pdu_cmd,
+      "max-pdu <64-9182>",
+      "MPLS interface configuration\n"
+      "maximum LDP PDU size\n"
+      "PDU size\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.max_pdu = atoi(argv[0]);
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_MAX_PDU);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_max_pdu,
+      no_ldp_if_max_pdu_cmd,
+      "no max-pdu",
+      NO_STR
+      "MPLS interface configuration\n"
+      "maximum LDP pdu size\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.max_pdu = LDP_ENTITY_DEF_MAX_PDU;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_MAX_PDU);
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_hello_interval,
+      ldp_if_hello_interval_cmd,
+      "hello-interval <1-60>",
+      "MPLS interface configuration\n"
+      "hello interval\n"
+      "interval in seconds\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.hellotime_interval = atoi(argv[0]);
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_HELLOTIME_INTERVAL);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_hello_interval,
+      no_ldp_if_hello_interval_cmd,
+      "no hello-interval",
+      NO_STR
+      "MPLS interface configuration\n"
+      "hello interval\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.hellotime_interval = LDP_ENTITY_DEF_HELLOTIME_INTERVAL;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_HELLOTIME_INTERVAL);
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_keepalive_interval,
+      ldp_if_keepalive_interval_cmd,
+      "keepalive-interval <1-60>",
+      "MPLS interface configuration\n"
+      "keepalive interval\n"
+      "interval in seconds\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.keepalive_interval = atoi(argv[0]);
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_KEEPALIVE_INTERVAL);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_keepalive_interval,
+      no_ldp_if_keepalive_interval_cmd,
+      "no keepalive-interval",
+      NO_STR
+      "MPLS interface configuration\n"
+      "keepalive interval\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.keepalive_interval = LDP_ENTITY_DEF_KEEPALIVE_INTERVAL;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_KEEPALIVE_INTERVAL);
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_max_session_attempt,
+      ldp_if_max_session_attempt_cmd,
+      "max-session-attempt <0-1024>",
+      "MPLS interface configuration\n"
+      "maximum LDP session setup attempt\n"
+      "Number of attempts (0 means keep trying)\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.session_setup_count = atoi(argv[0]);
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_SESSION_SETUP_COUNT);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_max_session_attempt,
+      no_ldp_if_max_session_attempt_cmd,
+      "no max-session-attempt\n",
+      NO_STR
+      "MPLS interface configuration\n"
+      "maximum LDP session setup attempt\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.session_setup_count = LDP_ENTITY_DEF_SESSIONSETUP_COUNT;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_SESSION_SETUP_COUNT);
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_max_path_vector,
+      ldp_if_max_path_vector_cmd,
+      "max-path-vector <1-255>",
+      "MPLS interface configuration\n"
+      "maximum path vector\n"
+      "number of entries\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.path_vector_limit = atoi(argv[0]);
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_PATHVECTOR_LIMIT);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_max_path_vector,
+      no_ldp_if_max_path_vector_cmd,
+      "no max-path-vector",
+      NO_STR
+      "MPLS interface configuration\n"
+      "maximum path vector\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.path_vector_limit = LDP_ENTITY_DEF_PATHVECTOR_LIMIT;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_PATHVECTOR_LIMIT);
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_max_hop_count,
+      ldp_if_max_hop_count_cmd,
+      "max-hop-count <1-1024>",
+      "MPLS interface configuration\n"
+      "maximum hop count\n"
+      "number of hops\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.hop_count_limit = atoi(argv[0]);
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_HOPCOUNT_LIMIT);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_max_hop_count,
+      no_ldp_if_max_hop_count_cmd,
+      "no max-hop-count",
+      NO_STR
+      "MPLS interface configuration\n"
+      "maximum hop count\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.hop_count_limit = LDP_ENTITY_DEF_HOPCOUNT_LIMIT;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_HOPCOUNT_LIMIT);
+  return CMD_SUCCESS;
+}
+
+DEFUN(ldp_if_max_label_requests,
+      ldp_if_max_label_requests_cmd,
+      "max-label-requests <0-1024>",
+      "MPLS interface configuration\n"
+      "maximum times to make a request for a FEC\n"
+      "Number of attempts (0 means keep trying)\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.label_request_count = atoi(argv[0]);
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_REQUEST_COUNT);
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_max_label_requests,
+      no_ldp_if_max_label_requests_cmd,
+      "no max-label-requests",
+      NO_STR
+      "MPLS interface configuration\n"
+      "maximum times to make a request for a FEC\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.label_request_count = LDP_ENTITY_DEF_REQUEST_COUNT;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  ldp_cfg_entity_set(ldp->h, &li->entity, LDP_ENTITY_CFG_REQUEST_COUNT);
+  return CMD_SUCCESS;
+}
+
+#if 0
+DEFUN(ldp_if_ttl_less_domain,
+      ldp_if_ttl_less_domain_cmd,
+      "ttl-less-domain",
+      "MPLS interface configuration\n"
+      "TTL less domain\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.remote_in_ttl_less_domain = MPLS_BOOL_TRUE;
+  if (!ldp) {
+    li->create_on_hold = MPLS_BOOL_TRUE;
+    return CMD_SUCCESS;
+  }
+
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_ldp_if_ttl_less_domain,
+      no_ldp_if_ttl_less_domain_cmd,
+      "no ttl-less-domain",
+      NO_STR
+      "MPLS interface configuration\n"
+      "TTL less domain\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct ldp_interface *li = mi->ldp;
+  struct mpls *mpls = mi->mpls;
+  struct ldp *ldp = mpls->ldp;
+
+  li->entity.remote_in_ttl_less_domain = MPLS_BOOL_FALSE;
+  if (!ldp) {
+    return CMD_SUCCESS;
+  }
+
+  return CMD_SUCCESS;
+}
+#endif
+
+static int ldp_if_config_write (struct vty *vty) {
+  return 0;
+}
+
+static int ldp_config_write (struct vty *vty) {
+  struct mpls *mpls = mpls_get();
+  struct ldp *ldp = mpls->ldp;
+  ldp_global g;
+  int write = 0;
+
+  if (ldp) {
+    vty_out (vty, "!%s", VTY_NEWLINE);
+    vty_out (vty, "mpls ldp%s", VTY_NEWLINE);
+    write++;
+
+    if (ldp_traceflags & LDP_TRACE_FLAG_ADDRESS)
+      vty_out (vty, " trace address%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_BINDING)
+      vty_out (vty, " trace binding%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_DEBUG)
+      vty_out (vty, " trace debug%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_ERROR)
+      vty_out (vty, " trace error%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_EVENT)
+      vty_out (vty, " trace event%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_GENERAL)
+      vty_out (vty, " trace general%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_INIT)
+      vty_out (vty, " trace init%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_LABEL)
+      vty_out (vty, " trace label%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_NORMAL)
+      vty_out (vty, " trace normal%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_NOTIF)
+      vty_out (vty, " trace notification%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_PACKET_DUMP)
+      vty_out (vty, " trace packet-dump%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_PACKET)
+      vty_out (vty, " trace packet%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_PATH)
+      vty_out (vty, " trace path%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_PERIODIC)
+      vty_out (vty, " trace periodic%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_POLICY)
+      vty_out (vty, " trace policy%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_ROUTE)
+      vty_out (vty, " trace route%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_STATE)
+      vty_out (vty, " trace state%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_TASK)
+      vty_out (vty, " trace task%s", VTY_NEWLINE);
+    if (ldp_traceflags & LDP_TRACE_FLAG_TIMER)
+      vty_out (vty, " trace timer%s", VTY_NEWLINE);
+
+    ldp_cfg_global_get(ldp->h,&g, 0xFFFFFFFF);
+
+    if (g.lsp_control_mode != LDP_GLOBAL_DEF_CONTROL_MODE) {
+      vty_out (vty, " lsp-control-mode ");
+      if (g.lsp_control_mode == LDP_CONTROL_INDEPENDENT) {
+        vty_out (vty, "independent%s", VTY_NEWLINE);
+      } else {
+        vty_out (vty, "ordered%s", VTY_NEWLINE);
+      }
+    }
+    if (g.label_retention_mode != LDP_GLOBAL_DEF_RETENTION_MODE) {
+      vty_out (vty, " label-retention-mode ");
+      if (g.label_retention_mode == LDP_RETENTION_LIBERAL) {
+        vty_out (vty, "liberal%s", VTY_NEWLINE);
+      } else {
+        vty_out (vty, "conservative%s", VTY_NEWLINE);
+      }
+    }
+    if (g.lsp_repair_mode != LDP_GLOBAL_DEF_REPAIR_MODE) {
+      vty_out (vty, " lsp-repair-mode ");
+      if (g.lsp_repair_mode == LDP_REPAIR_LOCAL) {
+        vty_out (vty, "local%s", VTY_NEWLINE);
+      } else {
+        vty_out (vty, "global%s", VTY_NEWLINE);
+      }
+    }
+    if (g.propagate_release != LDP_GLOBAL_DEF_PROPOGATE_RELEASE) {
+      if (g.propagate_release == MPLS_BOOL_TRUE) {
+        vty_out (vty, " propagate-release%s", VTY_NEWLINE);
+      } else {
+        vty_out (vty, " no propagate-release%s", VTY_NEWLINE);
+      }
+    }
+    if (g.label_merge != LDP_GLOBAL_DEF_LABEL_MERGE) {
+      if (g.label_merge == MPLS_BOOL_TRUE) {
+        vty_out (vty, " label-merge%s", VTY_NEWLINE);
+      } else {
+        vty_out (vty, " no label-merge%s", VTY_NEWLINE);
+      }
+    }
+    if (g.loop_detection_mode != LDP_GLOBAL_DEF_LOOP_DETECTION_MODE) {
+      if (g.loop_detection_mode == LDP_LOOP_HOPCOUNT) {
+        vty_out (vty, " loop-detection-mode hop%s", VTY_NEWLINE);
+      } else if (g.loop_detection_mode == LDP_LOOP_PATHVECTOR) {
+        vty_out (vty, " loop-detection-mode path%s", VTY_NEWLINE);
+      } else if (g.loop_detection_mode == LDP_LOOP_HOPCOUNT_PATHVECTOR) {
+        vty_out (vty, " loop-detection-mode both%s", VTY_NEWLINE);
+      } else {
+        vty_out (vty, " no loop-detection-mode%s", VTY_NEWLINE);
+      }
+    }
+    if (g.ttl_less_domain != MPLS_BOOL_FALSE) {
+      vty_out (vty, " ttl-less-domain%s", VTY_NEWLINE);
+    }
+    if (g.local_tcp_port != LDP_GLOBAL_DEF_LOCAL_TCP_PORT) {
+      vty_out (vty, " local-tcp-port %d%s", g.local_tcp_port, VTY_NEWLINE);
+    }
+    if (g.local_udp_port != LDP_GLOBAL_DEF_LOCAL_UDP_PORT) {
+      vty_out (vty, " local-udp-port %d%s", g.local_udp_port, VTY_NEWLINE);
+    }
+
+    switch (ldp->egress) {
+      case LDP_EGRESS_LSRID:
+        vty_out (vty, " egress lsr-id%s", VTY_NEWLINE);
+        break;
+      case LDP_EGRESS_CONNECTED:
+        vty_out (vty, " egress connected%s", VTY_NEWLINE);
+        break;
+      default:
+       break;
+    }
+
+    switch (ldp->address) {
+      case LDP_ADDRESS_LSRID:
+        vty_out (vty, " address-mode lsr-id%s", VTY_NEWLINE);
+        break;
+      case LDP_ADDRESS_LDP:
+        vty_out (vty, " address-mode ldp%s", VTY_NEWLINE);
+        break;
+      default:
+       break;
+    }
+  }
+  return write;
+}
+
+int ldp_interface_config_write(struct vty *vty, struct mpls_interface *mi) {
+    struct ldp_interface *li;
+    struct mpls *mpls;
+    struct ldp *ldp;
+    ldp_entity e;
+    int write = 0;
+
+    if (mi && mi->ldp) {
+       li = mi->ldp;
+       mpls = mi->mpls;
+       ldp = mpls->ldp;
+
+       if (li->entity.index) {
+          e.index = li->entity.index;
+         ldp_cfg_entity_get(ldp->h, &e, 0xFFFFFFFF);
+       } else {
+         memcpy(&e,&li->entity,sizeof(ldp_entity));
+       }
+
+        vty_out(vty, " mpls ldp%s", VTY_NEWLINE);
+        write++;
+
+        if (e.label_distribution_mode != LDP_ENTITY_DEF_DISTRIBUTION_MODE) {
+          vty_out(vty, "   distribution-mode ");
+          if (e.label_distribution_mode == LDP_DISTRIBUTION_ONDEMAND) {
+            vty_out(vty, "dod%s", VTY_NEWLINE);
+          } else {
+            vty_out(vty, "du%s", VTY_NEWLINE);
+          }
+        }
+        if (e.remote_tcp_port != LDP_ENTITY_DEF_REMOTE_TCP) {
+          vty_out(vty, "   remote-tcp-port %d%s", e.remote_tcp_port,
+            VTY_NEWLINE);
+        }
+        if (e.remote_udp_port != LDP_ENTITY_DEF_REMOTE_UDP) {
+          vty_out(vty, "   remote-udp-port %d%s", e.remote_udp_port,
+            VTY_NEWLINE);
+        }
+        if (e.max_pdu != LDP_ENTITY_DEF_MAX_PDU) {
+          vty_out(vty, "   max-pdu %d%s", e.max_pdu, VTY_NEWLINE);
+        }
+        if (e.hellotime_interval != LDP_ENTITY_DEF_HELLOTIME_INTERVAL) {
+          vty_out(vty, "   hello-interval %d%s", e.hellotime_interval,
+            VTY_NEWLINE);
+        }
+        if (e.keepalive_interval != LDP_ENTITY_DEF_KEEPALIVE_INTERVAL) {
+          vty_out(vty, "   keepalive-interval %d%s",
+            e.keepalive_interval, VTY_NEWLINE);
+        }
+        if (e.session_setup_count != LDP_ENTITY_DEF_SESSIONSETUP_COUNT) {
+          vty_out(vty, "   max-session-attempt %d%s",
+            e.session_setup_count, VTY_NEWLINE);
+        }
+        if (e.path_vector_limit != LDP_ENTITY_DEF_PATHVECTOR_LIMIT) {
+          vty_out(vty, "   max-path-vector %d%s",
+            e.path_vector_limit, VTY_NEWLINE);
+        }
+        if (e.hop_count_limit != LDP_ENTITY_DEF_HOPCOUNT_LIMIT) {
+          vty_out(vty, "   max-hop-count %d%s",
+            e.hop_count_limit, VTY_NEWLINE);
+        }
+        if (e.label_request_count != LDP_ENTITY_DEF_REQUEST_COUNT) {
+          vty_out(vty, "   max-label-requests %d%s",
+            e.label_request_count, VTY_NEWLINE);
+        }
+        vty_out(vty, " !%s",VTY_NEWLINE);
+    }
+
+    return write;
+}
+
+void ldp_vty_show_init() {
+
+  install_element(VIEW_NODE, &mpls_show_ldp_cmd);
+  install_element(ENABLE_NODE, &mpls_show_ldp_cmd);
+
+  install_element(VIEW_NODE, &mpls_show_ldp_neighbor_cmd);
+  install_element(ENABLE_NODE, &mpls_show_ldp_neighbor_cmd);
+
+  install_element(VIEW_NODE, &mpls_show_ldp_session_cmd);
+  install_element(ENABLE_NODE, &mpls_show_ldp_session_cmd);
+
+  install_element(VIEW_NODE, &mpls_show_ldp_discovery_cmd);
+  install_element(ENABLE_NODE, &mpls_show_ldp_discovery_cmd);
+
+  install_element(VIEW_NODE, &mpls_show_ldp_database_cmd);
+  install_element(ENABLE_NODE, &mpls_show_ldp_database_cmd);
+}
+
+static struct cmd_node ldp_if_node = {MPLS_LDP_IF_NODE,"%s(config-if-ldp)# ",1};
+
+void ldp_vty_if_init() {
+
+  install_node (&ldp_if_node, ldp_if_config_write);
+  install_default (MPLS_LDP_IF_NODE);
+
+  install_element(INTERFACE_NODE,&ldp_intf_cmd);
+  install_element(INTERFACE_NODE,&no_ldp_intf_cmd);
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_remote_tcp_port_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_remote_tcp_port_cmd);
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_remote_udp_port_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_remote_udp_port_cmd);
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_max_pdu_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_max_pdu_cmd);
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_hello_interval_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_hello_interval_cmd);
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_keepalive_interval_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_keepalive_interval_cmd);
+
+#if 0
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_loop_detect_mode_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_loop_detect_mode_cmd);
+#endif
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_max_session_attempt_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_max_session_attempt_cmd);
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_max_path_vector_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_max_path_vector_cmd);
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_max_hop_count_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_max_hop_count_cmd);
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_max_label_requests_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_max_label_requests_cmd);
+
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_distribution_mode_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_distribution_mode_cmd);
+
+#if 0
+  install_element(MPLS_LDP_IF_NODE,&ldp_if_ttl_less_domain_cmd);
+  install_element(MPLS_LDP_IF_NODE,&no_ldp_if_ttl_less_domain_cmd);
+#endif
+}
+
+static struct cmd_node ldp_node = {MPLS_LDP_NODE,"%s(config-ldp)# ",1};
+
+void ldp_vty_init () {
+
+  install_node (&ldp_node, ldp_config_write);
+  install_default (MPLS_LDP_NODE);
+
+  install_element (CONFIG_NODE, &mpls_ldp_cmd);
+  install_element (CONFIG_NODE, &no_mpls_ldp_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_disable_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_disable_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_lsrid_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_lsrid_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_lsp_control_mode_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_lsp_control_mode_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_label_retention_mode_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_label_retention_mode_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_lsp_repair_mode_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_lsp_repair_mode_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_propogate_release_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_propogate_release_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_label_merge_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_label_merge_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_loop_detection_mode_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_loop_detection_mode_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_ttl_less_domain_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_ttl_less_domain_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_local_tcp_port_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_local_tcp_port_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_local_udp_port_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_local_udp_port_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_address_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_binding_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_debug_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_error_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_event_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_general_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_init_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_label_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_normal_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_notif_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_packet_dump_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_packet_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_path_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_periodic_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_policy_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_route_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_state_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_task_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_timer_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_all_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_trace_none_cmd);
+
+  install_element (MPLS_LDP_NODE, &mpls_ldp_egress_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_egress_cmd);
+  install_element (MPLS_LDP_NODE, &mpls_ldp_address_cmd);
+  install_element (MPLS_LDP_NODE, &no_mpls_ldp_address_cmd);
+}
diff --exclude=CVS -uNr zebra/mplsd/ldp_vty.h zebra-ldp/mplsd/ldp_vty.h
--- zebra/mplsd/ldp_vty.h       1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/ldp_vty.h   2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,11 @@
+#ifndef LDP_VTY_H
+#define LDP_VTY_H
+
+#include "mpls_interface.h"
+
+int ldp_interface_config_write(struct vty *vty, struct mpls_interface *mi);
+void ldp_vty_show_init();
+void ldp_vty_if_init();
+void ldp_vty_init();
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/Makefile.am zebra-ldp/mplsd/Makefile.am
--- zebra/mplsd/Makefile.am     1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/Makefile.am 2003-02-26 15:47:42.000000000 -0600
@@ -0,0 +1,66 @@
+## Process this file with automake to produce Makefile.in.
+
+INCLUDES = @INCLUDES@ -I.. -I$(top_srcdir) -I$(top_srcdir)/lib
+DEFS = @DEFS@ -DSYSCONFDIR=\"$(sysconfdir)/\"
+INSTALL_SDATA=@INSTALL@ -m 600
+
+sbin_PROGRAMS = mplsd
+
+mplsd_SOURCES = \
+impl_fib.c impl_ifmgr.c impl_lock.c impl_mm.c impl_mpls.c \
+impl_policy.c impl_socket.c impl_timer.c impl_tree.c \
+mpls.c mpls_interface.c mpls_zebra.c mpls_main.c mpls_vty.c\
+static.c static_vty.c \
+ldp.c ldp_interface.c ldp_vty.c\
+ldp_addr.c ldp_adj.c \
+ldp_attr.c ldp_buf.c ldp_cfg.c ldp_entity.c ldp_fec.c ldp_global.c \
+ldp_hello.c ldp_hop.c ldp_hop_list.c ldp_if.c ldp_inet_addr.c \
+ldp_init.c ldp_inlabel.c ldp_keepalive.c ldp_label_abort.c \
+ldp_label_mapping.c ldp_label_rel_with.c ldp_label_request.c \
+ldp_mesg.c ldp_nortel.c ldp_notif.c ldp_outlabel.c \
+ldp_pdu_setup.c ldp_peer.c \
+ldp_resource.c ldp_session.c ldp_state_funcs.c \
+ldp_state_machine.c ldp_tunnel.c \
+mpls_compare.c \
+lsr_cfg.c lsr_global.c lsr_if.c lsr_insegment.c lsr_labelmanager.c \
+lsr_outsegment.c lsr_xconnect.c lsr_ftn.c
+
+
+noinst_HEADERS = \
+mpls.h mpls_interface.h mpls_zebra.h mpls_vty.h \
+ldp.h ldp_interface.h ldp_vty.h \
+static.h static_vty.h \
+ldp_addr.h ldp_adj.h ldp_attr.h ldp_buf.h ldp_cfg.h \
+ldp_defaults.h ldp_entity.h ldp_fec.h \
+ldp_global.h mpls_handle_type.h ldp_hello.h ldp_hop.h \
+ldp_hop_list.h ldp_if.h ldp_inet_addr.h \
+ldp_init.h ldp_inlabel.h ldp_keepalive.h ldp_label_abort.h \
+ldp_label_mapping.h ldp_label_rel_with.h ldp_label_request.h \
+ldp_mesg.h ldp_nortel.h ldp_notif.h ldp_outlabel.h ldp_pdu.h \
+ldp_pdu_setup.h ldp_peer.h mpls_refcnt.h ldp_resource.h \
+ldp_session.h ldp_state_machine.h ldp_struct.h ldp_tunnel.h \
+mpls_tree_impl.h mpls_mm_impl.h mpls_mpls_impl.h mpls_trace_impl.h \
+mpls_assert.h mpls_fib_impl.h mpls_ifmgr_impl.h mpls_list.h mpls_lock_impl.h \
+mpls_policy_impl.h mpls_socket_impl.h mpls_timer_impl.h mpls_trace.h \
+mpls_struct.h mpls_compare.h \
+lsr_cfg.h lsr_defaults.h lsr_global.h lsr_if.h lsr_insegment.h \
+lsr_labelmanager.h lsr_outsegment.h lsr_struct.h lsr_xconnect.h lsr_ftn.h
+
+mplsd_LDADD = ../lib/libzebra.a
+
+sysconf_DATA = mplsd.conf.sample
+
+EXTRA_DIST = $(sysconf_DATA)
+
+install-sysconfDATA: $(sysconf_DATA)
+       @$(NORMAL_INSTALL)
+       $(mkinstalldirs) $(DESTDIR)$(sysconfdir)
+       @list='$(sysconf_DATA)'; for p in $$list; do \
+         if test -f $(srcdir)/$$p; then \
+           echo " $(INSTALL_SDATA) $(srcdir)/$$p $(DESTDIR)$(sysconfdir)/$$p"; \
+           $(INSTALL_SDATA) $(srcdir)/$$p $(DESTDIR)$(sysconfdir)/$$p; \
+         else if test -f $$p; then \
+           echo " $(INSTALL_SDATA) $$p $(DESTDIR)$(sysconfdir)/$$p"; \
+           $(INSTALL_SDATA) $$p $(DESTDIR)$(sysconfdir)/$$p; \
+         fi; fi; \
+       done
diff --exclude=CVS -uNr zebra/mplsd/mpls.c zebra-ldp/mplsd/mpls.c
--- zebra/mplsd/mpls.c  1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls.c      2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,78 @@
+#include <zebra.h>
+
+#include "thread.h"
+#include "memory.h"
+#include "prefix.h"
+#include "table.h"
+#include "linklist.h"
+#include "filter.h"
+#include "vty.h"
+#include "plist.h"
+
+#include "mpls.h"
+#include "ldp.h"
+#include "static.h"
+#include "lsr_cfg.h"
+
+/* MPLS instance top. */
+struct mpls *mpls_top = NULL;
+
+struct mpls *mpls_new() {
+    lsr_global global;
+    struct mpls *new = XMALLOC(MTYPE_MPLS_TOP, sizeof (struct mpls));
+
+    memset(new,0,sizeof(*new));
+
+    new->h = lsr_cfg_open(new);
+    global.admin_state = MPLS_ADMIN_ENABLE;
+    lsr_cfg_global_set(new->h, &global, LSR_GLOBAL_CFG_ADMIN_STATE);
+
+    new->router_id.family = AF_INET;
+    new->router_id.prefixlen = 32;
+
+    new->iflist = iflist;
+    new->table = route_table_init();
+
+    return new;
+}
+
+struct mpls *mpls_get() {
+    if (mpls_top) {
+       return mpls_top;
+    }
+
+    mpls_top = mpls_new();
+    return mpls_top;
+}
+
+void mpls_finish(struct mpls *mpls) {
+
+    lsr_global global;
+
+    ldp_finish(mpls->ldp);
+    static_finish(mpls->mstatic);
+
+    global.admin_state = MPLS_ADMIN_DISABLE;
+    lsr_cfg_global_set(mpls->h, &global, LSR_GLOBAL_CFG_ADMIN_STATE);
+    lsr_cfg_close(mpls->h);
+    
+    XFREE(MTYPE_MPLS_TOP, mpls);
+    mpls_top = NULL;
+}
+
+/* Update access-list list. */
+void mpls_access_list_update(struct access_list *access) {
+}
+
+/* Update prefix-list list. */
+void mpls_prefix_list_update(struct prefix_list *plist) {
+}
+
+void mpls_init() {
+
+#if 0
+    access_list_init();
+    access_list_add_hook(mpls_access_list_update);
+    access_list_delete_hook(mpls_access_list_update);
+#endif
+}
diff --exclude=CVS -uNr zebra/mplsd/mplsd.conf.sample zebra-ldp/mplsd/mplsd.conf.sample
--- zebra/mplsd/mplsd.conf.sample       1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mplsd.conf.sample   2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,17 @@
+!
+! Zebra configuration saved from vty
+!   2002/03/23 17:07:30
+!
+hostname uml-1
+password root
+enable password root
+!
+mpls ldp
+!
+interface lo
+!
+interface eth0
+ mpls ldp
+!
+line vty
+!
diff --exclude=CVS -uNr zebra/mplsd/mpls.h zebra-ldp/mplsd/mpls.h
--- zebra/mplsd/mpls.h  1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls.h      2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,43 @@
+#ifndef _MPLSD_H
+#define _MPLSD_H
+
+#include "sockunion.h"
+#include "prefix.h"
+#include "zclient.h"
+#include "linklist.h"
+#include "if.h"
+
+#include "ldp.h"
+#include "static.h"
+
+#define MPLS_DEFAULT_CONFIG "mplsd.conf"
+
+#define MPLS_VTY_PORT                2610
+#define MPLS_VTYSH_PATH              "/tmp/.mplsd"
+
+enum mplsd_instr_types {
+  MPLS_FWD = 1,
+  MPLS_PUSH,
+  MPLS_SET
+};
+
+struct mplsd_set {
+   char ifname[INTERFACE_NAMSIZ + 1];
+   union sockunion nexthop;
+};
+
+struct mpls {
+    list iflist;
+    list miflist;
+    mpls_cfg_handle h;
+    struct route_table *table;
+    struct ldp *ldp;
+    struct mpls_static *mstatic;
+    struct prefix router_id;
+    ldp_fib_callback fib_callback;
+};
+
+void mpls_init();
+struct mpls *mpls_get();
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/mpls_handle_type.h zebra-ldp/mplsd/mpls_handle_type.h
--- zebra/mplsd/mpls_handle_type.h      1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls_handle_type.h  2003-02-26 23:23:55.000000000 -0600
@@ -0,0 +1,94 @@
+#ifndef _LDP_HANDLE_TYPE_H_
+#define _LDP_HANDLE_TYPE_H_
+
+#define MPLS_USE_LSR 1
+
+#if (__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
+#if 0
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+#endif
+#else
+#include <stdint.h>
+#endif
+
+#include <zebra.h>
+#include "if.h"
+
+struct ldp;
+struct ldp_timer;
+struct ldp_socket;
+
+#define ptr_verify(x) (x ? MPLS_BOOL_TRUE : MPLS_BOOL_FALSE)
+
+typedef void *mpls_tree_handle;
+#define mpls_tree_handle_compare(x,y) (x != y)
+#define mpls_tree_handle_verify(x) ptr_verify(x)
+
+typedef void *mpls_instance_handle;
+#define mpls_instance_handle_compare(x,y) (x != y)
+#define mpls_instance_handle_verify(x) ptr_verify(x)
+
+typedef struct mpls* mpls_fib_handle;
+#define mpls_fib_handle_compare(x,y) (x == y)
+#define mpls_fib_handle_verify(x) ptr_verify(x)
+
+typedef int mpls_ifmgr_handle;
+#define mpls_ifmgr_handle_compare(x,y) (x == y)
+#define mpls_ifmgr_handle_verify(x) ptr_verify(x)
+
+typedef struct interface* mpls_if_handle;
+#define mpls_if_handle_compare(x,y) \
+       ((x->ifindex == y->ifindex) ? 0 : (x->ifindex > y->ifindex ? 1 : -1))
+#define mpls_if_handle_verify(m,x) ptr_verify(x)
+
+typedef int mpls_timer_mgr_handle;
+#define mpls_timer_mgr_handle_compare(x,y) (x != y)
+#define mpls_timer_mgr_handle_verify(x) ptr_verify(x)
+
+typedef struct mpls_timer* mpls_timer_handle;
+#define mpls_timer_handle_compare(x,y) (x != y)
+#define mpls_timer_handle_verify(m,x) ptr_verify(x)
+
+typedef int mpls_socket_mgr_handle;
+#define mpls_socket_mgr_handle_compare(x,y) (x != y)
+#define mpls_socket_mgr_handle_verify(x) MPLS_BOOL_TRUE
+
+typedef struct mpls_socket* mpls_socket_handle;
+#define mpls_socket_handle_compare(x,y) (x->fd != y->fd)
+#define mpls_socket_handle_verify(m,x) ptr_verify(x)
+
+typedef int mpls_mpls_handle;
+#define mpls_mpls_handle_compare(x,y) (x != y)
+#define mpls_mpls_handle_verify(x) ptr_verify(x)
+
+typedef int mpls_insegment_handle;
+#define mpls_insegment_handle_compare(x,y) (x != y)
+#define mpls_insegment_handle_verify(m,x) ptr_verify(x)
+
+typedef int mpls_outsegment_handle;
+#define mpls_outsegment_handle_compare(x,y) (x != y)
+#define mpls_outsegment_handle_verify(m,x) ptr_verify(x)
+
+typedef int mpls_xconnect_handle;
+#define mpls_xconnect_handle_compare(x,y) (x != y)
+#define mpls_xconnect_handle_verify(m,x) ptr_verify(x)
+
+typedef int *mpls_lock_handle;
+#define mpls_lock_handle_compare(x,y) (x != y)
+#define mpls_lock_handle_verify(x) ptr_verify(x)
+
+typedef int mpls_tunnel_handle;
+#define mpls_tunnel_handle_compare(x,y) (x != y)
+
+typedef int mpls_policy_handle;
+#define mpls_policy_handle_compare(x,y) (x != y)
+
+typedef int mpls_trace_handle;
+#define mpls_trace_handle_compare(x,y) (x != y)
+
+typedef char *mpls_lock_key_type;
+typedef int mpls_size_type;
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/mpls_interface.c zebra-ldp/mplsd/mpls_interface.c
--- zebra/mplsd/mpls_interface.c        1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls_interface.c    2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,72 @@
+#include <zebra.h>
+
+#include "if.h"
+#include "memory.h"
+
+#include "mpls.h"
+#include "mpls_interface.h"
+#include "impl_mpls.h"
+
+struct mpls_interface *mpls_if_new(struct interface *ifp) {
+    struct mpls_interface *mi;
+    struct mpls *mpls = mpls_get();
+
+    mi = XMALLOC(MTYPE_MPLS_IF, sizeof(struct mpls_interface));
+    memset(mi, 0, sizeof(struct mpls_interface));
+
+    /* Set zebra interface pointer. */
+    mi->ifp = ifp;
+    mi->labelspace = -1;
+
+    mi->mpls = mpls;
+    return mi;
+}
+
+void mpls_if_free(struct mpls_interface *mi) {
+
+    listnode_delete(mi->mpls->miflist, mi);
+    XFREE(MTYPE_MPLS_IF, mi);
+}
+
+int mpls_if_is_up(struct mpls_interface *mi) {
+    return if_is_up(mi->ifp);
+}
+
+int mpls_if_new_hook(struct interface *ifp) {
+    ifp->info = mpls_if_new(ifp);
+    return 0;
+}
+
+int mpls_if_delete_hook(struct interface *ifp) {
+    mpls_if_free(ifp->info);
+    ifp->info = NULL;
+    return 0;
+}
+
+int mpls_if_up(struct mpls_interface *mi) {
+    if (!mi) {
+       return 0;
+    }
+    if (mi->labelspace != -1) {
+      do_mpls_labelspace(mi);
+    }
+    ldp_if_up(mi);
+    //static_if_up(mi);
+    return 1;
+}
+
+int mpls_if_down(struct mpls_interface *mi) {
+    if (!mi) {
+       return 0;
+    }
+    ldp_if_down(mi);
+    //static_if_down(mi);
+    return 1;
+}
+
+void mpls_if_init() {
+    /* Initialize Zebra interface data structure. */
+    if_init();
+    if_add_hook(IF_NEW_HOOK, mpls_if_new_hook);
+    if_add_hook(IF_DELETE_HOOK, mpls_if_delete_hook);
+}
diff --exclude=CVS -uNr zebra/mplsd/mpls_interface.h zebra-ldp/mplsd/mpls_interface.h
--- zebra/mplsd/mpls_interface.h        1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls_interface.h    2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,34 @@
+#ifndef MPLS_INTERFACE_H
+#define MPLS_INTERFACE_H
+
+#include <zebra.h>
+
+#include "if.h"
+#include "command.h"
+#include "prefix.h"
+#include "zclient.h"
+
+#include "ldp.h"
+#include "ldp_struct.h"
+#include "ldp_interface.h"
+
+struct mpls_interface {
+  struct mpls *mpls;
+
+  struct interface *ifp;
+  int labelspace;
+
+  struct connected *connected;
+
+  struct ldp_interface *ldp;
+//  struct static_interface static;
+};
+
+struct mpls_interface *mpls_if_new();
+void mpls_if_free(struct mpls_interface *);
+int mpls_if_is_up(struct mpls_interface *);
+int mpls_if_up(struct mpls_interface *mi);
+int mpls_if_down(struct mpls_interface *mi);
+void mpls_if_init();
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/mpls_main.c zebra-ldp/mplsd/mpls_main.c
--- zebra/mplsd/mpls_main.c     1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls_main.c 2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,228 @@
+#include <zebra.h>
+
+#include "version.h"
+#include "getopt.h"
+#include "command.h"
+#include "thread.h"
+#include "filter.h"
+#include "memory.h"
+#include "prefix.h"
+#include "log.h"
+
+#include "mpls.h"
+#include "mpls_vty.h"
+#include "mpls_zebra.h"
+#include "mpls_interface.h"
+
+/* Configuration filename and directory. */
+char config_current[] = MPLS_DEFAULT_CONFIG;
+char config_default[] = SYSCONFDIR MPLS_DEFAULT_CONFIG;
+
+/* Command line options. */
+struct option longopts[] =
+{
+  { "daemon",      no_argument,       NULL, 'd'},
+  { "config_file", required_argument, NULL, 'f'},
+  { "log_mode",    no_argument,       NULL, 'l'},
+  { "help",        no_argument,       NULL, 'h'},
+  { "vty_port",    required_argument, NULL, 'P'},
+  { "vty_addr",    required_argument, NULL, 'A'},
+  { "version",     no_argument,       NULL, 'v'},
+  { 0 }
+};
+
+/* Master of threads. */
+struct thread_master *master = NULL;
+
+/* Process ID saved for use by init system */
+char *pid_file = PATH_MPLSD_PID;
+
+/* Help information display. */
+static void
+usage (char *progname, int status)
+{
+  if (status != 0)
+    fprintf (stderr, "Try `%s --help' for more information.\n", progname);
+  else
+    {    
+      printf ("Usage : %s [OPTION...]\n\n\
+Daemon which manages MPLS related configuration.\n\n\
+-d, --daemon       Runs in daemon mode\n\
+-f, --config_file  Set configuration file name\n\
+-l, --log_mode     Set verbose log mode flag\n\
+-h, --help         Display this help and exit\n\
+-P, --vty_port     Set vty's port number\n\
+-A, --vty_addr     Set vty's bind address\n\
+-v, --version      Print program version\n\
+\n\
+Report bugs to %s\n", progname, ZEBRA_BUG_ADDRESS);
+    }
+
+  exit (status);
+}
+\f
+/* SIGHUP handler. */
+void 
+sighup (int sig)
+{
+  zlog_info ("SIGHUP received");
+
+  /* Reload of config file. */
+  ;
+}
+
+/* SIGINT handler. */
+void
+sigint (int sig)
+{
+  zlog_info ("Terminating on signal");
+
+  exit (0);
+}
+
+/* SIGUSR1 handler. */
+void
+sigusr1 (int sig)
+{
+  zlog_rotate (NULL);
+}
+
+/* Signale wrapper. */
+RETSIGTYPE *
+signal_set (int signo, void (*func)(int))
+{
+  int ret;
+  struct sigaction sig;
+  struct sigaction osig;
+
+  sig.sa_handler = func;
+  sigemptyset (&sig.sa_mask);
+  sig.sa_flags = 0;
+#ifdef SA_RESTART
+  sig.sa_flags |= SA_RESTART;
+#endif /* SA_RESTART */
+
+  ret = sigaction (signo, &sig, &osig);
+
+  if (ret < 0) 
+    return (SIG_ERR);
+  else
+    return (osig.sa_handler);
+}
+
+/* Initialization of signal handles. */
+void
+signal_init ()
+{
+  signal_set (SIGHUP, sighup);
+  signal_set (SIGINT, sigint);
+  signal_set (SIGTERM, sigint);
+  signal_set (SIGPIPE, SIG_IGN);
+  signal_set (SIGUSR1, sigusr1);
+}
+\f
+/* Main startup routine. */
+int
+main (int argc, char **argv)
+{
+  char *p;
+  int vty_port = 0;
+  char *vty_addr = NULL;
+  int daemon_mode = 0;
+  char *config_file = NULL;
+  char *progname;
+  struct thread thread;
+
+  /* Set umask before anything for security */
+  umask (0027);
+
+  /* preserve my name */
+  progname = ((p = strrchr (argv[0], '/')) ? ++p : argv[0]);
+
+  zlog_default = openzlog (progname, ZLOG_STDOUT, ZLOG_MPLS,
+                          LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);
+
+  while (1) 
+    {
+      int opt;
+  
+      opt = getopt_long (argc, argv, "bdklf:hP:rv", longopts, 0);
+
+      if (opt == EOF)
+       break;
+
+      switch (opt) 
+       {
+       case 0:
+         break;
+       case 'd':
+         daemon_mode = 1;
+         break;
+       case 'l':
+         /* log_mode = 1; */
+         break;
+       case 'f':
+         config_file = optarg;
+         break;
+       case 'A':
+         vty_addr = optarg;
+          break;
+       case 'P':
+         vty_port = atoi (optarg);
+         break;
+       case 'v':
+         print_version (progname);
+         exit (0);
+         break;
+       case 'h':
+         usage (progname, 0);
+         break;
+       default:
+         usage (progname, 1);
+         break;
+       }
+    }
+
+  /* Make master thread emulator. */
+  master = thread_master_create();
+
+  /* Vty related initialize. */
+  signal_init();
+  cmd_init(1);
+  vty_init();
+  memory_init();
+
+  /* MPLSs inits */
+  mpls_init();
+  mpls_if_init();
+  mpls_vty_init();
+  mpls_vty_show_init();
+  mpls_zebra_init();
+
+  sort_node();
+
+  /* Configuration file read*/
+  vty_read_config(config_file, config_current, config_default);
+
+  /* Daemonize. */
+  if (daemon_mode) {
+    daemon(0, 0);
+  }
+
+  /* Output pid of zebra. */
+  pid_output(pid_file);
+
+  /* Create VTY socket */
+  vty_serv_sock(vty_addr,
+               vty_port ? vty_port : MPLS_VTY_PORT, MPLS_VTYSH_PATH);
+
+  /* Print banner. */
+  zlog(NULL, LOG_INFO, "MPLSd (%s) starts", ZEBRA_VERSION);
+
+  while(thread_fetch(master, &thread)) {
+    thread_call(&thread);
+  }
+
+  /* Not reached... */
+  exit (0);
+}
diff --exclude=CVS -uNr zebra/mplsd/mpls_trace.h zebra-ldp/mplsd/mpls_trace.h
--- zebra/mplsd/mpls_trace.h    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls_trace.h        2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,60 @@
+#ifndef _LDP_TRACE_H_
+#define _LDP_TRACE_H_
+
+#include <stdio.h>
+#include "ldp_struct.h"
+
+extern uint32_t ldp_traceflags;
+extern uint8_t trace_buffer[16834];
+extern int trace_buffer_len;
+
+#if 0
+1 2 3 4 5 6 7 8
+  12345678901234567890123456789012345678901234567890123456789012345678901234567890
+#endif
+#define LDP_TRACE_OUT(handle,args...) {                                \
+    if(trace_buffer_len == 0) {                                        \
+      trace_buffer_len += sprintf(trace_buffer,"OUT: " args);\
+    } else {                                                   \
+      trace_buffer_len += sprintf(trace_buffer+trace_buffer_len,args);\
+    }                                                          \
+    if(trace_buffer[strlen(trace_buffer)-1] == '\n') {         \
+      fprintf(stderr,"%s",trace_buffer);                       \
+      trace_buffer_len = 0;                                    \
+    }                                                          \
+}
+#define LDP_TRACE_LOG(handle,class,type,args...) {             \
+  if(type & ldp_traceflags) {                                  \
+    LDP_TRACE_OUT(handle,args);                                        \
+  }                                                            \
+}
+#define LDP_TRACE_PKT(handle,class,type,header,body) {         \
+  if(type & ldp_traceflags) {                                  \
+    header;                                                    \
+    body;                                                      \
+  }                                                            \
+}
+#define LDP_DUMP_PKT(handle,class,type,func) {                 \
+  if(type & ldp_traceflags) {                                  \
+    func;                                                      \
+  }                                                            \
+}
+#define LDP_PRINT(data,args...) {                              \
+  if(ldp_traceflags & LDP_TRACE_FLAG_DEBUG) {                  \
+    fprintf(stderr, "PRT: " args);                             \
+  }                                                            \
+}
+#define LDP_ENTER(data,args...) {                              \
+  if(ldp_traceflags & LDP_TRACE_FLAG_DEBUG) {                  \
+    fprintf(stderr, "ENTER: " args);                           \
+    fprintf(stderr, "\n");                                     \
+  }                                                            \
+}
+#define LDP_EXIT(data,args...) {                               \
+  if(ldp_traceflags & LDP_TRACE_FLAG_DEBUG) {                  \
+    fprintf(stderr, "EXIT: " args);                            \
+    fprintf(stderr, "\n");                                     \
+  }                                                            \
+}
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/mpls_vty.c zebra-ldp/mplsd/mpls_vty.c
--- zebra/mplsd/mpls_vty.c      1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls_vty.c  2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,155 @@
+#include <zebra.h>
+
+#include "vty.h"
+#include "command.h"
+
+#include "mpls.h"
+#include "mpls_interface.h"
+
+#include "ldp.h"
+#include "ldp_cfg.h"
+#include "ldp_vty.h"
+#include "ldp_interface.h"
+#include "static_vty.h"
+
+#include "impl_mpls.h"
+
+DEFUN (mpls_show_lsr_id, mpls_show_lsr_id_cmd,
+       "show lsr-id",
+       SHOW_STR
+       "LSR identifier\n") {
+
+    struct mpls *mpls = mpls_get();
+
+    vty_out(vty, "lsr-id: %s%s", inet_ntoa(mpls->router_id.u.prefix4),
+        VTY_NEWLINE);
+    return CMD_SUCCESS;
+}
+
+DEFUN(interface_mpls_labelspace,
+      interface_mpls_labelspace_cmd,
+      "mpls labelspace <1-255>",
+      "MPLS interface configuration\n"
+      "labelspace\n"
+      "labelspace number\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct mpls *mpls = mpls_get();
+  struct mpls_range range;
+
+  if ((range.label_space = atoi(argv[0])) < 0) {
+    return CMD_WARNING;
+  }
+
+  mi->labelspace = range.label_space;
+  do_mpls_labelspace(mi);
+
+  if (mpls->ldp && mi->ldp && mi->ldp->entity.index) {
+    ldp_interface_admin_state_start(mi);
+    mi->ldp->iff.label_space = mi->labelspace;
+    ldp_cfg_if_set(mpls->ldp->h, &mi->ldp->iff, LDP_IF_CFG_LABEL_SPACE);
+    ldp_interface_admin_state_finish(mi);
+  }
+
+  return CMD_SUCCESS;
+}
+
+DEFUN(no_interface_mpls_labelspace,
+      no_interface_mpls_labelspace_cmd,
+      "no mpls labelspace",
+      NO_STR
+      "MPLS interface configuration\n"
+      "labelspace\n") {
+  struct interface *ifp = vty->index;
+  struct mpls_interface *mi = (struct mpls_interface*)ifp->info;
+  struct mpls *mpls = mpls_get();
+
+  mi->labelspace = -1;
+  do_mpls_labelspace(mi);
+
+  if (mpls->ldp && mi->ldp && mi->ldp->entity.index) {
+    ldp_interface_admin_state_start(mi);
+    mi->ldp->iff.label_space = mi->labelspace;
+    ldp_cfg_if_set(mpls->ldp->h, &mi->ldp->iff, LDP_IF_CFG_LABEL_SPACE);
+    ldp_interface_admin_state_finish(mi);
+  }
+  return CMD_SUCCESS;
+}
+
+int mpls_interface_config_write(struct vty *vty) {
+  listnode node;
+  struct interface *ifp;
+  struct mpls_interface *mi;
+  struct mpls *mpls = mpls_get();
+
+  for (node = listhead(mpls->iflist); node; nextnode(node)) {
+    ifp = getdata(node);
+
+    vty_out(vty, "interface %s%s", ifp->name, VTY_NEWLINE);
+
+    if (ifp->desc) {
+      vty_out(vty, " description %s%s", ifp->desc, VTY_NEWLINE);
+    }
+
+    if ((mi = (struct mpls_interface*)ifp->info)) {
+      if (mi->labelspace > -1) {
+        vty_out(vty, " mpls labelspace %d%s", mi->labelspace, VTY_NEWLINE);
+      } else {
+        vty_out(vty, " no mpls labelspace%s", VTY_NEWLINE);
+      }
+      ldp_interface_config_write(vty, mi);
+    }
+    vty_out(vty, "!%s", VTY_NEWLINE);
+  }
+  return 0;
+}
+
+void mpls_vty_show_init () {
+
+  install_element(VIEW_NODE, &mpls_show_lsr_id_cmd);
+  install_element(ENABLE_NODE, &mpls_show_lsr_id_cmd);
+
+#if 0
+  install_element (VIEW_NODE, &show_ip_route_cmd);
+  install_element (VIEW_NODE, &show_ip_route_addr_cmd);
+  install_element (VIEW_NODE, &show_ip_route_prefix_cmd);
+  install_element (VIEW_NODE, &show_ip_route_prefix_longer_cmd);
+  install_element (VIEW_NODE, &show_ip_route_protocol_cmd);
+  install_element (VIEW_NODE, &show_ip_route_supernets_cmd);
+  install_element (ENABLE_NODE, &show_ip_route_cmd);
+  install_element (ENABLE_NODE, &show_ip_route_addr_cmd);
+  install_element (ENABLE_NODE, &show_ip_route_prefix_cmd);
+  install_element (ENABLE_NODE, &show_ip_route_prefix_longer_cmd);
+  install_element (ENABLE_NODE, &show_ip_route_protocol_cmd);
+  install_element (ENABLE_NODE, &show_ip_route_supernets_cmd);
+#endif
+
+  ldp_vty_show_init();
+  static_vty_show_init();
+}
+
+struct cmd_node interface_node = { INTERFACE_NODE, "%s(config-if)# ", 1, };
+
+void mpls_vty_if_init() {
+
+  install_node(&interface_node, mpls_interface_config_write);
+
+  install_element(CONFIG_NODE, &interface_cmd);
+  install_default(INTERFACE_NODE);
+
+  install_element(INTERFACE_NODE,&interface_desc_cmd);
+  install_element(INTERFACE_NODE,&no_interface_desc_cmd);
+
+  install_element(INTERFACE_NODE,&interface_mpls_labelspace_cmd);
+  install_element(INTERFACE_NODE,&no_interface_mpls_labelspace_cmd);
+
+  ldp_vty_if_init();
+}
+
+void mpls_vty_init () {
+
+  ldp_vty_init();
+  static_vty_init();
+  mpls_vty_if_init();
+
+}
diff --exclude=CVS -uNr zebra/mplsd/mpls_vty.h zebra-ldp/mplsd/mpls_vty.h
--- zebra/mplsd/mpls_vty.h      1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls_vty.h  2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,40 @@
+#ifndef ZEBRA_MPLS_VTY_H
+#define ZEBRA_MPLS_VTY_H
+
+#define VTY_GET_UINT32(NAME,V,STR)                                            \
+{                                                                             \
+  char *endptr = NULL;                                                        \
+  (V) = strtoul ((STR), &endptr, 10);                                         \
+  if (*endptr != '\0' || ((V) == ULONG_MAX && errno == ERANGE))               \
+    {                                                                         \
+      vty_out (vty, "%% Invalid %s value%s", NAME, VTY_NEWLINE);              \
+      return CMD_WARNING;                                                     \
+    }                                                                         \
+}
+
+#define VTY_GET_UINT32_RANGE(NAME,V,STR,IMIN,IMAX)                            \
+{                                                                             \
+  VTY_GET_UINT32(NAME,V,STR);                                                 \
+  if (((V) < IMIN) || ((V) > IMAX))                                           \
+    {                                                                         \
+      vty_out (vty, "%% Invalid %s value.  Valid range is (%d ... %d)%s",     \
+         NAME, IMIN, IMAX, VTY_NEWLINE);                                      \
+      return CMD_WARNING;                                                     \
+    }                                                                         \
+}
+
+#define VTY_GET_IPV4_ADDRESS(NAME,V,STR)                                      \
+{                                                                             \
+  int retv;                                                                   \
+  retv = inet_aton ((STR), &(V));                                             \
+  if (!retv)                                                                  \
+    {                                                                         \
+      vty_out (vty, "%% Invalid %s value%s", NAME, VTY_NEWLINE);              \
+      return CMD_WARNING;                                                     \
+    }                                                                         \
+}
+
+void mpls_vty_init();
+void mpls_vty_show_init();
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/mpls_zebra.c zebra-ldp/mplsd/mpls_zebra.c
--- zebra/mplsd/mpls_zebra.c    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls_zebra.c        2003-03-13 21:55:36.000000000 -0600
@@ -0,0 +1,311 @@
+#include <zebra.h>
+
+#include "command.h"
+#include "prefix.h"
+#include "stream.h"
+#include "table.h"
+#include "memory.h"
+#include "zclient.h"
+#include "log.h"
+
+#include "ldp.h"
+#include "mpls_interface.h"
+#include "impl_fib.h"
+#include "impl_ifmgr.h"
+#include "impl_mpls.h"
+
+/* All information about zebra. */
+struct zclient *zclient = NULL;
+
+/* For registering threads. */
+extern struct thread_master *master;
+
+/* Router-id update message from zebra. */
+int mpls_router_id_update_zebra(int command, struct zclient *zclient,
+    zebra_size_t length) {
+    struct mpls *mpls = mpls_get();
+
+    zebra_router_id_update_read(zclient->ibuf,&mpls->router_id);
+
+    zlog_info("router-id change %s",
+       inet_ntoa(mpls->router_id.u.prefix4));
+
+    if (mpls && mpls->ldp) {
+       ldp_router_id_update(mpls->ldp, &mpls->router_id);
+    }
+    return 0;
+}
+
+/* Inteface addition message from zebra. */
+int mpls_interface_add(int command, struct zclient *zclient,
+    zebra_size_t length) {
+    struct interface *ifp;
+    struct mpls_interface *mi;
+
+    if (!(ifp = zebra_interface_add_read(zclient->ibuf))) {
+       return 1;
+    }
+
+    mi = (struct mpls_interface*)ifp->info;
+    if (mi && mi->ldp) {
+       /* Initialize labelspace to kernel */
+       /* If the labelspace has been set yet via the CLI */
+       /* the result will be that the kernel labelspace will */
+       /* be un-set, which doesn't hurt anything */
+       do_mpls_labelspace(mi);
+    }
+
+    zlog_info("interface add %s index %d flags %ld metric %d mtu %d",
+               ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu);
+
+    return 0;
+}
+
+int mpls_interface_delete(int command, struct zclient *zclient,
+    zebra_size_t length) {
+    struct interface *ifp;
+    struct stream *s;
+
+    s = zclient->ibuf;
+    /* zebra_interface_state_read() updates interface structure in iflist */
+    ifp = zebra_interface_state_read(s);
+
+    if (ifp == NULL) {
+       return 0;
+    }
+
+    if (if_is_up(ifp)) {
+       zlog_warn("got delete of %s, but interface is still up",
+            ifp->name);
+    }
+
+    zlog_info("interface delete %s index %d flags %ld metric %d mtu %d",               ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu);
+
+    if_delete(ifp);
+
+    return 0;
+}
+
+struct interface * zebra_interface_if_lookup(struct stream *s) {
+    struct interface *ifp;
+    u_char ifname_tmp[INTERFACE_NAMSIZ];
+
+    /* Read interface name. */
+    stream_get(ifname_tmp, s, INTERFACE_NAMSIZ);
+
+    /* Lookup this by interface index. */
+    ifp = if_lookup_by_name(ifname_tmp);
+
+    /* If such interface does not exist, indicate an error */
+    if (!ifp) {
+       return NULL;
+    }
+
+    return ifp;
+}
+
+int mpls_interface_state_up(int command, struct zclient *zclient,
+    zebra_size_t length) {
+    struct interface *ifp;
+    struct interface if_tmp;
+
+    ifp = zebra_interface_if_lookup(zclient->ibuf);
+    if (ifp == NULL) {
+       return 0;
+    }
+
+    /* Interface is already up. */
+    if (if_is_up (ifp)) {
+       /* Temporarily keep ifp values. */
+       memcpy (&if_tmp, ifp, sizeof (struct interface));
+
+       zebra_interface_if_set_value (zclient->ibuf, ifp);
+
+       zlog_info ("Interface[%s] state update.", ifp->name);
+
+       return 0;
+    }
+
+    zebra_interface_if_set_value(zclient->ibuf, ifp);
+
+    zlog_info ("Interface[%s] state change to up.", ifp->name);
+
+    mpls_if_up(ifp->info);
+
+    return 0;
+}
+
+int mpls_interface_state_down(int command, struct zclient *zclient,
+    zebra_size_t length) {
+    struct interface *ifp;
+
+    ifp = zebra_interface_state_read (zclient->ibuf);
+    if (ifp == NULL) {
+       return 0;
+    }
+
+    zlog_info ("Interface[%s] state change to down.", ifp->name);
+
+    mpls_if_down(ifp->info);
+
+    return 0;
+}
+
+int mpls_interface_address_add(int command, struct zclient *zclient,
+    zebra_size_t length) {
+    struct mpls *mpls = mpls_get();
+    struct connected *c;
+    struct interface *ifp;
+    struct prefix *p;
+
+    c = zebra_interface_address_add_read(zclient->ibuf);
+    if (c == NULL) {
+       return 0;
+    }
+
+    ifp = c->ifp;
+    p = c->address;
+
+    zlog_info("address add %s to interface %s",inet_ntoa(p->u.prefix4),
+       ifp->name);
+
+    if (mpls->ldp) {
+       ldp_address_add_callback(mpls, c);
+    }
+
+    return 0;
+}
+
+int mpls_interface_address_delete(int command, struct zclient *zclient,
+    zebra_size_t length) {
+    struct mpls *mpls = mpls_get();
+    struct connected *c;
+    struct interface *ifp;
+    struct prefix *p;
+
+    c = zebra_interface_address_delete_read(zclient->ibuf);
+    if (c == NULL) {
+       return 0;
+    }
+
+    ifp = c->ifp;
+    p = c->address;
+
+    zlog_info("address delete %s from interface %s",
+       inet_ntoa(p->u.prefix4), ifp->name);
+
+    if (mpls->ldp) {
+       ldp_address_delete_callback(mpls, c);
+    }
+
+    connected_free(c);
+
+    return 0;
+}
+
+static void mpls_read_ipv4(struct zclient *client, u_short length,
+    struct prefix_ipv4* p, struct mpls_nexthop* nexthop) {
+    struct stream *s;
+    int ifindex_num;
+    int nexthop_num;
+    int message;
+    int flags;
+    int type;
+
+    s = client->ibuf;
+    memset(nexthop,0,sizeof(nexthop));
+
+    /* Type, flags, message. */
+    type = stream_getc(s);
+    flags = stream_getc(s);
+    message = stream_getc(s);
+
+    if (type == ZEBRA_ROUTE_CONNECT) {
+      nexthop->attached = MPLS_BOOL_TRUE;
+    }
+
+    /* IPv4 prefix. */
+    memset (p, 0, sizeof(struct prefix_ipv4));
+    p->family = AF_INET;
+    p->prefixlen = stream_getc (s);
+    stream_get(&p->prefix, s, PSIZE(p->prefixlen));
+
+    /* Nexthop, ifindex, distance, metric. */
+    if (CHECK_FLAG(message, ZAPI_MESSAGE_NEXTHOP)) {
+       nexthop_num = stream_getc(s);
+       assert(nexthop_num == 1);
+       nexthop->ip.u.ipv4 = ntohl(stream_get_ipv4(s));
+       if (nexthop->ip.u.ipv4) {
+         nexthop->ip.type = MPLS_FAMILY_IPV4;
+         nexthop->type |= MPLS_NH_IP;
+       }
+    }
+
+    if (CHECK_FLAG(message, ZAPI_MESSAGE_IFINDEX)) {
+       ifindex_num = stream_getc(s);
+       assert(ifindex_num == 1);
+       nexthop->if_handle = if_lookup_by_index(stream_getl(s));
+       nexthop->type |= MPLS_NH_IF;
+    }
+
+    /* Distance. */
+    if (CHECK_FLAG(message, ZAPI_MESSAGE_DISTANCE)) {
+       nexthop->distance = stream_getc(s);
+    }
+
+    /* Metric. */
+    if (CHECK_FLAG(message, ZAPI_MESSAGE_METRIC)) {
+       nexthop->metric = stream_getl(s);
+    }
+}
+
+int mpls_zebra_read_ipv4(int command, struct zclient *client,
+    zebra_size_t length) {
+    struct mpls_nexthop nexthop;
+    struct prefix_ipv4 p;
+    struct mpls *mpls = mpls_get();
+    struct in_addr tmp;
+
+    mpls_read_ipv4(client, length, &p, &nexthop);
+
+    if (command == ZEBRA_IPV4_ROUTE_ADD) {
+       zlog_info("route add %s/%d", inet_ntoa(p.prefix), p.prefixlen);
+    } else {
+       zlog_info("route delete %s/%d", inet_ntoa(p.prefix), p.prefixlen);
+    }
+
+    if (nexthop.type & MPLS_NH_IP) {
+       tmp.s_addr = htonl(nexthop.ip.u.ipv4);
+       zlog_info("\tnexthop %s", inet_ntoa(tmp));
+    }
+    if (nexthop.type & MPLS_NH_IF) {
+       zlog_info("\tifindex %d", nexthop.if_handle->ifindex);
+    }
+
+    if (command == ZEBRA_IPV4_ROUTE_ADD) {
+       ldp_ipv4_add(mpls, &p, &nexthop);
+    } else {
+       ldp_ipv4_delete(mpls, &p, &nexthop);
+    }
+    return 0;
+}
+
+void mpls_zebra_init() {
+  int i;
+
+  /* Allocate zebra structure. */
+  zclient = zclient_new();
+  zclient_init(zclient, ZEBRA_ROUTE_MPLS);
+  for (i = 0;i < ZEBRA_ROUTE_MAX;i++) {
+       zclient->redist[i] = 1;
+  }
+  zclient->router_id_update = mpls_router_id_update_zebra;
+  zclient->interface_add = mpls_interface_add;
+  zclient->interface_delete = mpls_interface_delete;
+  zclient->interface_up = mpls_interface_state_up;
+  zclient->interface_down = mpls_interface_state_down;
+  zclient->interface_address_add = mpls_interface_address_add;
+  zclient->interface_address_delete = mpls_interface_address_delete;
+  zclient->ipv4_route_add = mpls_zebra_read_ipv4;
+  zclient->ipv4_route_delete = mpls_zebra_read_ipv4;
+}
diff --exclude=CVS -uNr zebra/mplsd/mpls_zebra.h zebra-ldp/mplsd/mpls_zebra.h
--- zebra/mplsd/mpls_zebra.h    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/mpls_zebra.h        2003-02-26 15:47:44.000000000 -0600
@@ -0,0 +1,8 @@
+#ifndef _ZEBRA_MPLS_ZEBRA_H
+#define _ZEBRA_MPLS_ZEBRA_H
+
+#include "prefix.h"
+
+void mpls_zebra_init();
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/static.c zebra-ldp/mplsd/static.c
--- zebra/mplsd/static.c        1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/static.c    2003-02-26 15:47:45.000000000 -0600
@@ -0,0 +1,101 @@
+#include <zebra.h>
+
+#include "vty.h"
+#include "command.h"
+#include "memory.h"
+
+#include "static.h"
+
+static struct static_outsegment *static_outsegment_new(struct mpls_static *mstatic) {
+    struct static_outsegment *new = XMALLOC(MTYPE_MPLS_STATIC, sizeof(*new));
+    memset(new,0,sizeof(*new));
+    new->node.data = new;
+    new->mstatic = mstatic;
+    return new;
+}
+
+struct static_outsegment *static_outsegment_get(struct mpls_static *mstatic,
+    unsigned int index, char create) {
+    struct listnode *tmp;
+    struct static_outsegment *out;
+
+    LIST_LOOP(mstatic->outsegment,out,tmp) {
+        if (out->index == index) {
+            return out;
+        }
+    }
+
+    if (create) {
+        out = static_outsegment_new(mstatic);
+       out->index = index;
+        LISTNODE_ADD(mstatic->outsegment, &out->node);
+        return out;
+    }
+    return NULL;
+}
+
+void static_outsegment_finish(struct static_outsegment *out) {
+    LISTNODE_DELETE(out->mstatic->outsegment, &out->node);
+    XFREE(MTYPE_MPLS_STATIC,out);
+}
+
+static struct static_insegment *static_insegment_new(struct mpls_static *mstatic) {
+    struct static_insegment *new = XMALLOC(MTYPE_MPLS_STATIC, sizeof(*new));
+    memset(new,0,sizeof(*new));
+    new->node.data = new;
+    new->mstatic = mstatic;
+    return new;
+}
+
+struct static_insegment *static_insegment_get(struct mpls_static *mstatic,
+    unsigned int index, char create) {
+    struct listnode *tmp;
+    struct static_insegment *in;
+
+    LIST_LOOP(mstatic->insegment,in,tmp) {
+       if (in->index == index) {
+           return in;
+       }
+    }
+
+    if (create) {
+       in = static_insegment_new(mstatic);
+       in->index = index;
+       LISTNODE_ADD(mstatic->insegment, &in->node);
+       return in;
+    }
+    return NULL;
+}
+
+void static_insegment_finish(struct static_insegment *in) {
+    LISTNODE_DELETE(in->mstatic->insegment, &in->node);
+    XFREE(MTYPE_MPLS_STATIC,in);
+}
+    
+static struct mpls_static *static_new(struct mpls *mpls) {
+    struct mpls_static *new = XMALLOC(MTYPE_MPLS_STATIC, sizeof(*new));
+    
+    memset(new,0,sizeof(*new));
+    new->mpls = mpls;
+    new->outsegment = list_new();
+    new->insegment = list_new();
+
+    return new;
+}
+
+struct mpls_static *static_get() {
+    struct mpls *mpls = mpls_get();
+    if (mpls->mstatic) {
+       return mpls->mstatic;
+    }
+
+    mpls->mstatic = static_new(mpls);
+    return mpls->mstatic;
+}
+
+void static_finish(struct mpls_static *mstatic) {
+    struct mpls *mpls = mstatic->mpls;
+
+    XFREE(MTYPE_MPLS_STATIC,mstatic);
+    mpls->mstatic = NULL;
+}
diff --exclude=CVS -uNr zebra/mplsd/static.h zebra-ldp/mplsd/static.h
--- zebra/mplsd/static.h        1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/static.h    2003-02-26 15:47:45.000000000 -0600
@@ -0,0 +1,42 @@
+#ifndef STATIC_H
+#define STATIC_H
+
+#include <zebra.h>
+#include "linklist.h"
+
+#include "mpls.h"
+#include "lsr_struct.h"
+
+struct mpls_static {
+    struct mpls *mpls;
+    mpls_cfg_handle h;
+    struct list *insegment;
+    struct list *outsegment;
+};
+
+struct static_insegment {
+    struct listnode node;
+    struct mpls_static *mstatic;
+    unsigned int index;
+    lsr_insegment in;
+    lsr_xconnect xc;
+    unsigned int out_index;
+};
+
+struct static_outsegment {
+    struct listnode node;
+    struct mpls_static *mstatic;
+    unsigned int index;
+    lsr_outsegment out;
+};
+
+struct mpls_static *static_get();
+void static_finish(struct mpls_static *mstatic);
+struct static_outsegment *static_outsegment_get(struct mpls_static *mstatic,
+    unsigned int index, char create);
+void static_outsegment_finish(struct static_outsegment *out);
+struct static_insegment *static_insegment_get(struct mpls_static *mstatic,
+    unsigned int index, char create);
+void static_insegment_finish(struct static_insegment *in);
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/static_tunnel.c zebra-ldp/mplsd/static_tunnel.c
--- zebra/mplsd/static_tunnel.c 1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/static_tunnel.c     2003-02-26 15:47:45.000000000 -0600
@@ -0,0 +1,260 @@
+#include <zebra.h>
+
+#include "if.h"
+#include "vty.h"
+#include "command.h"
+#include "memory.h"
+#include "out-segment.h"
+
+#include "tunnel.h"
+#include "interface.h"
+#include "utility.h"
+#include <linux/mpls.h>
+
+struct list *mplsd_tunnel_list;
+
+struct mplsd_tunnel *mplsd_tunnel_lookup_by_name(char *name) {
+  listnode node;
+  struct mplsd_tunnel *ifp;
+
+  for (node = listhead(mplsd_tunnel_list); node; nextnode(node)) {
+      ifp = getdata(node);
+      if (strncmp(name, ifp->iff.name, sizeof(ifp->iff.name)) == 0) {
+          return ifp;
+      }
+  }
+  return NULL;
+}
+
+struct mplsd_tunnel *mplsd_tunnel_create(char *name, int mode) {
+  struct mplsd_tunnel *ifp;
+  struct ifreq ifr;
+  int result;
+
+  ifp = XMALLOC(MTYPE_MPLS_STATIC, sizeof(struct mplsd_tunnel));
+  if(!ifp) return NULL;
+  memset(ifp, 0, sizeof(struct mplsd_tunnel));
+
+  listnode_add(mplsd_tunnel_list, ifp);
+
+  strncpy(ifr.ifr_name,name,IFNAMSIZ);
+  if(mode) {
+    result = mplsd_ioctl(SIOCMPLSTUNNELADD, (caddr_t)&ifr);
+  }
+  result = mplsd_ioctl(SIOCGIFINDEX, (caddr_t)&ifr);
+  strncpy(ifp->iff.name, name, INTERFACE_NAMSIZ);
+  ifp->iff.ifindex = ifr.ifr_ifindex;
+  return ifp;
+}
+
+void mplsd_tunnel_delete(struct mplsd_tunnel *ifp, int mode) {
+
+  listnode_delete(mplsd_tunnel_list, ifp);
+
+  if (mode) {
+    struct ifreq ifr;
+    int result;
+
+    strncpy(ifr.ifr_name,ifp->iff.name,IFNAMSIZ);
+    result = mplsd_ioctl(SIOCMPLSTUNNELDEL, (caddr_t)&ifr);
+  }
+
+  XFREE(MTYPE_MPLS_STATIC, ifp);
+}
+
+DEFUN (mplsd_tunnel,
+       mplsd_tunnel_cmd,
+       "tunnel IFNAME",
+       "Create a pseudo tunnel\n"
+       "Tunnel's name\n") {
+  struct mplsd_interface_wait *wait;
+  struct interface *ifp;
+  struct mplsd_tunnel *tun;
+  int num;
+
+  if(sscanf(argv[0],"mpls%d",&num) != 1) {
+    vty_out (vty, "Tunnel names must be in the form 'mpls%%d'%s", VTY_NEWLINE);
+    return CMD_WARNING;
+  }
+  
+  if (!(tun = mplsd_tunnel_lookup_by_name(argv[0]))) {
+    tun = mplsd_tunnel_create(argv[0], 1);
+
+    if (!(wait = mplsd_interface_wait_new())) {
+      vty_out(vty, "Unable to register for interface%s", VTY_NEWLINE);
+      return CMD_ERR_INCOMPLETE;
+    }
+
+    wait->data[0] = tun;
+    strncpy(wait->ifname, argv[0], INTERFACE_NAMSIZ);
+    tun->wait = wait;
+
+    if (!(ifp = if_lookup_by_name(argv[0]))) {
+#if 0
+      wait->callback = mplsd_tunnel_callback_add;
+      mplsd_interface_add_wait_add(wait);
+#endif
+    } else {
+#if 0
+      wait->callback = mplsd_tunnel_callback_delete;
+      mplsd_interface_add_wait_del(wait);
+#endif
+    }
+  }
+
+  vty->index = tun;
+  vty->node = MPLS_IF_NODE;
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mplsd_tunnel,
+       no_mplsd_tunnel_cmd,
+       "no tunnel IFNAME",
+       "Delete a pseudo tunnel's configuration\n"
+       "Tunnel's name\n") {
+  struct mplsd_tunnel *tun;
+
+  tun = mplsd_tunnel_lookup_by_name(argv[0]);
+  if (!tun) {
+    vty_out (vty, "Tunnel %s does not exist%s", argv[0], VTY_NEWLINE);
+    return CMD_WARNING;
+  }
+
+#if 0
+  mplsd_interface_remove_wait_add(tun->wait);
+  mplsd_interface_remove_wait_del(tun->wait);
+#endif
+
+  /* Delete tunnel */
+  mplsd_tunnel_delete(tun, 1);
+
+  return CMD_SUCCESS;
+}
+
+extern struct mplsd_static_info *mplsd_static_info;
+
+DEFUN (mplsd_tunnel_out_segment,
+       mplsd_tunnel_out_segment_cmd,
+       "out-segment INDEX",
+       "Assign an out-segment to this tunnel\n"
+       "MPLS out-segment index\n") {
+
+  struct mplsd_out_segment *out_old;
+  struct mplsd_out_segment *out;
+  struct interface *tun;
+  struct mpls_label ml;
+  struct ifreq ifr;
+
+  tun = vty->index;
+
+  if (!(out = mplsd_out_segment_lookup_by_index(mplsd_static_info,
+    atoi(argv[0])))) {
+    vty_out(vty, "Unable to find out-segment %s%s", argv[0], VTY_NEWLINE);
+    return CMD_WARNING;
+  }
+
+  out_old = (struct mplsd_out_segment*)tun->info;
+  if (out_old) {
+    mos2ml(out_old,&ml);
+    memcpy(&ifr.ifr_data,&ml,sizeof(struct mpls_label));
+    mplsd_ioctl(SIOCMPLSTUNNELDELOUT,(caddr_t)&ifr);
+  }
+
+  mos2ml(out,&ml);
+  memcpy(&ifr.ifr_data,&ml,sizeof(struct mpls_label));
+  if (mplsd_ioctl(SIOCMPLSTUNNELADDOUT,(caddr_t)&ifr)) {
+    vty_out(vty, "Unable to set out-segment %s on tunnel %s%s", argv[0],
+      tun->name, VTY_NEWLINE);
+    return CMD_WARNING;
+  }
+  tun->info = out;
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_mplsd_tunnel_out_segment,
+       no_mplsd_tunnel_out_segment_cmd,
+       "no out-segment",
+       "Delete the out-segment associated with this tunnel\n"
+       "MPLS out-segment index\n") {
+
+  struct interface *tun;
+
+  tun = vty->index;
+
+  if (tun->info) {
+    struct mplsd_out_segment *out = tun->info;
+    struct mpls_label ml;
+    struct ifreq ifr;
+
+    mos2ml(out,&ml);
+    memcpy(&ifr.ifr_data,&ml,sizeof(struct mpls_label));
+    mplsd_ioctl(SIOCMPLSTUNNELDELOUT,(caddr_t)&ifr);
+  }
+
+  return CMD_SUCCESS;
+}
+
+static void mplsd_dump_tunnel_vty(struct vty *vty, struct mplsd_tunnel *ifp) {
+  vty_out (vty, "Tunnel %s%s", ifp->iff.name, VTY_NEWLINE);
+  if (ifp->iff.desc) {
+    vty_out (vty, "  Description: %s%s", ifp->iff.desc, VTY_NEWLINE);
+  }
+  if (ifp->iff.ifindex <= 0) {
+    vty_out(vty, "  index %d pseudo tunnel%s", ifp->iff.ifindex, VTY_NEWLINE);
+  }
+  vty_out (vty, "%s", VTY_NEWLINE);
+}
+
+DEFUN (mplsd_show_tunnel, mplsd_show_tunnel_cmd,
+       "show tunnel [IFNAME]",
+       SHOW_STR
+       "MPLS Tunnel status and configuration\n"
+       "Inteface name\n") {
+  listnode node;
+  struct mplsd_tunnel *ifp;
+
+  if (argc != 0) {
+    ifp = mplsd_tunnel_lookup_by_name(argv[0]);
+    if (ifp == NULL) {
+      vty_out(vty, "%% Can't find tunnel %s%s", argv[0], VTY_NEWLINE);
+      return CMD_WARNING;
+    }
+    mplsd_dump_tunnel_vty(vty, ifp);
+    return CMD_SUCCESS;
+  }
+
+  for (node = listhead(mplsd_tunnel_list); node; nextnode(node)) {
+    mplsd_dump_tunnel_vty(vty, getdata(node));
+  }
+
+  return CMD_SUCCESS;
+}
+
+static int mplsd_tunnel_config_write(struct vty *vty) {
+  listnode node;
+  struct interface *ifp;
+
+  for (node = listhead(mplsd_tunnel_list); node; nextnode(node)) {
+    ifp = getdata(node);
+    vty_out (vty, "tunnel %s%s", ifp->name, VTY_NEWLINE);
+  }
+
+  vty_out (vty, "!%s", VTY_NEWLINE);
+  return 0;
+}
+
+static struct cmd_node mplsd_tunnel_node = {MPLS_IF_NODE, "%s(config-tun)# ", 1};
+
+void mplsd_tunnel_init () {
+  mplsd_tunnel_list = list_new();
+
+  install_node(&mplsd_tunnel_node, mplsd_tunnel_config_write);
+  install_default(MPLS_IF_NODE);
+
+  install_element(VIEW_NODE, &mplsd_show_tunnel_cmd);
+  install_element(ENABLE_NODE, &mplsd_show_tunnel_cmd);
+
+  install_element(CONFIG_NODE, &mplsd_tunnel_cmd);
+  install_element(CONFIG_NODE, &no_mplsd_tunnel_cmd);
+}
diff --exclude=CVS -uNr zebra/mplsd/static_tunnel.h zebra-ldp/mplsd/static_tunnel.h
--- zebra/mplsd/static_tunnel.h 1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/static_tunnel.h     2003-02-26 15:47:45.000000000 -0600
@@ -0,0 +1,17 @@
+#ifndef MPLS_TUNNEL_H
+#define MPLS_TUNNEL_H
+#include <zebra.h>
+#include "if.h"
+
+struct mplsd_tunnel {
+  struct interface iff;
+  struct mplsd_interface_wait *wait;
+  struct mplsd_out_segment *out;
+};
+
+extern void mplsd_tunnel_init();
+extern struct mplsd_tunnel *mplsd_tunnel_lookup_by_name(char *name);
+extern struct mplsd_tunnel *mplsd_tunnel_create(char *name, int mode);
+extern void mplsd_tunnel_delete(struct mplsd_tunnel *ifp, int mode);
+
+#endif
diff --exclude=CVS -uNr zebra/mplsd/static_vty.c zebra-ldp/mplsd/static_vty.c
--- zebra/mplsd/static_vty.c    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/static_vty.c        2003-02-26 15:47:45.000000000 -0600
@@ -0,0 +1,581 @@
+#include <zebra.h>
+
+#include "vty.h"
+#include "command.h"
+
+#include "mpls.h"
+#include "mpls_vty.h"
+#include "static.h"
+
+#include "lsr_cfg.h"
+
+char *owner_name[4] = { "LDP", "CR-LDP", "STATIC", "RSVP" };
+
+DEFUN (mpls_static,
+       mpls_static_cmd,
+       "mpls static",
+       "MPLS configuration\n"
+       "Static MPLS configuration\n") {
+
+    vty->node = MPLS_STATIC_NODE;
+    vty->index = static_get();
+
+    return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_static,
+       no_mpls_static_cmd,
+       "no mpls static",
+       NO_STR
+       "MPLS configuration\n"
+       "Static MPLS configuration\n") {
+    struct mpls *mpls = mpls_get();
+
+    if (!mpls->mstatic) {
+       vty_out (vty, "There isn't an active static MPLS instance.%s",
+           VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    static_finish(mpls->mstatic);
+    return CMD_SUCCESS;
+}
+
+static int do_mpls_static_insegment(struct static_insegment *in,
+    unsigned int label, unsigned int labelspace) {
+    in->in.info.label.type = MPLS_LABEL_TYPE_GENERIC;
+    in->in.info.label.u.gen = label;
+    in->in.info.labelspace = labelspace;
+    in->in.info.owner = MPLS_OWNER_STATIC;
+    in->in.info.family = MPLS_FAMILY_IPV4;
+    in->in.info.npop = 1;
+    return lsr_cfg_insegment_set(in->mstatic->mpls->h,&in->in,LSR_CFG_ADD|
+       LSR_INSEGMENT_CFG_NPOP|LSR_INSEGMENT_CFG_FAMILY|
+       LSR_INSEGMENT_CFG_LABELSPACE|LSR_INSEGMENT_CFG_LABEL|
+       LSR_INSEGMENT_CFG_OWNER);
+}
+
+static int do_mpls_static_outsegment(struct static_outsegment *out,
+    unsigned int label, mpls_nexthop *nh) {
+    out->out.info.label.type = MPLS_LABEL_TYPE_GENERIC;
+    out->out.info.label.u.gen = label;
+    out->out.info.owner = MPLS_OWNER_STATIC;
+    out->out.info.push_label = MPLS_BOOL_TRUE;
+    memcpy(&out->out.info.nexthop, nh, sizeof(mpls_nexthop));
+    
+    return lsr_cfg_outsegment_set(out->mstatic->mpls->h,&out->out, LSR_CFG_ADD|
+       LSR_OUTSEGMENT_CFG_PUSH_LABEL|LSR_OUTSEGMENT_CFG_OWNER|
+       LSR_OUTSEGMENT_CFG_LABEL|LSR_OUTSEGMENT_CFG_NEXTHOP);
+}
+
+static int do_mpls_static_xconnect(struct static_insegment *in,
+    struct static_outsegment *out) {
+    in->xc.insegment_index = in->in.index;
+    in->xc.outsegment_index = out->out.index;
+    in->xc.info.owner = MPLS_OWNER_STATIC;
+    in->xc.info.lspid = 1;
+    return lsr_cfg_xconnect_set2(in->mstatic->mpls->h, &in->xc, LSR_CFG_ADD|
+        LSR_XCONNECT_CFG_OUTSEGMENT|LSR_XCONNECT_CFG_INSEGMENT|
+        LSR_XCONNECT_CFG_LSPID|LSR_XCONNECT_CFG_OWNER);
+}
+
+DEFUN (mpls_static_in_segment,
+       mpls_static_in_segment_cmd,
+       "in-segment INDEX generic LABEL LABELSPACE",
+       "Create an MPLS in-segment\n"
+       "Insegment index\n"
+       "Generic label family\n"
+       "Generic label value\n"
+       "LabelSpace\n") {
+    struct mpls_static *mstatic = (struct mpls_static*)vty->index;
+    struct static_insegment *in;
+    unsigned int index;
+    unsigned int label;
+    unsigned int labelspace;
+
+    VTY_GET_UINT32("INDEX",index,argv[0]);
+    VTY_GET_UINT32_RANGE("LABEL",label,argv[1],16,0xFFFFF);
+    VTY_GET_UINT32_RANGE("LABELSPACE",labelspace,argv[2],0,255);
+
+    if ((in = static_insegment_get(mstatic, index, 0))) {
+       vty_out (vty, "There is an insegment with index %d already.%s", index,
+           VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    in = static_insegment_get(mstatic, index, 1);
+    do_mpls_static_insegment(in, label, labelspace);
+    return CMD_SUCCESS;
+}
+
+DEFUN (mpls_static_in_segment_xc,
+       mpls_static_in_segment_xc_cmd,
+       "in-segment INDEX generic LABEL LABELSPACE cross-connect OUTINDEX",
+       "Create an MPLS in-segment\n"
+       "Insegment index\n"
+       "Generic label family\n"
+       "Generic label value\n"
+       "LabelSpace\n"
+       "Cross Connect\n"
+       "Outsegment Index\n") {
+    struct mpls_static *mstatic = (struct mpls_static*)vty->index;
+    struct static_insegment *in;
+    struct static_outsegment *out;
+    unsigned int index;
+    unsigned int label;
+    unsigned int labelspace;
+    unsigned int out_index;
+
+    VTY_GET_UINT32("INDEX",index,argv[0]);
+    VTY_GET_UINT32_RANGE("LABEL",label,argv[1],16,0xFFFFF);
+    VTY_GET_UINT32_RANGE("LABELSPACE",labelspace,argv[2],0,255);
+    VTY_GET_UINT32("OUTINDEX",out_index,argv[3]);
+
+    if (!(out = static_outsegment_get(mstatic, out_index, 0))) {
+       vty_out (vty, "There isn't an outsegment with index %d.%s", out_index,
+           VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+    
+    in = static_insegment_get(mstatic, index, 1);
+    if (in->in.index) {
+       if (in->in.info.label.type != MPLS_LABEL_TYPE_GENERIC ||
+           in->in.info.label.u.gen != label ||
+           in->in.info.labelspace != labelspace ||
+           in->in.info.owner != MPLS_OWNER_STATIC) {
+           vty_out (vty, "There is an insegment with index %d, label %d,"
+               "and labelspace %d already.%s", index, label, labelspace,
+               VTY_NEWLINE);
+           return CMD_WARNING;
+       }
+    } else {
+       do_mpls_static_insegment(in, label, labelspace);
+    }
+
+    if (in->out_index) {
+       vty_out (vty, "Insegment %d is already cross-connect to "
+           "outsegment %d.%s", index, in->out_index, VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+    in->out_index = out_index;
+    do_mpls_static_xconnect(in, out);
+    
+    return CMD_SUCCESS;
+}
+
+DEFUN (mpls_static_in_segment_xc2,
+       mpls_static_in_segment_xc2_cmd,
+       "in-segment INDEX cross-connect OUTINDEX",
+       "Create an MPLS in-segment\n"
+       "Insegment index\n"
+       "Cross Connect\n"
+       "Outsegment Index\n") {
+    struct mpls_static *mstatic = (struct mpls_static*)vty->index;
+    struct static_insegment *in;
+    struct static_outsegment *out;
+    unsigned int index;
+    unsigned int out_index;
+
+    VTY_GET_UINT32("INDEX",index,argv[0]);
+    VTY_GET_UINT32("OUTINDEX",out_index,argv[1]);
+
+    if (!(in = static_insegment_get(mstatic, index, 0))) {
+        vty_out (vty, "There isn't an insegment with index %d.%s", index,
+            VTY_NEWLINE);
+        return CMD_WARNING;
+    }
+
+    if (!(out = static_outsegment_get(mstatic, out_index, 0))) {
+        vty_out (vty, "There isn't an outsegment with index %d.%s", out_index,
+            VTY_NEWLINE);
+        return CMD_WARNING;
+    }
+
+    do_mpls_static_xconnect(in, out);
+
+    return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_static_in_segment,
+       no_mpls_static_in_segment_cmd,
+       "no in-segment INDEX",
+       NO_STR
+       "Delete an MPLS in-segment\n"
+       "Index of In-segment\n") {
+    struct mpls_static *mstatic = (struct mpls_static*)vty->index;
+    struct static_insegment *in;
+    int index;
+
+    VTY_GET_UINT32("INDEX",index,argv[0]);
+
+    if (!(in  = static_insegment_get(mstatic, index, 0))) {
+       vty_out (vty, "There isn't an insegment with the index %d.%s", index,
+           VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+    lsr_cfg_insegment_set(in->mstatic->mpls->h,&in->in,LSR_CFG_DEL);
+    static_insegment_finish(in);
+    return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_static_in_segment_xc,
+       no_mpls_static_in_segment_xc_cmd,
+       "no in-segment INDEX cross-connect",
+       NO_STR
+       "Delete an MPLS in-segment\n"
+       "Index of In-segment\n"
+       "Cross Connect\n") {
+    struct mpls_static *mstatic = (struct mpls_static*)vty->index;
+    struct static_insegment *in;
+    int index; 
+    
+    VTY_GET_UINT32("INDEX",index,argv[0]);
+    
+    if (!(in  = static_insegment_get(mstatic, index, 0))) {
+        vty_out (vty, "There isn't an insegment with the index %d.%s", index,
+            VTY_NEWLINE);
+        return CMD_WARNING;
+    }
+    if (!in->out_index) {
+        vty_out (vty, "Insegment %d is not cross-conencted to anything.%s",
+           index, VTY_NEWLINE);
+        return CMD_WARNING;
+    }
+    lsr_cfg_xconnect_set(in->mstatic->mpls->h,&in->xc,LSR_CFG_DEL);
+    in->out_index = 0;
+    return CMD_SUCCESS;
+}
+
+DEFUN (mpls_static_out_segment_nh_ipaddr,
+       mpls_static_out_segment_nh_ipaddr_cmd,
+       "out-segment INDEX generic LABEL next-hop IPADDR",
+       "Create an MPLS out-segment\n"
+       "Index for the out-segment\n"
+       "Generic label family\n"
+       "Generic label value\n"
+       "Next Hop\n"
+       "IP Address\n") {
+    struct mpls_static *mstatic = (struct mpls_static*)vty->index;
+    struct static_outsegment *out;
+    struct interface *iff;
+    unsigned int index;
+    unsigned int label;
+    struct in_addr ip;
+    mpls_nexthop nh;
+
+    VTY_GET_UINT32("INDEX",index,argv[0]);
+    VTY_GET_UINT32("LABEL",label,argv[1]);
+    VTY_GET_IPV4_ADDRESS("NEXTHOP",ip,argv[2]);
+
+    if ((out = static_outsegment_get(mstatic, index, 0))) {
+       vty_out (vty, "There is an insegment with index %d already.%s", index,
+           VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    out = static_outsegment_get(mstatic, index, 1);
+    iff = if_lookup_address(ip);
+    nh.type = MPLS_NH_IP|MPLS_NH_IF;
+    nh.if_handle = iff;
+    nh.ip.u.ipv4 = ntohl(ip.s_addr);
+
+    do_mpls_static_outsegment(out, label, &nh);
+
+    return CMD_SUCCESS;
+}
+
+DEFUN (mpls_static_out_segment_nh_intf,
+       mpls_static_out_segment_nh_intf_cmd,
+       "out-segment INDEX generic LABEL interface IFNAME",
+       "Create an MPLS out-segment\n"
+       "Index for the out-segment\n"
+       "Generic label family\n"
+       "Generic label value\n"
+       "Next Hop\n"
+       "Interface\n") {
+    struct mpls_static *mstatic = (struct mpls_static*)vty->index;
+    struct static_outsegment *out;
+    struct interface *iff;
+    unsigned int index;
+    unsigned int label;
+    mpls_nexthop nh;
+
+    VTY_GET_UINT32("INDEX",index,argv[0]);
+    VTY_GET_UINT32("LABEL",label,argv[1]);
+
+    if ((out = static_outsegment_get(mstatic, index, 0))) {
+       vty_out (vty, "There is an insegment with index %d already.%s", index,
+           VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    out = static_outsegment_get(mstatic, index, 1);
+    iff = if_lookup_by_name(argv[2]);
+    nh.type = MPLS_NH_IF;
+    nh.if_handle = iff;
+
+    do_mpls_static_outsegment(out, label, &nh);
+
+    return CMD_SUCCESS;
+}
+
+DEFUN (no_mpls_static_out_segment,
+       no_mpls_static_out_segment_cmd,
+       "no out-segment INDEX",
+       NO_STR
+       "Delete an MPLS out-segment\n"
+       "Index of the out-segment\n") {
+    struct mpls_static *mstatic = (struct mpls_static*)vty->index;
+    struct static_outsegment *out;
+    unsigned int index;
+
+    VTY_GET_UINT32("INDEX",index,argv[0]);
+
+    if (!(out = static_outsegment_get(mstatic, index, 0))) {
+       vty_out (vty, "There isn't an outsegment with the index %d.%s", index,
+           VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    lsr_cfg_outsegment_set(out->mstatic->mpls->h,&out->out,LSR_CFG_DEL);
+    static_outsegment_finish(out);
+    return CMD_SUCCESS;
+}
+
+DEFUN (mpls_show_mpls_fwd, mpls_show_mpls_fwd_cmd,
+       "show mpls forwarding",
+       SHOW_STR
+       "MPLS related commands\n"
+       "MPLS forwarding table\n") {
+    struct mpls *mpls = mpls_get();
+    struct lsr_outsegment out;
+    struct lsr_insegment in;
+    struct lsr_xconnect xc;
+    struct in_addr ip;
+    struct interface *iff;
+    int count;
+
+    if (!mpls) {
+       vty_out (vty, "There isn't an active MPLS instance.%s",
+           VTY_NEWLINE);
+       return CMD_WARNING;
+    }
+
+    vty_out(vty, "Insegments:%s",VTY_NEWLINE);
+
+    count = 0;
+    in.index = 0;
+    while (lsr_cfg_insegment_getnext(mpls->h,&in,0xFFFFFFFF)==MPLS_SUCCESS) {
+        if (!count) {
+           vty_out(vty, "  Lbl Spc  Label Owner%s", VTY_NEWLINE);
+       }
+       vty_out(vty, "    %-3d  %7d %-6s%s", in.info.labelspace,
+           in.info.label.u.gen, owner_name[in.info.owner], VTY_NEWLINE);
+       count++;
+    }
+    if (!count) {
+       vty_out(vty, "%s", VTY_NEWLINE);
+    }
+    vty_out(vty, "Total %d%s",count, VTY_NEWLINE);
+    vty_out(vty, "%s", VTY_NEWLINE);
+
+    vty_out(vty, "Outsegments:%s",VTY_NEWLINE);
+    count = 0;
+    out.index = 0;
+    while (lsr_cfg_outsegment_getnext(mpls->h,&out,0xFFFFFFFF)==MPLS_SUCCESS) {
+        if (!count) {
+           vty_out(vty, "  Interface          Label Next Hop      Owner%s",
+               VTY_NEWLINE);
+       }
+       if (out.info.nexthop.type & MPLS_NH_IP) {
+           ip.s_addr = htonl(out.info.nexthop.ip.u.ipv4);
+       } else {
+           ip.s_addr = 0;
+       }
+       if (out.info.nexthop.type & MPLS_NH_IF) {
+           iff = out.info.nexthop.if_handle;
+       } else {
+           iff = NULL;
+       }
+       vty_out(vty, "  %-16s %7d %-15s %-6s%s",iff->name,
+           out.info.label.u.gen, inet_ntoa(ip), owner_name[out.info.owner],
+           VTY_NEWLINE);
+       count++;
+    }
+    if (!count) {
+       vty_out(vty, "%s", VTY_NEWLINE);
+    }
+    vty_out(vty, "Total %d%s",count, VTY_NEWLINE);
+    vty_out(vty, "%s", VTY_NEWLINE);
+
+    vty_out(vty, "Cross Connects:%s",VTY_NEWLINE);
+    count = 0;
+    xc.index = 0;
+    while (lsr_cfg_xconnect_getnext(mpls->h,&xc,0xFFFFFFFF) == MPLS_SUCCESS) {
+        if (!count) {
+            vty_out(vty, "  Lbl Spc  In Label Out Label Interface        "
+               "Next Hop      Owner%s", VTY_NEWLINE);
+       }
+
+       in.index = xc.insegment_index;
+       lsr_cfg_insegment_get(mpls->h,&in,0xFFFFFFFF);
+
+       out.index = xc.outsegment_index;
+       lsr_cfg_outsegment_get(mpls->h,&out,0xFFFFFFFF);
+       if (out.info.nexthop.type & MPLS_NH_IP) {
+           ip.s_addr = htonl(out.info.nexthop.ip.u.ipv4);
+       } else {
+           ip.s_addr = 0;
+       }
+       if (out.info.nexthop.type & MPLS_NH_IF) {
+           iff = out.info.nexthop.if_handle;
+       } else {
+           iff = NULL;
+       }
+
+       vty_out(vty, "    %-3d     %7d   %7d %-16s %-15s %-6s%s",
+           in.info.labelspace, in.info.label.u.gen, out.info.label.u.gen,
+           iff->name, inet_ntoa(ip), owner_name[in.info.owner], VTY_NEWLINE);
+       count++;
+    }
+    if (!count) {
+       vty_out(vty, "%s", VTY_NEWLINE);
+    }
+    vty_out(vty, "Total %d%s",count, VTY_NEWLINE);
+    vty_out(vty, "%s", VTY_NEWLINE);
+
+    return CMD_SUCCESS;
+}
+
+DEFUN (mpls_show_mpls_ftn, mpls_show_mpls_ftn_cmd,
+       "show mpls ftn",
+       SHOW_STR
+       "MPLS related commands\n"
+       "MPLS FTN bindings\n") {
+    struct mpls *mpls = mpls_get();
+    lsr_outsegment out;
+    char buf[24];
+    struct interface *iff;
+    struct in_addr ip;
+    lsr_ftn ftn;
+    int count = 0;
+
+    vty_out(vty, "FTNs:%s",VTY_NEWLINE);
+    ftn.index = 0;
+    while (lsr_cfg_ftn_getnext(mpls->h,&ftn,0xFFFFFFFF) == MPLS_SUCCESS) {
+        if (!count) {
+            vty_out(vty, "  FEC               Out Label Interface      "
+               "Next Hop        Owner%s", VTY_NEWLINE);
+       }
+
+       out.index = ftn.outsegment_index;
+       lsr_cfg_outsegment_get(mpls->h,&out,0xFFFFFFFF);
+
+       vty_out(vty, "  ");
+       switch(ftn.fec.type) {
+           case MPLS_FEC_PREFIX:
+               ip.s_addr = htonl(ftn.fec.u.prefix.network.u.ipv4);
+               sprintf(buf, "%s/%d", inet_ntoa(ip),ftn.fec.u.prefix.length);
+               vty_out(vty, "%-18s", buf);
+               break;
+           case MPLS_FEC_HOST:
+               ip.s_addr = htonl(ftn.fec.u.host.u.ipv4);
+               vty_out(vty, "%-18s", inet_ntoa(ip));
+               break;
+           case MPLS_FEC_L2CC:
+           default:
+               vty_out(vty, "%-18s", "(unknown)");
+       }
+       vty_out(vty, "  ");
+
+        if (out.info.nexthop.type & MPLS_NH_IP) {
+            ip.s_addr = htonl(out.info.nexthop.ip.u.ipv4);
+       } else {
+           ip.s_addr = 0;
+       }
+        if (out.info.nexthop.type & MPLS_NH_IF) {
+            iff = out.info.nexthop.if_handle;
+        } else {
+           iff = NULL;
+        }
+       vty_out(vty, "%7d %-15s %-15s %-6s%s", out.info.label.u.gen,
+           iff->name, inet_ntoa(ip), owner_name[out.info.owner], VTY_NEWLINE);
+
+       count++;
+    }
+
+    if (!count) {
+       vty_out(vty, "%s", VTY_NEWLINE);
+    }
+    vty_out(vty, "Total %d%s",count, VTY_NEWLINE);
+    vty_out(vty, "%s", VTY_NEWLINE);
+    return CMD_SUCCESS;
+}
+
+static int mpls_static_config_write (struct vty *vty) {
+    struct mpls *mpls = mpls_get();
+    struct mpls_static *mstatic = mpls->mstatic;
+    struct static_outsegment *out;
+    struct static_insegment *in;
+    struct listnode *tmp;
+
+    if (!mstatic) {
+       return 0;
+    }
+
+    vty_out(vty, "mpls static%s", VTY_NEWLINE);
+
+    LIST_LOOP(mstatic->outsegment, out, tmp) {
+       vty_out(vty, " out-segment %d generic %d", out->index,
+           out->out.info.label.u.gen);
+       if (out->out.info.nexthop.type & MPLS_NH_IF) {
+           vty_out(vty, " interface %s",
+               out->out.info.nexthop.if_handle->name);
+       }
+       if (out->out.info.nexthop.type & MPLS_NH_IP) {
+           struct in_addr ip;
+           ip.s_addr = htonl(out->out.info.nexthop.ip.u.ipv4);
+           vty_out(vty, " next-hop %s", inet_ntoa(ip));
+       }
+       vty_out(vty,"%s", VTY_NEWLINE);
+    }
+
+    LIST_LOOP(mstatic->insegment, in, tmp) {
+       vty_out(vty, " in-segment %d generic %d %d", in->index,
+           in->in.info.label.u.gen, in->in.info.labelspace);
+       if (in->out_index) {
+           vty_out(vty, " cross-connect %d", in->out_index);
+       }
+       vty_out(vty, "%s", VTY_NEWLINE);
+    }
+    vty_out(vty,"!%s", VTY_NEWLINE);
+    return 0;
+}
+
+static struct cmd_node static_node = {MPLS_STATIC_NODE,"%s(config-mpls)# ",1};
+
+void static_vty_show_init() {
+  install_element (VIEW_NODE, &mpls_show_mpls_fwd_cmd);
+  install_element (ENABLE_NODE, &mpls_show_mpls_fwd_cmd);
+
+  install_element (VIEW_NODE, &mpls_show_mpls_ftn_cmd);
+  install_element (ENABLE_NODE, &mpls_show_mpls_ftn_cmd);
+}
+
+void static_vty_init () {
+
+  install_node (&static_node, mpls_static_config_write);
+  install_default (MPLS_STATIC_NODE);
+
+  install_element (CONFIG_NODE, &mpls_static_cmd);
+  install_element (CONFIG_NODE, &no_mpls_static_cmd);
+
+  install_element(MPLS_STATIC_NODE, &mpls_static_in_segment_cmd);
+  install_element(MPLS_STATIC_NODE, &mpls_static_in_segment_xc_cmd);
+  install_element(MPLS_STATIC_NODE, &no_mpls_static_in_segment_cmd);
+  install_element(MPLS_STATIC_NODE, &no_mpls_static_in_segment_xc_cmd);
+
+  install_element(MPLS_STATIC_NODE, &mpls_static_out_segment_nh_ipaddr_cmd);
+  install_element(MPLS_STATIC_NODE, &mpls_static_out_segment_nh_intf_cmd);
+  install_element(MPLS_STATIC_NODE, &no_mpls_static_out_segment_cmd);
+}
diff --exclude=CVS -uNr zebra/mplsd/static_vty.h zebra-ldp/mplsd/static_vty.h
--- zebra/mplsd/static_vty.h    1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/mplsd/static_vty.h        2003-02-26 15:47:45.000000000 -0600
@@ -0,0 +1,7 @@
+#ifndef STATIC_VTY_H
+#define STATIC_VTY_H
+
+void static_vty_init();
+void static_vty_show_init();
+
+#endif
diff --exclude=CVS -uNr zebra/ospfd/ospfd.c zebra-ldp/ospfd/ospfd.c
--- zebra/ospfd/ospfd.c 2003-03-14 08:45:16.000000000 -0600
+++ zebra-ldp/ospfd/ospfd.c     2003-02-26 15:48:30.000000000 -0600
@@ -56,6 +56,7 @@
 struct ospf *ospf_top;
 
 extern struct zclient *zclient;
+extern struct in_addr router_id_zebra;
 
 \f
 void ospf_remove_vls_through_area (struct ospf_area *);
@@ -63,33 +64,6 @@
 void ospf_area_free (struct ospf_area *);
 void ospf_network_run (struct ospf *, struct prefix *, struct ospf_area *);
 
-/* Get Router ID from ospf interface list. */
-struct in_addr
-ospf_router_id_get (list if_list)
-{
-  listnode node;
-  struct in_addr router_id;
-
-  memset (&router_id, 0, sizeof (struct in_addr));
-
-  for (node = listhead (if_list); node; nextnode (node))
-    {
-      struct ospf_interface *oi = getdata (node);
-
-      if (!if_is_up (oi->ifp) ||
-         OSPF_IF_PARAM (oi, passive_interface) == OSPF_IF_PASSIVE)
-       continue;
-      
-      /* Ignore virtual link interface. */
-      if (oi->type != OSPF_IFTYPE_VIRTUALLINK &&
-         oi->type != OSPF_IFTYPE_LOOPBACK) 
-       if (IPV4_ADDR_CMP (&router_id, &oi->address->u.prefix4) < 0)
-         router_id = oi->address->u.prefix4;
-    }
-
-  return router_id;
-}
-
 #define OSPF_EXTERNAL_LSA_ORIGINATE_DELAY 1
 
 void
@@ -106,7 +80,7 @@
   if (ospf_top->router_id_static.s_addr != 0)
     router_id = ospf_top->router_id_static;
   else
-    router_id = ospf_router_id_get (ospf_top->oiflist);
+    router_id = router_id_zebra;
 
   ospf_top->router_id = router_id;
   
diff --exclude=CVS -uNr zebra/ospfd/ospf_lsdb.c zebra-ldp/ospfd/ospf_lsdb.c
--- zebra/ospfd/ospf_lsdb.c     2003-03-14 08:45:05.000000000 -0600
+++ zebra-ldp/ospfd/ospf_lsdb.c 2003-02-26 15:48:04.000000000 -0600
@@ -284,8 +284,8 @@
 }
 
 struct ospf_lsa *
-foreach_lsa (struct route_table *table, void *p_arg, int int_arg, 
-            int (*callback) (struct ospf_lsa *, void *, int))
+foreach_lsa (struct route_table *table, void *p_arg, int int_arg,
+             int (*callback) (struct ospf_lsa *, void *, int))
 {
   struct route_node *rn;
   struct ospf_lsa *lsa;
@@ -293,6 +293,21 @@
   for (rn = route_top (table); rn; rn = route_next (rn))
     if ((lsa = rn->info) != NULL)
       if (callback (lsa, p_arg, int_arg))
+        return lsa;
+
+  return NULL;
+}
+
+struct ospf_lsa *
+foreach_lsa_sum (struct route_table *table, void *p_arg, int *sum, int int_arg, 
+            int (*callback) (struct ospf_lsa *, void *, int*, int))
+{
+  struct route_node *rn;
+  struct ospf_lsa *lsa;
+
+  for (rn = route_top (table); rn; rn = route_next (rn))
+    if ((lsa = rn->info) != NULL)
+      if (callback (lsa, p_arg, sum, int_arg))
        return lsa;
 
   return NULL;
diff --exclude=CVS -uNr zebra/ospfd/ospf_lsdb.h zebra-ldp/ospfd/ospf_lsdb.h
--- zebra/ospfd/ospf_lsdb.h     2003-03-14 08:45:05.000000000 -0600
+++ zebra-ldp/ospfd/ospf_lsdb.h 2003-02-26 15:48:06.000000000 -0600
@@ -79,5 +79,7 @@
 unsigned long ospf_lsdb_isempty (struct ospf_lsdb *);
 struct ospf_lsa *foreach_lsa (struct route_table *, void *, int,
                      int (*callback) (struct ospf_lsa *, void *, int));
+struct ospf_lsa *foreach_lsa_sum (struct route_table *, void *, int *, int,
+                     int (*callback) (struct ospf_lsa *, void *, int *, int));
 
 #endif /* _ZEBRA_OSPF_LSDB_H */
diff --exclude=CVS -uNr zebra/ospfd/ospf_vty.c zebra-ldp/ospfd/ospf_vty.c
--- zebra/ospfd/ospf_vty.c      2003-03-14 08:45:14.000000000 -0600
+++ zebra-ldp/ospfd/ospf_vty.c  2003-02-26 22:39:57.000000000 -0600
@@ -3046,7 +3046,7 @@
 \f
 /* Show functions */
 int
-show_lsa_summary (struct ospf_lsa *lsa, void *v, int self)
+show_lsa_summary (struct ospf_lsa *lsa, void *v, int *sum, int self)
 {
   struct vty *vty = (struct vty *) v;
   struct router_lsa *rl;
@@ -3059,6 +3059,7 @@
     if (self == 0 || IS_LSA_SELF (lsa))
       {
        /* LSA common part show. */
+       (*sum) += ntohs (lsa->data->checksum);
        vty_out (vty, "%-15s ", inet_ntoa (lsa->data->id));
        vty_out (vty, "%-15s %4d 0x%08lx 0x%04x",
                 inet_ntoa (lsa->data->adv_router), LS_AGE (lsa),
@@ -3592,6 +3593,7 @@
 void
 show_ip_ospf_database_summary (struct vty *vty, int self)
 {
+  unsigned int sum;
   listnode node;
   int type;
 
@@ -3619,9 +3621,10 @@
                        VTY_NEWLINE, VTY_NEWLINE);
               vty_out (vty, "%s%s", show_database_header[type], VTY_NEWLINE);
 
-              foreach_lsa (AREA_LSDB (area, type), vty, self, show_lsa_summary);
-
-              vty_out (vty, "%s", VTY_NEWLINE);
+              sum = 0;
+              foreach_lsa_sum (AREA_LSDB (area, type), vty, &sum, self, show_lsa_summary);
+              vty_out (vty, "%s                Sum of CkSum: 0x%08x%s%s", 
+                       VTY_NEWLINE, sum, VTY_NEWLINE, VTY_NEWLINE);
          }
        }
     }
@@ -3646,8 +3649,11 @@
               VTY_NEWLINE, VTY_NEWLINE);
           vty_out (vty, "%s%s", show_database_header[type],
               VTY_NEWLINE);
-          foreach_lsa (AS_LSDB (ospf_top, type), vty, self, show_lsa_summary);
-          vty_out (vty, "%s", VTY_NEWLINE);
+
+          sum = 0;
+          foreach_lsa_sum (AS_LSDB (ospf_top, type), vty, &sum, self, show_lsa_summary);
+          vty_out (vty, "%s                Sum of CkSum: 0x%08x%s%s", 
+                       VTY_NEWLINE, sum, VTY_NEWLINE, VTY_NEWLINE);
         }
     }
 
diff --exclude=CVS -uNr zebra/ospfd/ospf_zebra.c zebra-ldp/ospfd/ospf_zebra.c
--- zebra/ospfd/ospf_zebra.c    2003-03-14 08:45:15.000000000 -0600
+++ zebra-ldp/ospfd/ospf_zebra.c        2003-02-26 22:40:03.000000000 -0600
@@ -53,6 +53,23 @@
 
 /* For registering threads. */
 extern struct thread_master *master;
+struct in_addr router_id_zebra;
+
+/* Router-id update message from zebra. */
+int
+ospf_router_id_update_zebra (int command, struct zclient *zclient,
+  zebra_size_t length)
+{
+  struct prefix router_id;
+  zebra_router_id_update_read(zclient->ibuf,&router_id);
+
+  router_id_zebra = router_id.u.prefix4;
+
+  if (ospf_top && ospf_top->t_router_id_update == NULL)
+     ospf_top->t_router_id_update = thread_add_timer (master,
+        ospf_router_id_update_timer, ospf_top, OSPF_ROUTER_ID_UPDATE_DELAY);
+  return 0;
+}
 
 /* Inteface addition message from zebra. */
 int
@@ -147,19 +164,6 @@
   return ifp;
 }
 
-void
-zebra_interface_if_set_value (struct stream *s, struct interface *ifp)
-{
-  /* Read interface's index. */
-  ifp->ifindex = stream_getl (s);
-
-  /* Read interface's value. */
-  ifp->flags = stream_getl (s);
-  ifp->metric = stream_getl (s);
-  ifp->mtu = stream_getl (s);
-  ifp->bandwidth = stream_getl (s);
-}
-
 int
 ospf_interface_state_up (int command, struct zclient *zclient,
                         zebra_size_t length)
@@ -1166,6 +1170,7 @@
   /* Allocate zebra structure. */
   zclient = zclient_new ();
   zclient_init (zclient, ZEBRA_ROUTE_OSPF);
+  zclient->router_id_update = ospf_router_id_update_zebra;
   zclient->interface_add = ospf_interface_add;
   zclient->interface_delete = ospf_interface_delete;
   zclient->interface_up = ospf_interface_state_up;
diff --exclude=CVS -uNr zebra/zebra/main.c zebra-ldp/zebra/main.c
--- zebra/zebra/main.c  2003-03-14 08:45:32.000000000 -0600
+++ zebra-ldp/zebra/main.c      2003-02-26 22:42:44.000000000 -0600
@@ -34,7 +34,7 @@
 #include "zebra/rib.h"
 #include "zebra/zserv.h"
 #include "zebra/debug.h"
-#include "zebra/rib.h"
+#include "zebra/router-id.h"
 
 /* Master of threads. */
 struct thread_master *master;
@@ -258,6 +258,7 @@
   rib_init ();
   zebra_if_init ();
   zebra_debug_init ();
+  router_id_init();
   zebra_vty_init ();
   access_list_init ();
   rtadv_init ();
diff --exclude=CVS -uNr zebra/zebra/Makefile.am zebra-ldp/zebra/Makefile.am
--- zebra/zebra/Makefile.am     2003-03-14 08:45:30.000000000 -0600
+++ zebra-ldp/zebra/Makefile.am 2003-02-26 22:42:29.000000000 -0600
@@ -21,11 +21,11 @@
 
 zebra_SOURCES = \
        zserv.c main.c interface.c connected.c ioctl.c zebra_rib.c \
-       redistribute.c debug.c rtadv.c zebra_snmp.c zebra_vty.c
+       redistribute.c debug.c rtadv.c zebra_snmp.c zebra_vty.c router-id.c
 
 noinst_HEADERS = \
        connected.h ioctl.h rib.h rt.h zserv.h redistribute.h debug.h rtadv.h \
-       interface.h ipforward.h
+       interface.h ipforward.h router-id.h
 
 zebra_LDADD = ../lib/libzebra.a $(otherobj) $(LIB_IPV6)
 
diff --exclude=CVS -uNr zebra/zebra/redistribute.c zebra-ldp/zebra/redistribute.c
--- zebra/zebra/redistribute.c  2003-03-14 08:45:33.000000000 -0600
+++ zebra-ldp/zebra/redistribute.c      2003-02-26 22:42:50.000000000 -0600
@@ -35,6 +35,7 @@
 #include "zebra/zserv.h"
 #include "zebra/redistribute.h"
 #include "zebra/debug.h"
+#include "zebra/router-id.h"
 
 int
 zebra_check_addr (struct prefix *p)
@@ -379,6 +380,8 @@
                 p->prefixlen, ifc->ifp->name);
     }
 
+  router_id_add_address(ifc);
+
   for (node = listhead (client_list); node; nextnode (node))
     if ((client = getdata (node)) != NULL)
       if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
@@ -403,6 +406,8 @@
                 p->prefixlen, ifc->ifp->name);
     }
 
+  router_id_del_address(ifc);
+
   for (node = listhead (client_list); node; nextnode (node))
     if ((client = getdata (node)) != NULL)
       if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
diff --exclude=CVS -uNr zebra/zebra/rib.h zebra-ldp/zebra/rib.h
--- zebra/zebra/rib.h   2003-03-14 08:45:33.000000000 -0600
+++ zebra-ldp/zebra/rib.h       2003-02-26 22:44:34.000000000 -0600
@@ -135,6 +135,9 @@
   unsigned int ifindex;
   char *ifname;
 
+  /* MPLS index */
+  unsigned int mplsindex;
+
   /* Nexthop address or interface name. */
   union
   {
@@ -147,6 +150,7 @@
   /* Recursive lookup nexthop. */
   u_char rtype;
   unsigned int rifindex;
+  unsigned int rmplsindex;
   union
   {
     struct in_addr ipv4;
@@ -215,6 +219,11 @@
 void rib_close ();
 void rib_init ();
 
+#include "prefix.h"
+#include "table.h"
+
+void rib_process (struct route_node *rn, struct rib *del);
+
 int
 static_add_ipv4 (struct prefix *p, struct in_addr *gate, char *ifname,
                 u_char distance, u_int32_t vrf_id);
diff --exclude=CVS -uNr zebra/zebra/router-id.c zebra-ldp/zebra/router-id.c
--- zebra/zebra/router-id.c     1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/zebra/router-id.c 2003-02-26 15:49:07.000000000 -0600
@@ -0,0 +1,239 @@
+#include <zebra.h>
+
+#include "if.h"
+#include "vty.h"
+#include "sockunion.h"
+#include "prefix.h"
+#include "stream.h"
+#include "command.h"
+#include "memory.h"
+#include "ioctl.h"
+#include "connected.h"
+#include "network.h"
+#include "log.h"
+#include "table.h"
+#include "rib.h"
+
+#include "zebra/zserv.h"
+
+static struct list rid_all_sorted_list;
+static struct list rid_lo_sorted_list;
+static struct prefix rid_user_assigned;
+extern struct list *client_list;
+
+static struct connected *router_id_find_node(struct list *l,
+  struct connected *ifc) {
+  struct listnode *node;
+  struct connected *c;
+
+  for (node = l->head; node; node = node->next) {
+    c = (struct connected*)getdata(node);
+    if (prefix_same(ifc->address,c->address)) {
+      return c;
+    }
+  }
+  return NULL;
+}
+
+static int router_id_bad_address(struct connected *ifc) {
+  struct prefix n;
+
+  n.u.prefix4.s_addr = htonl(INADDR_LOOPBACK);
+  n.prefixlen = 8;
+  n.family = AF_INET;
+
+  if (prefix_match(&n,ifc->address)) {
+    return 1;
+  }
+  return 0;
+}
+
+void router_id_get(struct prefix *p) {
+  struct listnode *node;
+  struct connected *c;
+
+  p->u.prefix4.s_addr = 0;
+  p->family = AF_INET;
+  p->prefixlen = 32;
+
+  if (rid_user_assigned.u.prefix4.s_addr) {
+    p->u.prefix4.s_addr = rid_user_assigned.u.prefix4.s_addr;
+  } else if (!list_isempty(&rid_lo_sorted_list)) {
+    node = listtail(&rid_lo_sorted_list);
+    c = getdata(node);
+    p->u.prefix4.s_addr = c->address->u.prefix4.s_addr;
+  } else if (!list_isempty(&rid_all_sorted_list)) {
+    node = listtail(&rid_all_sorted_list);
+    c = getdata(node);
+    p->u.prefix4.s_addr = c->address->u.prefix4.s_addr;
+  }
+}
+
+static void router_id_set(struct prefix *p) {
+  struct prefix p2;
+  struct listnode *node;
+  struct zserv *client;
+
+  rid_user_assigned.u.prefix4.s_addr = p->u.prefix4.s_addr;
+
+  router_id_get(&p2);
+  for (node = listhead(client_list); node; nextnode(node))
+    if ((client = getdata(node)) != NULL)
+      zsend_router_id_update(client,&p2);
+}
+
+void router_id_add_address(struct connected *ifc) {
+  struct list *l = NULL;
+  struct listnode *node;
+  struct prefix before;
+  struct prefix after;
+  struct zserv *client;
+
+  if (router_id_bad_address(ifc)) {
+    return;
+  }
+
+  router_id_get(&before);
+
+  if (!strncmp(ifc->ifp->name,"lo",2) || !strncmp(ifc->ifp->name,"dummy",5)) {
+    l = &rid_lo_sorted_list;
+  } else {
+    l = &rid_all_sorted_list;
+  }
+  if (!router_id_find_node(l,ifc)) {
+    listnode_add(l,ifc);
+  }
+
+  router_id_get(&after);
+
+  if (prefix_same(&before, &after)) {
+    return;
+  }
+
+  for (node = listhead(client_list); node; nextnode(node))
+    if ((client = getdata(node)) != NULL)
+      zsend_router_id_update(client,&after);
+}
+
+void router_id_del_address(struct connected *ifc) {
+  struct connected *c;
+  struct list *l;
+  struct prefix after;
+  struct prefix before;
+  struct listnode *node;
+  struct zserv *client;
+
+  if (router_id_bad_address(ifc)) {
+    return;
+  }
+
+  router_id_get(&before);
+
+  if (!strncmp(ifc->ifp->name,"lo",2) || !strncmp(ifc->ifp->name,"dummy",5)) {
+    l = &rid_lo_sorted_list;
+  } else {
+    l = &rid_all_sorted_list;
+  }
+
+  if ((c = router_id_find_node(l,ifc))) {
+    listnode_delete(l,c);
+  }
+
+  router_id_get(&after);
+
+  if (prefix_same(&before, &after)) {
+    return;
+  }
+
+  for (node = listhead(client_list); node; nextnode(node))
+    if ((client = getdata(node)) != NULL)
+      zsend_router_id_update(client,&after);
+}
+
+void router_id_write(struct vty *vty) {
+  if (rid_user_assigned.u.prefix4.s_addr) {
+    vty_out(vty, "router-id %s%s", inet_ntoa(rid_user_assigned.u.prefix4),
+      VTY_NEWLINE);
+  }
+}
+
+DEFUN (router_id,
+       router_id_cmd,
+       "router-id A.B.C.D",
+       "Manually set the router-id\n"
+       "IP address to use for router-id\n")
+{
+  struct prefix rid;
+  
+  rid.u.prefix4.s_addr = inet_addr(argv[0]);
+  if (!rid.u.prefix4.s_addr) {
+    return CMD_WARNING;
+  }
+  rid.prefixlen = 32;
+  rid.family = AF_INET;
+
+  router_id_set(&rid);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_router_id,
+       no_router_id_cmd,
+       "no router-id",
+       NO_STR
+       "Remove the manually configured router-id\n")
+{
+  struct prefix rid;
+  
+  rid.u.prefix4.s_addr = 0;
+  rid.prefixlen = 0;
+  rid.family = AF_INET;
+
+  router_id_set(&rid);
+
+  return CMD_SUCCESS;
+}
+
+DEFUN (show_router_id,
+       show_router_id_cmd,
+       "show router-id",
+       SHOW_STR
+       "current router ID\n")
+{
+  struct prefix rid;
+  router_id_get(&rid);
+
+  vty_out(vty, "router-id: %s%s", inet_ntoa(rid.u.prefix4),VTY_NEWLINE);
+  return CMD_SUCCESS;
+}
+
+int router_id_cmp(void *a, void *b) {
+  unsigned int A, B;
+
+  A = ((struct connected*)a)->address->u.prefix4.s_addr;
+  B = ((struct connected*)b)->address->u.prefix4.s_addr;
+
+  if (A > B) {
+    return 1;
+  } else if (A < B) {
+    return -1;
+  }
+  return 0;
+}
+
+void router_id_init(void) {
+  install_element(VIEW_NODE, &show_router_id_cmd);
+  install_element(ENABLE_NODE, &show_router_id_cmd);
+  install_element(CONFIG_NODE, &router_id_cmd);
+  install_element(CONFIG_NODE, &no_router_id_cmd);
+
+  memset(&rid_all_sorted_list,0,sizeof(rid_all_sorted_list));
+  memset(&rid_lo_sorted_list,0,sizeof(rid_lo_sorted_list));
+  memset(&rid_user_assigned,0,sizeof(rid_user_assigned));
+
+  rid_all_sorted_list.cmp = router_id_cmp;
+  rid_lo_sorted_list.cmp = router_id_cmp;
+
+  rid_user_assigned.family = AF_INET;
+  rid_user_assigned.prefixlen = 32;
+}
diff --exclude=CVS -uNr zebra/zebra/router-id.h zebra-ldp/zebra/router-id.h
--- zebra/zebra/router-id.h     1969-12-31 18:00:00.000000000 -0600
+++ zebra-ldp/zebra/router-id.h 2003-02-26 15:49:07.000000000 -0600
@@ -0,0 +1,20 @@
+#ifndef _ROUTER_ID_H_
+#define _ROUTER_ID_H_
+
+#include <zebra.h>
+
+#include "memory.h"
+#include "prefix.h"
+#include "zclient.h"
+#include "if.h"
+
+extern void router_id_add_address(struct connected *);
+extern void router_id_del_address(struct connected *);
+extern void router_id_init(void);
+extern void router_id_write(struct vty *);
+extern void router_id_get(struct prefix *);
+
+extern void zread_router_id_add(struct zserv *, u_short);
+extern void zread_router_id_delete(struct zserv *, u_short);
+
+#endif
diff --exclude=CVS -uNr zebra/zebra/rt_netlink.c zebra-ldp/zebra/rt_netlink.c
--- zebra/zebra/rt_netlink.c    2003-03-14 08:45:36.000000000 -0600
+++ zebra-ldp/zebra/rt_netlink.c        2003-02-26 22:43:11.000000000 -0600
@@ -606,6 +606,7 @@
   
   char anyaddr[16] = {0};
 
+  unsigned int mplsindex;
   int index;
   int table;
   void *dest;
@@ -662,10 +663,14 @@
       return 0;
     }
   
+  mplsindex = 0;
   index = 0;
   dest = NULL;
   gate = NULL;
 
+  if (tb[RTA_LSP])
+    mplsindex = *(unsigned int *) RTA_DATA (tb[RTA_LSP]);
+
   if (tb[RTA_OIF])
     index = *(int *) RTA_DATA (tb[RTA_OIF]);
 
@@ -1208,6 +1213,10 @@
                      || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFNAME)
                    addattr32 (&req.n, sizeof req, RTA_OIF,
                               nexthop->rifindex);
+
+                 if (nexthop->rmplsindex)
+                   addattr32 (&req.n, sizeof req, RTA_LSP,
+                              nexthop->rmplsindex);
                }
              else
                {
@@ -1228,6 +1237,11 @@
                      || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX
                      || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME)
                    addattr32 (&req.n, sizeof req, RTA_OIF, nexthop->ifindex);
+
+                 if (nexthop->mplsindex) {
+fprintf(stderr,"Adding RTA_LSP = 0x%x\n",nexthop->mplsindex);
+                   addattr32 (&req.n, sizeof req, RTA_LSP, nexthop->mplsindex);
+                 }
                }
 
              if (cmd == RTM_NEWROUTE)
@@ -1290,6 +1304,9 @@
                    rtnh->rtnh_ifindex = nexthop->rifindex;
                  else
                    rtnh->rtnh_ifindex = 0;
+
+                 if (nexthop->rmplsindex)
+                   rtnh->rtnh_lsp = nexthop->rmplsindex;
                }
              else
                {
@@ -1316,6 +1333,11 @@
                    rtnh->rtnh_ifindex = nexthop->ifindex;
                  else
                    rtnh->rtnh_ifindex = 0;
+
+                 if (nexthop->mplsindex) {
+fprintf(stderr,"Setting rtnh_lsp = 0x%x\n",nexthop->mplsindex);
+                   rtnh->rtnh_lsp = nexthop->mplsindex;
+                 }
                }
              rtnh = RTNH_NEXT(rtnh);
 
diff --exclude=CVS -uNr zebra/zebra/zebra_rib.c zebra-ldp/zebra/zebra_rib.c
--- zebra/zebra/zebra_rib.c     2003-03-14 08:45:37.000000000 -0600
+++ zebra-ldp/zebra/zebra_rib.c 2003-03-13 21:33:30.000000000 -0600
@@ -396,6 +396,7 @@
                      {
                        SET_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE);
                        nexthop->rtype = newhop->type;
+                       nexthop->rmplsindex = newhop->mplsindex;
                        if (newhop->type == NEXTHOP_TYPE_IPV4 ||
                            newhop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
                          nexthop->rgate.ipv4 = newhop->gate.ipv4;
@@ -494,6 +495,7 @@
                      {
                        SET_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE);
                        nexthop->rtype = newhop->type;
+                       nexthop->rmplsindex = newhop->mplsindex;
                        if (newhop->type == NEXTHOP_TYPE_IPV6
                            || newhop->type == NEXTHOP_TYPE_IPV6_IFINDEX
                            || newhop->type == NEXTHOP_TYPE_IPV6_IFNAME)
@@ -763,6 +765,9 @@
       rib->nexthop_active_num += nexthop_active_check (rn, rib, nexthop, set);
       if (active != CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
        SET_FLAG (rib->flags, ZEBRA_FLAG_CHANGED);
+
+      if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_MPLS_CHANGED))
+       SET_FLAG (rib->flags, ZEBRA_FLAG_CHANGED);
     }
   return rib->nexthop_active_num;
 }
@@ -840,7 +845,9 @@
 {
   if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELECTED))
     {
-      redistribute_delete (&rn->p, rib);
+      if (!CHECK_FLAG (rib->flags, ZEBRA_FLAG_MPLS_CHANGED))
+        redistribute_delete (&rn->p, rib);
+
       if (! RIB_SYSTEM_ROUTE (rib))
        rib_uninstall_kernel (rn, rib);
       UNSET_FLAG (rib->flags, ZEBRA_FLAG_SELECTED);
@@ -887,7 +894,9 @@
     {
       if (CHECK_FLAG (select->flags, ZEBRA_FLAG_CHANGED))
        {
-         redistribute_delete (&rn->p, select);
+         if (!CHECK_FLAG (select->flags, ZEBRA_FLAG_MPLS_CHANGED))
+            redistribute_delete (&rn->p, select);
+
          if (! RIB_SYSTEM_ROUTE (select))
            rib_uninstall_kernel (rn, select);
 
@@ -896,7 +905,11 @@
   
          if (! RIB_SYSTEM_ROUTE (select))
            rib_install_kernel (rn, select);
-         redistribute_add (&rn->p, select);
+
+         if (!CHECK_FLAG (select->flags, ZEBRA_FLAG_MPLS_CHANGED))
+           redistribute_add (&rn->p, select);
+
+         UNSET_FLAG (select->flags, ZEBRA_FLAG_MPLS_CHANGED);
        }
       return;
     }
diff --exclude=CVS -uNr zebra/zebra/zebra_vty.c zebra-ldp/zebra/zebra_vty.c
--- zebra/zebra/zebra_vty.c     2003-03-14 08:45:38.000000000 -0600
+++ zebra-ldp/zebra/zebra_vty.c 2003-02-26 23:12:42.000000000 -0600
@@ -345,6 +345,10 @@
            default:
              break;
            }
+
+         if (nexthop->mplsindex)
+           vty_out (vty, " MPLS 0x%x", nexthop->mplsindex);
+
          if (! CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
            vty_out (vty, " inactive");
 
@@ -356,16 +360,21 @@
                {
                case NEXTHOP_TYPE_IPV4:
                case NEXTHOP_TYPE_IPV4_IFINDEX:
-                 vty_out (vty, " via %s)", inet_ntoa (nexthop->rgate.ipv4));
+                 vty_out (vty, " via %s", inet_ntoa (nexthop->rgate.ipv4));
                  break;
                case NEXTHOP_TYPE_IFINDEX:
                case NEXTHOP_TYPE_IFNAME:
-                 vty_out (vty, " is directly connected, %s)",
+                 vty_out (vty, " is directly connected, %s",
                           ifindex2ifname (nexthop->rifindex));
                  break;
                default:
                  break;
                }
+
+             if (nexthop->rmplsindex)
+               vty_out (vty, " MPLS 0x%x", nexthop->rmplsindex);
+
+             vty_out (vty, ")");
            }
          vty_out (vty, "%s", VTY_NEWLINE);
        }
@@ -427,6 +436,10 @@
        default:
          break;
        }
+
+      if (nexthop->mplsindex)
+       vty_out (vty, " MPLS 0x%x", nexthop->mplsindex);
+
       if (! CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
        vty_out (vty, " inactive");
 
@@ -438,16 +451,21 @@
            {
            case NEXTHOP_TYPE_IPV4:
            case NEXTHOP_TYPE_IPV4_IFINDEX:
-             vty_out (vty, " via %s)", inet_ntoa (nexthop->rgate.ipv4));
+             vty_out (vty, " via %s", inet_ntoa (nexthop->rgate.ipv4));
              break;
            case NEXTHOP_TYPE_IFINDEX:
            case NEXTHOP_TYPE_IFNAME:
-             vty_out (vty, " is directly connected, %s)",
+             vty_out (vty, " is directly connected, %s",
                       ifindex2ifname (nexthop->rifindex));
              break;
            default:
              break;
            }
+
+         if (nexthop->rmplsindex)
+           vty_out (vty, " MPLS 0x%x", nexthop->rmplsindex);
+
+         vty_out (vty, ")");
        }
 
       if (rib->type == ZEBRA_ROUTE_RIP
@@ -1072,6 +1090,10 @@
            default:
              break;
            }
+
+         if (nexthop->mplsindex)
+           vty_out (vty, " MPLS 0x%x", nexthop->mplsindex);
+
          if (! CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
            vty_out (vty, " inactive");
 
@@ -1084,7 +1106,7 @@
                case NEXTHOP_TYPE_IPV6:
                case NEXTHOP_TYPE_IPV6_IFINDEX:
                case NEXTHOP_TYPE_IPV6_IFNAME:
-                 vty_out (vty, " via %s)",
+                 vty_out (vty, " via %s",
                           inet_ntop (AF_INET6, &nexthop->rgate.ipv6,
                                      buf, BUFSIZ));
                  if (nexthop->rifindex)
@@ -1092,12 +1114,17 @@
                  break;
                case NEXTHOP_TYPE_IFINDEX:
                case NEXTHOP_TYPE_IFNAME:
-                 vty_out (vty, " is directly connected, %s)",
+                 vty_out (vty, " is directly connected, %s",
                           ifindex2ifname (nexthop->rifindex));
                  break;
                default:
                  break;
                }
+
+             if (nexthop->rmplsindex)
+               vty_out (vty, " MPLS 0x%x", nexthop->rmplsindex);
+
+             vty_out (vty, ")");
            }
          vty_out (vty, "%s", VTY_NEWLINE);
        }
diff --exclude=CVS -uNr zebra/zebra/zserv.c zebra-ldp/zebra/zserv.c
--- zebra/zebra/zserv.c 2003-03-14 08:45:39.000000000 -0600
+++ zebra-ldp/zebra/zserv.c     2003-03-13 21:54:55.000000000 -0600
@@ -35,6 +35,7 @@
 #include "zclient.h"
 
 #include "zebra/zserv.h"
+#include "zebra/router-id.h"
 #include "zebra/redistribute.h"
 #include "zebra/debug.h"
 #include "zebra/ipforward.h"
@@ -73,7 +74,11 @@
   "ZEBRA_IPV4_NEXTHOP_LOOKUP",
   "ZEBRA_IPV6_NEXTHOP_LOOKUP",
   "ZEBRA_IPV4_IMPORT_LOOKUP",
-  "ZEBRA_IPV6_IMPORT_LOOKUP"
+  "ZEBRA_IPV6_IMPORT_LOOKUP",
+  "ZEBRA_ROUTER_ID_ADD",
+  "ZEBRA_ROUTER_ID_DELETE",
+  "ZEBRA_ROUTER_ID_UPDATE",
+  "ZEBRA_IPV4_SET_MPLSINDEX"
 };
 \f
 struct zebra_message_queue
@@ -983,6 +988,38 @@
   return 0;
 }
 \f
+/* Router-id is updated. Send ZEBRA_ROUTER_ID_ADD to client. */
+int
+zsend_router_id_update (struct zserv *client, struct prefix *p)
+{
+  struct stream *s;
+  int blen;
+
+  /* Check this client need interface information. */
+  if (!client->ridinfo)
+    return -1;
+
+  s = client->obuf;
+  stream_reset (s);
+
+  /* Place holder for size. */
+  stream_putw (s, 0);
+
+  /* Message type. */
+  stream_putc (s, ZEBRA_ROUTER_ID_UPDATE);
+
+  /* Prefix information. */
+  stream_putc (s, p->family);
+  blen = prefix_blen (p);
+  stream_put (s, &p->u.prefix, blen);
+  stream_putc (s, p->prefixlen);
+
+  /* Write packet size. */
+  stream_putw_at (s, 0, stream_get_endp (s));
+
+  return writen (client->sock, s->data, stream_get_endp (s));
+}
+\f
 /* Register zebra server interface information.  Send current all
    interface and address information. */
 void
@@ -1022,6 +1059,71 @@
   client->ifinfo = 0;
 }
 
+void
+zread_ipv4_set_mplsindex (struct zserv *client, u_short length)
+{
+  struct prefix_ipv4 p;
+  struct in_addr gate;
+  struct stream *s;
+  unsigned int mplsindex;
+  unsigned int ifindex;
+  struct route_node *rn;
+  struct rib *rib;
+  struct nexthop *nexthop;
+  struct route_table *table;
+
+  /* Get input stream.  */
+  s = client->ibuf;
+
+  /* IPv4 prefix. */
+  memset (&p, 0, sizeof (struct prefix_ipv4));
+  p.family = AF_INET;
+  p.prefixlen = stream_getc (s);
+  stream_get (&p.prefix, s, PSIZE (p.prefixlen));
+
+  /* Nexthop info */
+  gate.s_addr = stream_get_ipv4 (s);
+  ifindex = stream_getl (s);
+
+  /* the MPLS index */
+  mplsindex = stream_getl (s);
+
+  apply_mask_ipv4 (&p);
+
+  /* Lookup table.  */
+  table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
+  if (! table)
+    return;
+
+  rn = route_node_get (table, (struct prefix *)&p);
+  if (!rn)
+    return;
+    
+  for (rib = rn->info; rib; rib = rib->next)
+    {
+      if (!CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELECTED))
+       {
+         continue;
+       }
+
+      for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
+       {
+         if (!CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
+           {
+             continue;
+           }
+         if (nexthop->ifindex == ifindex
+             && nexthop->gate.ipv4.s_addr == gate.s_addr)
+           {
+             SET_FLAG (rib->flags, ZEBRA_FLAG_MPLS_CHANGED);
+             nexthop->mplsindex = mplsindex;
+           }
+       }
+
+    }
+  rib_process (rn, NULL);
+}
+
 /* This function support multiple nexthop. */
 void
 zread_ipv4_add (struct zserv *client, u_short length)
@@ -1113,7 +1215,7 @@
   u_char nexthop_num;
   u_char nexthop_type;
   u_char ifname_len;
-  
+
   s = client->ibuf;
   ifindex = 0;
   nexthop.s_addr = 0;
@@ -1207,7 +1309,7 @@
   struct in6_addr nexthop;
   unsigned long ifindex;
   struct prefix_ipv6 p;
-  
+
   s = client->ibuf;
   ifindex = 0;
   memset (&nexthop, 0, sizeof (struct in6_addr));
@@ -1271,7 +1373,7 @@
   struct in6_addr nexthop;
   unsigned long ifindex;
   struct prefix_ipv6 p;
-  
+
   s = client->ibuf;
   ifindex = 0;
   memset (&nexthop, 0, sizeof (struct in6_addr));
@@ -1379,6 +1481,27 @@
 }
 #endif /* HAVE_IPV6 */
 
+/* Register zebra server router-id information.  Send current router-id */
+void
+zread_router_id_add (struct zserv *client, u_short length)
+{
+  struct prefix p;
+
+  /* Router-id information is needed. */
+  client->ridinfo = 1;
+
+  router_id_get (&p);
+
+  zsend_router_id_update (client,&p);
+}
+
+/* Unregister zebra server router-id information. */
+void
+zread_router_id_delete (struct zserv *client, u_short length)
+{
+  client->ridinfo = 0;
+}
+
 /* Close zebra client. */
 void
 zebra_client_close (struct zserv *client)
@@ -1490,6 +1613,15 @@
 
   switch (command) 
     {
+    case ZEBRA_IPV4_SET_MPLSINDEX:
+      zread_ipv4_set_mplsindex (client, length);
+      break;
+    case ZEBRA_ROUTER_ID_ADD:
+      zread_router_id_add (client, length);
+      break;
+    case ZEBRA_ROUTER_ID_DELETE:
+      zread_router_id_delete (client, length);
+      break;
     case ZEBRA_INTERFACE_ADD:
       zread_interface_add (client, length);
       break;
diff --exclude=CVS -uNr zebra/zebra/zserv.h zebra-ldp/zebra/zserv.h
--- zebra/zebra/zserv.h 2003-03-14 08:45:39.000000000 -0600
+++ zebra-ldp/zebra/zserv.h     2003-02-26 15:49:12.000000000 -0600
@@ -56,6 +56,9 @@
 
   /* Interface information. */
   u_char ifinfo;
+
+  /* Router-id information. */
+  u_char ridinfo;
 };
 
 /* Count prefix size from mask length */
@@ -126,6 +129,9 @@
 
 #endif /* HAVE_IPV6 */
 
+int
+zsend_router_id_update(struct zserv *, struct prefix *);
+
 extern pid_t pid;
 extern pid_t old_pid;