/*
 *  Copyright (C) James R. Leu 2000
 *  jleu@mindspring.com
 *
 *  This software is covered under the LGPL, for more
 *  info check out http://www.gnu.org/copyleft/lgpl.html
 */

#ifndef _LDP_STRUCT_H_
#define _LDP_STRUCT_H_

#ifdef __LDP_LINUX__
#include "ldp_list.h"
#include "ldp_refcnt.h"
#else
#include <ldp/ldp_list.h>
#include <ldp/ldp_refcnt.h>
#endif

LDP_LIST_ROOT(ldp_session_elem_list,ldp_session_elem);
LDP_LIST_ROOT(ldp_inlabel_elem_list,ldp_inlabel_elem);
LDP_LIST_ROOT(ldp_attr_elem_list,ldp_attr_elem);
LDP_LIST_ROOT(ldp_addr_elem_list,ldp_addr_elem);
LDP_LIST_ROOT(ldp_outlabel_list,ldp_outlabel);
LDP_LIST_ROOT(ldp_inlabel_list,ldp_inlabel);
LDP_LIST_ROOT(ldp_session_list,ldp_session);
LDP_LIST_ROOT(ldp_entity_list,ldp_entity);
/* LDP_LIST_ROOT(ldp_socket_list,ldp_socket); */
LDP_LIST_ROOT(ldp_range_list,ldp_range);
LDP_LIST_ROOT(ldp_addr_list,ldp_addr);
LDP_LIST_ROOT(ldp_attr_list,ldp_attr);
LDP_LIST_ROOT(ldp_peer_list,ldp_peer);
LDP_LIST_ROOT(ldp_adj_list,ldp_adj);
LDP_LIST_ROOT(ldp_msg_list,ldp_msg);
LDP_LIST_ROOT(ldp_fec_list,ldp_fec);
LDP_LIST_ROOT(ldp_fs_list,ldp_fs);
LDP_LIST_ROOT(ldp_if_list,ldp_if);

typedef struct ldp_attr_list ldp_attr_list;

typedef enum {
  LDP_SUCCESS = 1,
  LDP_FAILURE,
  LDP_NON_BLOCKING,
  LDP_END_OF_LIST,
  LDP_NO_ROUTE
} ldp_return_enum;

typedef enum {
  LDP_ADD,
  LDP_DEL,
  LDP_MODIFY
} ldp_update_enum;

typedef enum {
  LDP_UP = 1,
  LDP_DOWN,
} ldp_oper_state_enum;

typedef enum {
  LDP_UNKNOWN = 0,
  LDP_DIRECT,
  LDP_INDIRECT,
} ldp_entity_type_enum;

typedef enum {
  LDP_ONESHOT = 1,
  LDP_REOCCURRING,
} ldp_timer_type_enum;

typedef enum {
  LDP_MICRO = 1,
  LDP_SEC,
  LDP_MIN,
  LDP_HOUR
} ldp_time_unit_enum;

typedef enum {
  LDP_CONTROL_INDEPENDENT = 1,
  LDP_CONTROL_ORDERED
} ldp_control_mode;

typedef enum {
  LDP_RETENTION_LIBERAL = 1,
  LDP_RETENTION_CONSERVATIVE
} ldp_retention_mode;

typedef enum {
  LDP_REPAIR_LOCAL = 1,
  LDP_REPAIR_GLOBAL
} ldp_repaire_mode;

typedef enum {
  LDP_ENABLE = 1,
  LDP_DISABLE
} ldp_admin_state_enum;

typedef enum {
  LDP_LOOP_NONE = 0,
  LDP_LOOP_HOPCOUNT,
  LDP_LOOP_PATHVECTOR,
  LDP_LOOP_HOPCOUNT_PATHVECTOR,
  LDP_LOOP_OTHER,
} ldp_loop_detection_mode;

typedef enum {
  LDP_TRANS_ADDR_NONE = 0,
  LDP_TRANS_ADDR_INTERFACE,
  LDP_TRANS_ADDR_LSRID
} ldp_trans_addr_mode;

typedef enum {
  LDP_DISTRIBUTION_UNSOLICITED = 0,
  LDP_DISTRIBUTION_ONDEMAND = 1,
} ldp_distribution_mode;

typedef enum {
  LDP_INFINIT = 0,
} ldp_count;

typedef enum {
  LDP_PASSIVE = 1,
  LDP_ACTIVE
} ldp_role_enum;

typedef enum {
  LDP_GENERIC = 1,
  LDP_ATM_VP,
  LDP_ATM_VC,
  LDP_ATM_VP_VC,
  LDP_FR_10,
  LDP_FR_24
} ldp_label_range_type;

typedef enum {
  LDP_LABEL_NONE,
  LDP_LABEL_GEN,
  LDP_LABEL_ATM,
  LDP_LABEL_FR
} ldp_label_type;

typedef enum {
  LDP_FALSE = 0,
  LDP_TRUE = 1
} ldp_bool;

typedef enum {
  LDP_UDP_DATA = 1,
  LDP_TCP_LISTEN,
  LDP_TCP_CONNECT,
  LDP_TCP_DATA,
} ldp_socket_enum;

typedef enum {
  LDP_SOCKET_NONBLOCK = 0x1,
  LDP_SOCKET_REUSE = 0x2,
} ldp_socket_option_type;

typedef enum {
  LDP_EVENT_HELLO = 0,
  LDP_EVENT_CONNECT,
  LDP_EVENT_INIT,
  LDP_EVENT_KEEP,
  LDP_EVENT_ADDR,
  LDP_EVENT_LABEL,
  LDP_EVENT_NOTIF,
  LDP_EVENT_CLOSE,
  LDP_EVENT_HTIMER,
  LDP_EVENT_KTIMER,
  LDP_EVENT_TCP_LISTEN,
  LDP_EVENT_TCP_CONNECT,
  LDP_EVENT_UDP_DATA,
  LDP_EVENT_TCP_DATA,
} ldp_event_enum;

typedef enum {
  LDP_STATE_NONE = 0,
  LDP_STATE_NON_EXIST,
  LDP_STATE_INITIALIZED,
  LDP_STATE_OPENSENT,
  LDP_STATE_OPENREC,
  LDP_STATE_OPERATIONAL
} ldp_state_enum;

typedef enum {
  LDP_KEEPALIVE_RECV = 1,
  LDP_KEEPALIVE_SEND
} ldp_keepalive_type;

typedef enum {
  LDP_TRACE_STATE_SEND,
  LDP_TRACE_STATE_RECV,
  LDP_TRACE_STATE_ALL
} ldp_trace_states;

typedef enum {
  LDP_LSP_STATE_REQ_RECV,
  LDP_LSP_STATE_REQ_SENT,
  LDP_LSP_STATE_MAP_RECV,
  LDP_LSP_STATE_MAP_SENT,
  LDP_LSP_STATE_WITH_SENT,
  LDP_LSP_STATE_WITH_RECV,
  LDP_LSP_STATE_NO_LABEL_RESOURCE_SENT,
  LDP_LSP_STATE_NO_LABEL_RESOURCE_RECV,
  LDP_LSP_STATE_ABORT_SENT
} ldp_lsp_state;


typedef enum {
  LDP_TRACE_FLAG_ADDRESS =	0x00000001,
  LDP_TRACE_FLAG_BINDING =	0x00000002,
  LDP_TRACE_FLAG_DEBUG =	0x00000004,
  LDP_TRACE_FLAG_ERROR =	0x00000008,
  LDP_TRACE_FLAG_EVENT =	0x00000010,
  LDP_TRACE_FLAG_GENERAL =	0x00000020,
  LDP_TRACE_FLAG_INIT =		0x00000040,
  LDP_TRACE_FLAG_LABEL =	0x00000080,
  LDP_TRACE_FLAG_NORMAL =	0x00000100,
  LDP_TRACE_FLAG_NOTIF =	0x00000200,
  LDP_TRACE_FLAG_PACKET_DUMP =	0x00000400,
  LDP_TRACE_FLAG_PACKET =	0x00000800,
  LDP_TRACE_FLAG_PATH =		0x00001000,
  LDP_TRACE_FLAG_PERIODIC =	0x00002000,
  LDP_TRACE_FLAG_POLICY =	0x00004000,
  LDP_TRACE_FLAG_ROUTE =	0x00008000,
  LDP_TRACE_FLAG_STATE =	0x00010000,
  LDP_TRACE_FLAG_TASK =		0x00020000,
  LDP_TRACE_FLAG_TIMER =	0x00040000,
  LDP_TRACE_FLAG_ALL =		0xFFFFFFFF
} ldp_trace_flags;

typedef enum {
  LDP_FEC_HOST,
  LDP_FEC_PREFIX
} ldp_fec_type_enum;

typedef enum {
  LDP_NOTIF_NONE = 0,
  LDP_NOTIF_SUCCESS,
  LDP_NOTIF_BAD_LDP_ID,
  LDP_NOTIF_BAD_PROTO,
  LDP_NOTIF_BAD_PDU_LEN,
  LDP_NOTIF_UNKNOWN_MESG,
  LDP_NOTIF_BAD_MESG_LEN,
  LDP_NOTIF_UNKNOWN_TVL,
  LDP_NOTIF_BAD_TLV_LEN,
  LDP_NOTIF_MALFORMED_TLV,
  LPD_NOTIF_HOLD_TIMER_EXPIRED,
  LDP_NOTIF_SHUTDOWN,
  LDP_NOTIF_LOOP_DETECTED,
  LDP_NOTIF_UNKNOWN_FEC,
  LDP_NOTIF_NO_ROUTE,
  LDP_NOTIF_NO_LABEL_RESOURCES_AVAILABLE,
  LDP_NOTIF_LABEL_RESOURCES_AVAILABLE,
  LDP_NOTIF_SESSION_REJECTED_NO_HELLO,
  LDP_NOTIF_SESSION_REJECTED_PARAMETERS_ADVERTISEMENT_MODE,
  LDP_NOTIF_SESSION_REJECTED_PARAMETERS_MAX_PDU_LEN,
  LDP_NOTIF_SESSION_REJECTED_PARAMETERS_LABEL_RANGE,
  LDP_NOTIF_KEEPALIVE_TIMER_EXPIRED,
  LDP_NOTIF_LABEL_ABORT
} ldp_notif_status;

#define LDP_STATE_NUM 6
#define LDP_EVENT_NUM 10
#define LDP_FUNC_NUM 10

#include "ldp_defaults.h"
#define LDP_MAX_IF_NAME 16

#ifdef __LDP_LINUX__
#include "ldp_handle_type.h"
#else
#include <ldp/ldp_handle_type.h>
#endif

typedef struct ldp_inet_addr {
  uint16_t protocol;
  union {
    uint8_t ipv6[16];
    uint32_t ipv4;
  } u;
} ldp_inet_addr;

typedef struct ldp_dest {
  LDP_REFCNT_FIELD;
  struct ldp_inet_addr addr;
  uint16_t port;
  ldp_if_handle if_handle;
} ldp_dest;

#ifdef __LDP_LINUX__
#include "ldp_nortel.h"
#else
#include <ldp/ldp_nortel.h>
#endif

typedef struct ldp_msg {
  LDP_LIST_ELEM(ldp_msg) _pdu;
  mplsLdpHeader_t *hdr;
  mplsLdpMsg_t *body;
  uint16_t type;
} ldp_msg;

typedef struct ldp_pdu {
  struct ldp_msg_list msg;
} ldp_pdu;

typedef struct ldp_global {
  struct ldp_outlabel_list outlabel;
  struct ldp_inlabel_list inlabel;
  struct ldp_session_list session;
  struct ldp_entity_list entity;
  struct ldp_range_list range;
  struct ldp_peer_list peer;
  struct ldp_attr_list attr;
  struct ldp_adj_list adj;
  struct ldp_if_list iff;

  ldp_lock_handle global_lock;
  ldp_instance_handle user_data;

  ldp_tree_handle addr_tree;
  ldp_tree_handle fec_tree;
  ldp_tree_handle nh_tree;

  ldp_socket_handle hello_socket;
  ldp_socket_handle listen_socket;

  ldp_timer_mgr_handle timer_handle;
  ldp_socket_mgr_handle socket_handle;
  ldp_fib_handle fib_handle;
  ldp_ifmgr_handle ifmgr_handle;
  ldp_mpls_handle mpls_handle;

  /*
   * CSN changes with every MIB set, BUT only when a entity goes through
   * shutdown/startup cycle will it grab the new CSN and use it in hellos
   */
  uint32_t configuration_sequence_number;

  /*
   * Message ID increaments with EVERY message, this means it will roll over
   */
  uint32_t message_identifier;

  struct ldp_inet_addr lsr_identifier;
  ldp_bool send_address_messages;
  ldp_bool send_lsrid_mapping;
  ldp_control_mode lsp_control_mode;
  ldp_retention_mode label_retention_mode;
  ldp_repaire_mode lsp_repair_mode;
  ldp_bool propagate_release;
  ldp_bool label_merge;
  ldp_loop_detection_mode loop_detection_mode;
  ldp_bool ttl_less_domain;
  uint16_t local_tcp_port;
  uint16_t local_udp_port;
  uint16_t backoff_step;
  int no_route_to_peer_time;

  /*
   * some global defaults, entities will inherit these values unless
   * instructed otherwise
   */
  struct ldp_inet_addr transport_address;
  uint16_t keepalive_timer;
  uint16_t keepalive_interval;
  uint16_t hellotime_timer;
  uint16_t hellotime_interval;

  ldp_admin_state_enum admin_state;
} ldp_global;

typedef struct ldp_global* ldp_cfg_handle;

typedef struct ldp_entity {
  LDP_REFCNT_FIELD;
  LDP_LIST_ELEM(ldp_entity) _global;
  struct ldp_session_list session_root;
  struct ldp_adj_list adj_root;

  ldp_entity_type_enum entity_type;
  union {
    struct ldp_peer* peer;
    struct ldp_if* iff;
  } p;

  ldp_state_enum state;
  uint32_t inherit_flag;
  ldp_bool require_hop_count;
  uint32_t sub_index;
  uint32_t index;
  struct ldp_inet_addr transport_address;
  uint8_t protocol_version;
  uint16_t remote_tcp_port;
  uint16_t remote_udp_port;
  uint16_t max_pdu;
  uint16_t keepalive_timer;
  uint16_t keepalive_interval;
  uint16_t hellotime_timer;
  uint16_t hellotime_interval;
  uint16_t session_setup_count;
  uint16_t session_backoff_timer;
  ldp_distribution_mode label_distribution_mode;
  uint8_t path_vector_limit;
  uint8_t hop_count_limit;
  uint8_t label_request_count;
  uint16_t label_request_timer;
  ldp_loop_detection_mode loop_detection_mode;

  ldp_timer_handle keepalive_send_timer;
  ldp_timer_handle keepalive_recv_timer;

  ldp_admin_state_enum admin_state;
  ldp_bool remote_in_ttl_less_domain;

  /* only used for cfg gets */
  int adj_count;
} ldp_entity;

typedef struct ldp_if {
  LDP_REFCNT_FIELD;
  LDP_LIST_ELEM(ldp_if) _global;
  LDP_LIST_ELEM(ldp_if) _range;
  struct ldp_msg* hello;
  struct ldp_entity* entity;
  struct ldp_range* range;
  ldp_timer_handle hellotime_send_timer;
  int hellotime_send_timer_duration;
  int label_space;
  ldp_if_handle handle;

  uint32_t index;
  uint8_t buffer[MPLS_PDUMAXLEN];
  int buffer_size;
  struct ldp_inet_addr local_source_address;

  /* YES this is a dest, it is what we use for sendto */
  struct ldp_dest dest;

  char name[LDP_MAX_IF_NAME];
  ldp_oper_state_enum oper_state;

  /* only used for cfg gets */
  uint32_t entity_index;
} ldp_if;

typedef struct ldp_peer {
  LDP_REFCNT_FIELD;
  LDP_LIST_ELEM(ldp_peer) _global;
  LDP_LIST_ELEM(ldp_peer) _range;
  struct ldp_msg* hello;
  struct ldp_entity* entity;
  struct ldp_range* range;
  ldp_timer_handle no_route_to_peer_timer;
  ldp_timer_handle hellotime_send_timer;
  int hellotime_send_timer_duration;
  int label_space;
  uint32_t index;
  uint8_t buffer[MPLS_PDUMAXLEN];
  int buffer_size;
  struct ldp_inet_addr local_source_address;

  /* YES this is a dest, it is what we use for sendto */
  struct ldp_dest dest;
  ldp_role_enum target_role;

  char peer_name[LDP_MAX_IF_NAME];
  ldp_oper_state_enum oper_state;

  /* only used for cfg gets */
  uint32_t entity_index;
} ldp_peer;

typedef struct ldp_session {
  LDP_REFCNT_FIELD;
  LDP_LIST_ELEM(ldp_session) _global;
  LDP_LIST_ELEM(ldp_session) _entity;
  struct ldp_outlabel_list outlabel_root;
  struct ldp_inlabel_elem_list inlabel_root;
  struct ldp_addr_elem_list addr_root;
  struct ldp_attr_list attr_root;
  ldp_timer_handle initial_distribution_timer;
  ldp_timer_handle keepalive_recv_timer;
  ldp_timer_handle keepalive_send_timer;
  struct ldp_entity* entity;
  struct ldp_adj* adj;
  struct ldp_msg* keepalive;
  uint32_t index;
  ldp_state_enum state;
  ldp_socket_handle socket;

  /* these are the opertaional values, config values come from entity */
  int oper_max_pdu;
  int oper_keepalive;
  int oper_path_vector_limit;
  ldp_distribution_mode oper_distribution_mode;
  ldp_loop_detection_mode oper_loop_detection;
  
  /* these values are learned form the remote peer */
  int remote_max_pdu;
  int remote_keepalive;
  int remote_path_vector_limit;
  ldp_distribution_mode remote_distribution_mode;
  ldp_bool remote_loop_detection;

  ldp_dest remote_dest;
  ldp_bool no_label_resource_sent;
  ldp_bool no_label_resource_recv;
  ldp_bool on_global;

  /* only used by cfg gets */
  uint32_t entity_index;
  uint32_t adj_index;
} ldp_session;

typedef struct ldp_session_elem {
  LDP_LIST_ELEM(ldp_session_elem) _elem;
  struct ldp_session *session;
} ldp_session_elem;

typedef struct ldp_adj {
  LDP_REFCNT_FIELD;
  LDP_LIST_ELEM(ldp_adj) _entity;
  LDP_LIST_ELEM(ldp_adj) _global;
  struct ldp_entity* entity;
  struct ldp_session* session;
  ldp_timer_handle hellotime_recv_timer;
  uint32_t index;

  /* these are operational values */
  /* the transport address is stored in the iff or peer */
  /* the holdtimer is stored in the iff or peer */
  /* the conf. sequ. number is stored in the iff or peer */

  /* these values are learned form the remote peer */
  struct ldp_inet_addr remote_transport_address;
  struct ldp_inet_addr remote_source_address;
  struct ldp_inet_addr remote_lsr_address;
  uint32_t remote_csn;
  int remote_label_space;
  int remote_hellotime;

  ldp_timer_handle backoff_timer;
  int backoff;
  ldp_role_enum role;

  /* only used by cfg gets */
  uint32_t session_index;
  uint32_t entity_index;
} ldp_adj;

typedef struct ldp_addr {
  LDP_REFCNT_FIELD;
  LDP_LIST_ELEM(ldp_addr) _addr;
  struct ldp_session_elem_list session_root;
  struct ldp_fec_list fec_root;
  struct ldp_inet_addr address;
  uint32_t index;
} ldp_addr;

typedef struct ldp_addr_elem {
  LDP_LIST_ELEM(ldp_addr_elem) _elem;
  struct ldp_addr* addr;
} ldp_addr_elem;

typedef struct ldp_attr_elem {
  LDP_LIST_ELEM(ldp_attr_elem) _elem;
  struct ldp_attr* attr;
} ldp_attr_elem;

typedef struct ldp_label {
  ldp_label_type type;
  union {
    int gen;
    struct {
      int vpi;
      int vci;
    } atm;
    struct {
      int len;
      int dlci;
    } fr;
  } u;
} ldp_label;

typedef struct ldp_outlabel {
  LDP_REFCNT_FIELD;
  struct ldp_inlabel_list inlabel_root;
  LDP_LIST_ELEM(ldp_outlabel) _global;
  LDP_LIST_ELEM(ldp_outlabel) _session;
  struct ldp_attr* attr;
  uint32_t merge_count;
  uint32_t index;
  struct ldp_session* session;
  struct ldp_label l;
  struct ldp_addr* next_hop;

  /* only used by get() */
  uint32_t session_index;
  uint32_t addr_index;
} ldp_outlabel;

typedef struct ldp_inlabel {
  LDP_REFCNT_FIELD;
  LDP_LIST_ELEM(ldp_inlabel) _global;
  LDP_LIST_ELEM(ldp_inlabel) _outlabel;
  struct ldp_session_elem_list session_root;
  struct ldp_attr_elem_list attr_root;
  struct ldp_outlabel *outlabel;
  uint32_t reuse_count;
  int label_space;
  uint32_t index;
  struct ldp_label l;

  /* only used by get() */
  uint32_t outlabel_index;
} ldp_inlabel;

typedef struct ldp_inlabel_elem {
  LDP_LIST_ELEM(ldp_inlabel_elem) _elem;
  struct ldp_inlabel *inlabel;
} ldp_inlabel_elem;

typedef struct ldp_range {
  LDP_REFCNT_FIELD;
  LDP_LIST_ELEM(ldp_range) _global;
  struct ldp_peer_list peer_root;
  struct ldp_if_list if_root;
  int label_space;
  ldp_label_range_type type;
  union {
    struct {
      uint16_t vpi;
      uint16_t vci;
    } atm;
    uint32_t gen;
    uint32_t fr;
  } max,min;
} ldp_range;

typedef struct ldp_prefix {
  struct ldp_inet_addr next_hop;
  struct ldp_inet_addr network;
  ldp_if_handle out_if_handle;
  int prefix_len;
  uint32_t index;
} ldp_prefix;

typedef struct ldp_fec {
  LDP_REFCNT_FIELD;
  LDP_LIST_ELEM(ldp_fec) _global;
  LDP_LIST_ELEM(ldp_fec) _inlabel;
  LDP_LIST_ELEM(ldp_fec) _outlabel;
  LDP_LIST_ELEM(ldp_fec) _tree;
  LDP_LIST_ELEM(ldp_fec) _addr;
  LDP_LIST_ELEM(ldp_fec) _fec;
  LDP_LIST_ELEM(ldp_fec) _nh;
  struct ldp_fs_list fs_root_us;
  struct ldp_fs_list fs_root_ds;
  struct ldp_inet_addr prefix;
  int prefix_len;
  ldp_fec_type_enum type;
} ldp_fec;

typedef struct ldp_tree_node {
  struct ldp_addr_list addr_root;
  struct ldp_fec_list fec_root;
  struct ldp_fec_list nh_root;
} ldp_tree_node;

typedef struct ldp_fs {
  struct ldp_attr_list attr_root;
  LDP_LIST_ELEM(ldp_fs) _fec;
  struct ldp_session* session;
} ldp_fs;

typedef struct ldp_attr {
  LDP_REFCNT_FIELD;
  uint32_t index;
  uint32_t msg_id;
  ldp_lsp_state state;
  ldp_bool installed;
  ldp_bool filtered;
  ldp_bool in_tree;
  struct ldp_session* session;

  LDP_LIST_ELEM(ldp_attr) _session;
  LDP_LIST_ELEM(ldp_attr) _global;
  LDP_LIST_ELEM(ldp_attr) _fs;

  mplsLdpFecTlv_t fecTlv;
  mplsLdpGenLblTlv_t genLblTlv;
  mplsLdpAtmLblTlv_t atmLblTlv;
  mplsLdpFrLblTlv_t frLblTlv;
  mplsLdpHopTlv_t hopCountTlv;
  mplsLdpPathTlv_t pathVecTlv;
  mplsLdpLblMsgIdTlv_t lblMsgIdTlv;
  mplsLdpLspIdTlv_t lspidTlv;
  mplsLdpTrafficTlv_t trafficTlv;

  uint8_t fecTlvExists:1;
  uint8_t genLblTlvExists:1;
  uint8_t atmLblTlvExists:1;
  uint8_t frLblTlvExists:1;
  uint8_t hopCountTlvExists:1;
  uint8_t pathVecTlvExists:1;
  uint8_t lblMsgIdTlvExists:1;
  uint8_t lspidTlvExists:1;
  uint8_t trafficTlvExists:1;

  struct ldp_inlabel* inlabel;
  struct ldp_outlabel* outlabel;

  /* only used for get() */
  uint32_t inlabel_index;
  uint32_t outlabel_index;
  uint32_t session_index;
} ldp_attr;

typedef void (*ldp_fib_callback)(ldp_cfg_handle cfg,ldp_update_enum type,
          ldp_prefix* dest);
typedef void (*ldp_ifmgr_callback)(ldp_cfg_handle cfg,ldp_update_enum type,
          const char* ifname);

#endif