openapi_routing.h

Go to the documentation of this file.

/*********************************************************************
*
* Copyright 2016-2022 Broadcom.
*
*  Licensed under the Apache License, Version 2.0 (the "License");
*  you may not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
**********************************************************************
*
* @filename  openapi_routing.h
*
* @purpose   Routing Protocol Process Interface 
*
* @component OPEN
*
* @create    07/10/2012
*
* @end
*
**********************************************************************/
#ifndef OPENAPI_ROUTING_H_INCLUDED
#define OPENAPI_ROUTING_H_INCLUDED

#include <stdio.h>
#include <stddef.h>
#include <sys/un.h>

#include "openapi_common.h"
#include "openapi_mpls.h"

/* Event registration variables */
#define OPEN_RPPI_CLIENT_NAME_MAX_LEN (32)

#define RPPI_BRC_ADDR          "/tmp/rppi_brc.%04u"   

#define ROUTER_EVENT_CLIENT_ADDR         "/tmp/rppi_rec.%04u"

/* UNIX "address" on client side for policy change notifications */
#define RPPI_POLICY_CLIENT_ADDR          "/tmp/rppi_pc.%04u"   

/* The maximum length of an RPPI event message, in bytes. */
#define RPPI_MSG_SIZE_MAX   256

/* The maximum length of the name of a best route client */
#define OPENR_BRC_NAME_LEN  16

/* The maximum length of the name of a routing policy client */
#define OPENR_POLICY_CLIENT_NAME_LEN 16

#define OPENR_RTR_GBL_MSG_LEN (sizeof(openrRouterEventMsg_t))
#define OPENR_RTR_INTF_MSG_LEN (sizeof(openrRouterEventMsg_t))

/* The maximum length of the name of a routing protocol */
#define OPENR_ROUTING_PROTOCOL_NAME_LEN  10

/* The maximum number of route changes that we can fetch in one call */
#define OPENR_NUM_BEST_ROUTES_PER_GET  50
/* 
*  Use the maximum here no matter how many next hops a route has. This
*  way we can pre-allocate buffers for route gets making them faster.
* The number of next hops are indicated in a field in the routes
*/  
#define OPENR_PLAT_MAX_ECMP_NEXTHOPS 48

/* Number of routes queried to get the policy results */
#define OPENR_NUM_ROUTES_CHECK_POLICY_ACTION 50

typedef enum
{
  OPEN_INTF_IP_ADDR_METHOD_NONE       = 0, 
  OPEN_INTF_IP_ADDR_METHOD_CONFIG     = 1, 
  OPEN_INTF_IP_ADDR_METHOD_DHCP       = 2  
} OPEN_INTF_IP_ADDR_METHOD_t;

typedef enum
{
  OPEN_ADD_ROUTE        = 0,
  OPEN_DELETE_ROUTE     = 1,
  OPEN_CHANGE_ROUTE     = 2

} OPEN_ROUTE_EVENT_t;

typedef enum
{
  OPEN_POLICY_ROUTE_MAP         = 1, /* (1 << 0) */
  OPEN_POLICY_PREFIX_LIST       = 2, /* (1 << 1) */
  OPEN_POLICY_AS_PATH_LIST      = 4, /* (1 << 2) */
  OPEN_POLICY_ACL_ROUTE_FILTER  = 8  /* (1 << 3) */

} OPEN_ROUTING_POLICY_TYPE_t;

typedef enum
{
  OPEN_POLICY_CHANGE = 1, 
  OPEN_POLICY_DELETE = 2  
} OPEN_ROUTING_POLICY_CHANGE_t;

typedef enum
{
  OPENR_KEEPALIVE                 = 1,

  /* Best route change service messages */
  OPENR_BEST_ROUTE_CHANGE         = 10,

  /* router event message types */
  OPENR_RTR_ENABLE                = 101,
  OPENR_RTR_DISABLE               = 102,
  OPENR_RTR_STARTUP_DONE          = 103,
  OPENR_RTR_INTF_CREATE           = 104,
  OPENR_RTR_INTF_DELETE           = 105,
  OPENR_RTR_INTF_ENABLE           = 106,
  OPENR_RTR_INTF_ENABLE_PENDING   = 107,
  OPENR_RTR_INTF_DISABLE          = 108,
  OPENR_RTR_INTF_DISABLE_PENDING  = 109,
  OPENR_RTR_INTF_ADDR_CHANGE      = 110,
  OPENR_RTR_INTF_MTU              = 111,
  OPENR_RTR_INTF_BW_CHANGE        = 112,
  OPENR_RTR_INTF_HOST_MODE        = 113,
  OPENR_RTR_INTF_CFG_CHANGE       = 114,
  OPENR_RTR_VRF_CREATE            = 115,
  OPENR_RTR_VRF_DELETE            = 116,

  OPENR_RTR6_ENABLE                = 201,
  OPENR_RTR6_DISABLE               = 202,
  OPENR_RTR6_STARTUP_DONE          = 203,
  OPENR_RTR6_INTF_CREATE           = 204,
  OPENR_RTR6_INTF_DELETE           = 205,
  OPENR_RTR6_INTF_ENABLE           = 206,
  OPENR_RTR6_INTF_DISABLE          = 207,
  OPENR_RTR6_INTF_ADDR_CHANGE      = 208,
  OPENR_RTR6_INTF_MTU              = 209,
  OPENR_RTR6_INTF_BW_CHANGE        = 210,
  OPENR_RTR6_INTF_HOST_MODE        = 211,

  OPENR_POLICY_CHANGE              = 300

} OPENR_MESSAGE_TYPE_t;

/* NSF applications that may send IPv4 routes to RTO. Values are powers
 * of two used to index nsfRoutesPending. RIP and BGP don't support NSF
 * now but adding values for them anyway. */
typedef enum
{
  OPEN_NSF_PROTOCOL_OSPF = 0x1,
  OPEN_NSF_PROTOCOL_RIP  = 0x2,
  OPEN_NSF_PROTOCOL_BGP  = 0x4,
  OPEN_NSF_PROTOCOL_LAST = 0x8
} OPEN_NSF_PROTOCOL_t;

typedef enum
{
  OPEN_FILTER_ACTION_PERMIT = 0,
  OPEN_FILTER_ACTION_DENY = 1
} OPEN_FILTER_ACTION_t;

typedef struct openrBestRouteChangeMsg_s
{
  uint16_t msgType;

  uint16_t msgLen;

  uint32_t clientId;

  uint32_t vrfId;

} openrBestRouteChangeMsg_t;

typedef struct openrRouterEventMsg_s
{
  /* One of OPENR_MESSAGE_TYPE_t */
  uint16_t msgType;

  /* Number of bytes in payload. Includes the Message Type and Message Length fields. */
  uint16_t msgLen;

  uint32_t eventSeqNumber;

  /* For events associated with an interface, this field contains the interface identifier.
  ** Only sent if needed.
  */
  uint32_t ifNum;

  /* VRF Identifier */
  uint32_t vrfId;

  /* Start of the Event specific data memory, which is allocated  based on msgType value. */
  uint8_t  data[0]; 

} openrRouterEventMsg_t;

typedef struct openrPolicyChangeMsg_s
{
  /* One of OPENR_MESSAGE_TYPE_t */
  uint16_t msgType;

  /* Number of bytes in payload. Includes the Message Type and Message Length fields. */
  uint16_t msgLen;

  /* Change sequence number */
  uint32_t seqNo;

  /* The type of routing policy that changed. One of OPEN_ROUTING_POLICY_TYPE_t */
  uint32_t policyType;

  /* The type of change. One of OPEN_ROUTING_POLICY_CHANGE_t. */
  uint32_t changeType;

  /* Name or number of changed policy follows the changeType. */

} openrPolicyChangeMsg_t;

typedef struct openNextHop_s 
{
  open_inet_addr_t  nhAddr;      

  uint32_t  ifNum;    

  uint32_t label[OPEN_MAX_MPLS_IMPOSE_LABELS];

} openNextHop_t;


typedef struct openRoute_s
{
  open_inet_addr_t      destPfx;
  uint8_t              pfxLen;

  uint8_t         routeType;   

  uint32_t        protoId;

  uint32_t        vrfId;

  uint8_t         rejectRoute;   

  uint8_t         discardRoute;   

  uint8_t         pref;

  uint32_t        metric;        

  uint32_t        numNextHops;

  uint8_t        leakedRoute;

  /* Flag to indicate if this is an RFC 5549 route */
  uint8_t        rfc5549Route;

  /* Flag to indicate if this route is unnumbered. */
  uint8_t        unnumberedRoute;

  /* Flag to indicate if this route is MPLS. */
  uint8_t        mplsRoute;

  /* Flag to indicate if this route is Syncdb entry. */
  uint8_t        syncdbRoute;
} openRoute_t;

/*
 * This structure defines a route change event. It contains the best route data,
 * the operation being performed and the set of next hops. It also contains a flag
 * that indicates whether more route changes are pending based on which a 
 * subsequent call can be made
 */
typedef struct openRouteChange_s
{
  /* The route itself */
  openRoute_t route;

  /* operation being performed, change type */
  uint8_t chType;

  /* The set of next hops, will assume the maximum value of all supported platforms here */ 
  openNextHop_t   nextHops[OPENR_PLAT_MAX_ECMP_NEXTHOPS];

  /* Is it valid, needed because an ip and mask of 0 are valid and cannot be checked against */
  uint8_t valid;

} openRouteChange_t;

/* Needed by openapi to be a structure as arrays cannot be handled over RPC */
typedef struct openRouteChangeList_s
{
  openRouteChange_t routeChange[OPENR_NUM_BEST_ROUTES_PER_GET];
} openRouteChangeList_t;

/* Bit mask to indicate which match or set terms
 * are set in a route-map statement. Note that not all of these are supported. */
typedef enum 
{
  OPENR_RMAP_MATCH_AS_PATH               = 0x1,
  OPENR_RMAP_MATCH_COMMUNITY_LIST        = 0x2,
  OPENR_RMAP_MATCH_INTERFACE             = 0x4,
  OPENR_RMAP_MATCH_IP_ADDRESS            = 0x8,
  OPENR_RMAP_MATCH_IP_NEXT_HOP           = 0x10,
  OPENR_RMAP_MATCH_IP_ROUTE_SOURCE       = 0x20,
  OPENR_RMAP_MATCH_LENGTH                = 0x40,
  OPENR_RMAP_MATCH_METRIC                = 0x80,
  OPENR_RMAP_MATCH_METRIC_TYPE           = 0x100,
  OPENR_RMAP_MATCH_TAG                   = 0x200,
#ifdef L7_QOS_PACKAGE
  OPENR_RMAP_MATCH_MAC_ACL               = 0x400, 
#endif /* L7_QOS_PACKAGE */
  OPENR_RMAP_MATCH_EXTCOMMUNITY_LIST     = 0x800,
  OPENR_RMAP_MATCH_IPV6_ADDRESS          = 0x1000,

  OPENR_RMAP_SET_AS_PATH                 = 0x1,
  OPENR_RMAP_SET_AUTOMATIC_TAG           = 0x2,
  OPENR_RMAP_SET_COMMUNITY               = 0x4,
  OPENR_RMAP_SET_COMM_LIST_DELETE        = 0x8,
  OPENR_RMAP_SET_DEFAULT_INTF            = 0x10,
  OPENR_RMAP_SET_INTF                    = 0x20,
  OPENR_RMAP_SET_IP_DEFAULT_NEXT_HOP     = 0x40,
  OPENR_RMAP_SET_IPV6_NEXT_HOP           = 0x80,
  OPENR_RMAP_SET_LEVEL                   = 0x100,
  OPENR_RMAP_SET_LOCAL_PREF              = 0x200,
  OPENR_RMAP_SET_METRIC                  = 0x400,
  OPENR_RMAP_SET_METRIC_TYPE             = 0x800,
  OPENR_RMAP_SET_NEXT_HOP                = 0x1000,
  OPENR_RMAP_SET_TAG                     = 0x2000,
  OPENR_RMAP_SET_IP_TOS                  = 0x4000,
  OPENR_RMAP_SET_IP_PREC                 = 0x8000,
  OPENR_RMAP_SET_RT_EXTCOMMUNITY         = 0x10000,
  OPENR_RMAP_SET_SOO_EXTCOMMUNITY        = 0x20000,
  OPENR_RMAP_SET_EXTCOMM_LIST_DELETE     = 0x40000,
  OPENR_RMAP_SET_IPV6_DEFAULT_NEXT_HOP   = 0x80000,
  OPENR_RMAP_SET_IPV6_PREC               = 0x100000,
  OPENR_RMAP_SET_IP_UNCHANGED_NEXT_HOP   = 0x200000,
} OPENR_RMAP_PARAMS_MASK_t;

/* Route map match parameters. */
typedef struct openRmMatchParams_s
{
  /* Bit-map to indicate what match params are set */
  OPENR_RMAP_PARAMS_MASK_t  matchParamsMask;

  /* To match any prefix, set the prefix and prefixLen to 0. */
  open_inet_addr_t      prefix;
  uint32_t              prefixLen;

  /* To match on the metric, metric-type (ospf type-1/type-2)
   * and route tag */
  uint32_t              metric;
  uint32_t              metricType;
  uint32_t              tag;
} openRmMatchParams_t;

typedef struct openRmSetParams_s
{
  /* Bit-map to indicate what set params are set */
  OPENR_RMAP_PARAMS_MASK_t  setParamsMask;

  /* metric value, if set */
  uint32_t     metric;

  /* metric type value, if set */
  uint32_t     metricType;

  /* tag value, if set */
  uint32_t     tag;
} openRmSetParams_t;

/* Needed by openapi to get the results of the route-map policies for
 * a given set of routes with match params */
typedef struct openRoutePolicyResults_s
{
  openRoute_t          route[OPENR_NUM_ROUTES_CHECK_POLICY_ACTION];
  openRmMatchParams_t  matchParams[OPENR_NUM_ROUTES_CHECK_POLICY_ACTION];
  openRmSetParams_t    setParams[OPENR_NUM_ROUTES_CHECK_POLICY_ACTION];
} openRoutePolicyResults_t;

/* BFD Admin modes */
typedef enum
{
  OPEN_BFD_DISABLE = 0,
  OPEN_BFD_ENABLE = 1
} OPEN_BFD_ADMIN_MODE_t;

/* BFD endpoint parameters used to initiate a session */
typedef struct openBfdEndpoint_s {
  uint32_t           compId;               /* Id of component creating the session  */
  uint32_t           vrfId;                /* VRID associated with this BFD session */
  uint32_t           intIfNum;             /* Interface associated with this session */
  open_inet_addr_t   srcIpAddr;            /* Source IPv4 or Ipv6 address */
  open_inet_addr_t   dstIpAddr;            /* Destination IPv4 or Ipv6 address */
  open_inet_addr_t   nextHopIpAddr;        /* NextHop IPv4 or Ipv6 address for Destination */
  OPEN_MPLS_LABELS_t mpls_label;           /* MPLS Label Stack */
  uint32_t           type;                 /* Type of BFD encapsulation. */

  /* The BFD application can take the echo mode and BFD session timers from the
  ** interface and global config or from the session setting. In order to use the session 
  ** settings set the override_config to 1. 
  ** The timer values are in milliseconds. 
  */ 
  uint32_t           override_config;
  uint32_t           bfdMinTx; 
  uint32_t           bfdMinRx;
  uint32_t           bfdMultiplier;
  uint32_t           bfdEchoMode;
  uint32_t           bfdSlowTimer;
} openBfdEndpoint_t;


/* Maximum protocols allowed to Register with BFD */
#define OPEN_BFD_MAX_REG_PROT    2 /* BGP and OSPF */

/* BFD session information */
#define OPEN_BFD_SESSION_ID_INVALID  (~0)

/* BFD session states */
typedef enum
{
  OPEN_BFD_SESSION_STATE_ADMIN_DOWN = 0,
  OPEN_BFD_SESSION_STATE_DOWN = 1,
  OPEN_BFD_SESSION_STATE_INIT = 2,
  OPEN_BFD_SESSION_STATE_UP = 3,
} OPEN_BFD_SESSION_STATE_t;

/* BFD Diagnostic codes */
typedef enum {
  OPEN_BFD_DIAG_CODE_NONE,
  OPEN_BFD_DIAG_CODE_CTRL_DETECT_TIME_EXPIRED,
  OPEN_BFD_DIAG_CODE_ECHO_FAILED,
  OPEN_BFD_DIAG_CODE_NEIGHBOR_SIGNALED_SESSION_DOWN,
  OPEN_BFD_DIAG_CODE_FORWARDING_PLANE_RESET,
  OPEN_BFD_DIAG_CODE_PATH_DOWN,
  OPEN_BFD_DIAG_CODE_CONCATENATED_PATH_DOWN,
  OPEN_BFD_DIAG_CODE_ADMIN_DOWN,
  OPEN_BFD_DIAG_CODE_REVERSE_CONCATENATED_PATH_DOWN,
  OPEN_BFD_DIAG_CODE_MIS_CONNECTIVITY_DEFECT
} OPEN_BFD_DIAG_CODE_t;

typedef enum {
  OPEN_BFD_TUNNEL_TYPE_RAW,                /* RAW UDP */
  OPEN_BFD_TUNNEL_TYPE_UDP,                /* BFD over IPv4/v6. */
  OPEN_BFD_TUNNEL_TYPE_COUNT
} openBfdTunnelType_t;

#define SYNCDB_OPENAPI_BFD "OpEN API BFD"
#define SYNCDB_OPENAPI_BFD_VERSION 1

typedef struct openBfdSessionKey_s {
  uint32_t            intIfNum;           /* Interface associated with this session */
  uint32_t            vrfId;              /* VRID associated with this BFD session */
  open_inet_addr_t    srcIpAddr;          /* Source IPv4 or Ipv6 address */
  open_inet_addr_t    dstIpAddr;          /* Destination IPv4 or Ipv6 address */
  OPEN_MPLS_LABELS_t  mpls_label;         /* MPLS Label Stack */
} openBfdSessionKey_t;

typedef struct openBfdSessionInfo_s {
  openBfdSessionKey_t key;                
  uint32_t            session_id;         
  uint8_t               version;          
  OPEN_BFD_SESSION_STATE_t state;         
  uint8_t              flags;             
  OPEN_BFD_DIAG_CODE_t diag;              
  uint32_t            authType;           
  uint32_t            localDiscr;         
  uint32_t            remoteDiscr;        
  uint32_t            localMinTx;         
  uint32_t            localMinRx;         
  uint8_t             localDetectMult;    
  uint32_t            remoteMinTx;        
  uint32_t            remoteMinRx;        
  uint8_t             remoteDetectMult;   
  uint32_t            actualTx;           
  uint32_t            echoEnable;         
  uint32_t            actualTxEcho;       
  uint32_t            id[OPEN_BFD_MAX_REG_PROT]; 
  open_inet_addr_t    nextHopIpAddr;      
  openBfdTunnelType_t type;               
  uint32_t            upTime;             
} openBfdSessionInfo_t;

/* BFD session statistics */
typedef struct openBfdSessionStats_s {
  uint32_t inPkts;          /* BFD packets received. */
  uint32_t outPkts;         /* BFD packets transmitted. */
  uint32_t dropPkts;        /* Total BFD packets drop. */
  uint32_t echoInPkts;      /* BFD echo packets received. */
  uint32_t echoOutPkts;     /* BFD echo packets transmitted. */
} openBfdSessionStats_t;


/*****************************************************************/
open_error_t openapiRoutingProtocolRegister(openapiClientHandle_t *client_handle,
                                            uint32_t vrfId,
                                            OPEN_AF_t  addressFamily, 
                                            open_buffdesc  *protoName,
                                            open_buffdesc  *protoCode,
                                            uint32_t  *protoId);

/*****************************************************************/
open_error_t openapiRouteTypeRegister(openapiClientHandle_t *client_handle,
                                      OPEN_AF_t  addressFamily,
                                      uint32_t  protoId, 
                                      open_buffdesc  *routeTypeName,
                                      open_buffdesc  *routeTypeCode,
                                      uint32_t  *routeType);

/*****************************************************************/
open_error_t openapiRoutingProtocolDeregister(openapiClientHandle_t *client_handle,
                                              uint32_t vrfId,
                                              uint32_t addressFamily, 
                                              uint32_t protoId);

/*****************************************************************/
open_error_t openapiRouteTypeDeregister(openapiClientHandle_t *client_handle,
                                        uint32_t addressFamily, 
                                        uint32_t routeType);

/*****************************************************************/
open_error_t
openapiExternalRoutesSaveRegister (openapiClientHandle_t *client_handle,
                                   OPEN_AF_t addressFamily,
                                   uint32_t vrfId,
                                   uint32_t protoId);

/*****************************************************************/
open_error_t
openapiExternalRoutesSaveDeRegister (openapiClientHandle_t *client_handle,
                                     OPEN_AF_t addressFamily,
                                     uint32_t vrfId,
                                     uint32_t protoId);

/*****************************************************************/
open_error_t openapiRouteTypeInfoGet(openapiClientHandle_t *client_handle,
                                     uint32_t routeType,
                                     open_buffdesc *protoName,
                                     open_buffdesc *routeTypeName);

/*****************************************************************/
open_error_t openapiRouteProtoNameLenMax(openapiClientHandle_t *client_handle,
                                         uint32_t *protoNameLen);

/*****************************************************************/
open_error_t openapiRouteTypeNameLenMax(openapiClientHandle_t *client_handle,
                                        uint32_t *routeTypeNameLen);

/*****************************************************************/
open_error_t openapiRouteAdd(openapiClientHandle_t *client_handle,
                             openRoute_t *routeEntry, 
                             open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiRouteMod(openapiClientHandle_t *client_handle,
                             openRoute_t *routeEntry, 
                             open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiRouteDel(openapiClientHandle_t *client_handle,
                             openRoute_t *routeEntry);


/*****************************************************************/
open_error_t openapiBestRouteNextGet(openapiClientHandle_t *client_handle,
                                     OPEN_AF_t family, 
                                     openRoute_t *routeEntry, 
                                     open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiBestRouteNextGetVr(openapiClientHandle_t *client_handle,
                                       OPEN_AF_t family,
                                       uint32_t vrfId,
                                       openRoute_t *openRoute,
                                       open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiRouteNextGet(openapiClientHandle_t *client_handle,
                                 OPEN_AF_t family, 
                                 openRoute_t *route, 
                                 open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiBestRouteLookup(openapiClientHandle_t *client_handle,
                                    open_inet_addr_t destAddr, 
                                    openRoute_t *route, 
                                    open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiPrefixFind(openapiClientHandle_t *client_handle,
                               open_inet_addr_t destPrefix, 
                               uint32_t pfxLen, 
                               openRoute_t *route, 
                               open_buffdesc *nextHopListBuff);
/*****************************************************************/
open_error_t openapiPrefixFindVr(openapiClientHandle_t *client_handle,
                                 uint32_t vrfId,
                                 open_inet_addr_t destPrefix, 
                                 uint32_t pfxLen, 
                                 openRoute_t *route, 
                                 open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiArpResolve(openapiClientHandle_t *client_handle,
                               uint32_t vrfId,
                               open_inet_addr_t *nh_addr,
                               open_buffdesc *mac,
                               uint32_t cbParm1,
                               uint32_t cbParm2, 
                               uint32_t cbParm3);

/*****************************************************************/
open_error_t openapiBestRouteEventRegister(openapiClientHandle_t *client_handle,
                                           OPEN_AF_t family,
                                           uint32_t pid,
                                           uint32_t vrfId,
                                           open_buffdesc *clientName, 
                                           uint32_t   *clientId);

/*****************************************************************/
open_error_t openapiBestRouteEventDeregister(openapiClientHandle_t *client_handle,
                                             uint32_t clientId);

/*****************************************************************/
open_error_t openapiBestRouteChangeNextGet(openapiClientHandle_t *client_handle,
                                           uint32_t clientId, 
                                           OPEN_ROUTE_EVENT_t *chType, 
                                           openRoute_t *route, 
                                           open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiBestRouteChangeNextGetMult(openapiClientHandle_t *client_handle,
                                              uint32_t clientId, 
                                              uint32_t numChanges, 
                                              open_buffdesc *routeListBuff);

/*****************************************************************/
open_error_t openapiIntfBestRoutesNextGet(openapiClientHandle_t *client_handle,
                                          uint32_t clientId, uint32_t intIfNum, 
                                          uint32_t numChanges, 
                                          open_buffdesc *routeListBuff);

/*****************************************************************/
open_error_t openapiMaxNextHopsGet(openapiClientHandle_t *client_handle,
                                   uint32_t *maxNextHops);

/*****************************************************************/
open_error_t openapiRouterEventRegister(openapiClientHandle_t *client_handle,
                                        OPEN_AF_t family, 
                                        uint32_t pid, 
                                        uint32_t vrfId,
                                        open_buffdesc *clientName, 
                                        uint32_t *clientId);

/*****************************************************************/
open_error_t openapiRouterEventDeregister(openapiClientHandle_t *client_handle,
                                          uint32_t vrfId,
                                          uint32_t clientId);

/*****************************************************************/
open_error_t openapiRouterEventAcknowledge(openapiClientHandle_t *client_handle,
                                           uint32_t vrfId,
                                           uint32_t clientId, 
                                           uint32_t eventId);

/*****************************************************************/
open_error_t openapiMaxRoutingInterfacesGet(openapiClientHandle_t *client_handle,
                                            uint32_t *routingIntfMax);

/*****************************************************************/
open_error_t openapiRtrIntfNextGetVrf(openapiClientHandle_t *client_handle,
                                   uint32_t vrfId, 
                                   uint32_t intf, 
                                   uint32_t *nextIntf);

/*****************************************************************/
open_error_t openapiRtrIntfNextGet(openapiClientHandle_t *client_handle,
                                   uint32_t intf, 
                                   uint32_t *nextIntf);

/*****************************************************************/
open_error_t openapiRtrIntfTypeGet(openapiClientHandle_t *client_handle,
                                   uint32_t intf, 
                                   OPEN_INTF_TYPE_t *intfType);

/*****************************************************************/
open_error_t
openapiIntfIsUnnumbered (openapiClientHandle_t *client_handle,
                         uint32_t intIfNum,
                         OPEN_BOOL_t *isUnnumbered);

/*****************************************************************/
open_error_t
openapiIntfBorrowedAddrAndMaskGet (openapiClientHandle_t *client_handle,
                                   uint32_t intIfNum, uint32_t *addr,
                                   uint32_t *mask);

/*****************************************************************/
open_error_t openapiVrfNameGet(openapiClientHandle_t *client_handle,
                               uint32_t vrfId, open_buffdesc *vrfName);

/*****************************************************************/
open_error_t openapiVrfNameNextGet(openapiClientHandle_t *client_handle,
                                    open_buffdesc *vrfName,
                                    open_buffdesc *vrfNameNext);

/*****************************************************************/
open_error_t
openapiVrfNameToIdGet (openapiClientHandle_t *client_handle,
                       open_buffdesc *vrfName,
                       uint32_t *vrfId);

/*****************************************************************/
open_error_t openapiRtrIntfVlanIdGet(openapiClientHandle_t *client_handle,
                                     uint32_t intf, 
                                     uint32_t *vlanId);

/*****************************************************************/
open_error_t openapiRtrIntfLoopbackIdGet(openapiClientHandle_t *client_handle,
                                         uint32_t intf, 
                                         uint32_t *loopbackId);

/*****************************************************************/
open_error_t openapiRtrLoopbackIntIfNumGet(openapiClientHandle_t *client_handle,
                                           uint32_t loopbackId, 
                                           uint32_t *intf);

/*****************************************************************/
open_error_t openapiIntfNameSizeGet(openapiClientHandle_t *client_handle,
                                    uint32_t *ifNameSize);

/*****************************************************************/
open_error_t openapiRtrIntfNameGet(openapiClientHandle_t *client_handle,
                                   uint32_t intf, 
                                   open_buffdesc *intfName);

/*****************************************************************/
open_error_t openapiStackIfIndexIntIfNumGet(openapiClientHandle_t *client_handle,
    uint32_t ifIndex, uint32_t *intIfNum);

/*****************************************************************/
open_error_t openapiRtrIntfIpStackIfIndexGet(openapiClientHandle_t *client_handle,
                                             uint32_t intf, 
                                             uint32_t *ifIndex);
 
/*****************************************************************/
open_error_t openapiRtrIntfIpStackIfNameGet(openapiClientHandle_t *client_handle,
                                   uint32_t intf, 
                                   open_buffdesc *intfName);

/*****************************************************************/
open_error_t openapiRtrIntfIpStackStkNameGet(openapiClientHandle_t *client_handle,
                                             uint32_t vrfId, uint32_t intf, open_buffdesc *intfName);

/*****************************************************************/
open_error_t openapiRtrIntfIpStackDrvNameGet(openapiClientHandle_t *client_handle,
                                             uint32_t vrfId, uint32_t intf, open_buffdesc *intfName);

/*****************************************************************/
open_error_t openapiVrfIntfNameGet(openapiClientHandle_t *client_handle,
                                   uint32_t vrfId, open_buffdesc *intfName);

/*****************************************************************/
open_error_t openapiRtrIntfUnitSlotPortGet(openapiClientHandle_t *client_handle,
                                           uint32_t intf,
                                           open_USP_t *usp);

/*****************************************************************/
open_error_t openapiRtrIntfL3MacAddressGet(openapiClientHandle_t *client_handle,
                                           uint32_t intf,
                                           open_buffdesc *mac);

/*****************************************************************/
open_error_t openapiRtrIntfOperModeGet(openapiClientHandle_t *client_handle,
                                       OPEN_AF_t af, 
                                       uint32_t intf, 
                                       OPEN_CONTROL_t *ifState);

/*****************************************************************/
open_error_t openapiRtrIntfIpAddrGet(openapiClientHandle_t *client_handle,
                                     OPEN_AF_t af, 
                                     uint32_t intf, 
                                     open_inet_pfx_t *ipAddr);

/*****************************************************************/
open_error_t openapiRtrIntfSecIpAddrGet(openapiClientHandle_t *client_handle,
                                     OPEN_AF_t af, 
                                     uint32_t intf, 
                                     open_inet_pfx_t *ipAddr,
                                     uint32_t *index);

/*****************************************************************/
open_error_t openapiRtrIntfIpAddrMethodGet(openapiClientHandle_t *client_handle,
                                           uint32_t intf,
                                           OPEN_INTF_IP_ADDR_METHOD_t *addrMethod,
                                           OPEN_CONTROL_t *clientIdEnable);

/*****************************************************************/
open_error_t openapiIntfIpMtuGet(openapiClientHandle_t *client_handle,
                                 OPEN_AF_t af, 
                                 uint32_t intf, 
                                 uint32_t *ipMtu);

/*****************************************************************/
open_error_t openapiIntfBandwidthGet(openapiClientHandle_t *client_handle,
                                     OPEN_AF_t af, 
                                     uint32_t intf, 
                                     uint32_t *bandwidth);

/*****************************************************************/
open_error_t openapiRtrICMPUnreachablesModeGet(openapiClientHandle_t *client_handle,
                                     uint32_t intf, 
                                     uint32_t *mode);

/*****************************************************************/
open_error_t openapiRtrICMPRedirectsModeGet(openapiClientHandle_t *client_handle,
                                     uint32_t intf, 
                                     uint32_t *mode);

/*****************************************************************/
open_error_t openapiRtrICMPRatelimitGet(openapiClientHandle_t *client_handle,
                                        open_buffdesc *vrfName, 
                                        uint32_t *burstSize,
                                        uint32_t *interval);

/*****************************************************************/
open_error_t openapiRtrICMPEchoReplyModeGet(openapiClientHandle_t *client_handle,
                                        open_buffdesc *vrfName, 
                                        uint32_t *mode);

/*****************************************************************/
open_error_t openapiRtrAdminModeGet(openapiClientHandle_t *client_handle,
                                    OPEN_AF_t af, 
                                    OPEN_CONTROL_t *enable);

/*****************************************************************/
open_error_t openapiRoutingStartupStatus(openapiClientHandle_t *client_handle,
                                         OPEN_AF_t af, 
                                         uint32_t *complete);

/*****************************************************************/
open_error_t openapiRoutingStartupStatusVr (openapiClientHandle_t *client_handle,
                                            OPEN_AF_t af,
                                            uint32_t vrfId,
                                            uint32_t *complete);

/*****************************************************************/
int openapiRouteMapApply(openapiClientHandle_t *client_handle,
                         open_buffdesc *routeMapName,
                         openRmMatchParams_t *matchParams,
                         openRmSetParams_t *setParams);

/*****************************************************************/
open_error_t openapiRouteMapFilter( openapiClientHandle_t *client_handle,
                                    open_buffdesc *routeMapName,
                                    openRmMatchParams_t *matchParams,
                                    openRmSetParams_t *setParams,
                                    OPEN_FILTER_ACTION_t *action);

/*****************************************************************/
int openapiPrefixListApply(openapiClientHandle_t *client_handle,
                           open_buffdesc *pfxListName, 
                           open_inet_addr_t prefix, 
                           uint32_t pfxLen);

/*****************************************************************/
open_error_t openapiRoutingPolicyRegister(openapiClientHandle_t *client_handle,
                                          open_buffdesc *clientName, 
                                          uint32_t  pid,
                                          uint32_t policyTypeMask,
                                          uint32_t *clientId);

/*****************************************************************/
open_error_t openapiPolicyChangeAck(openapiClientHandle_t *client_handle,
                                    uint32_t clientId, 
                                    uint32_t seqNo);

/*****************************************************************/
open_error_t openapiIpRouterPreferenceGet(openapiClientHandle_t *client_handle,
                                          OPEN_PREF_INDICES_t index,
                                          uint32_t *pref);

/*****************************************************************/
open_error_t openapiIpRouterPreferenceSet(openapiClientHandle_t *client_handle,
                                          OPEN_PREF_INDICES_t index,
                                          uint32_t pref);

/*****************************************************************/
open_error_t openapiIpRouterProtoNameNextGet(openapiClientHandle_t *client_handle,
                                             uint32_t protoId,
                                             open_buffdesc *protoName,
                                             uint32_t *nextProtoId);

/*****************************************************************/
open_error_t openapiIp6RouterPreferenceGet(openapiClientHandle_t *client_handle,
                                           OPEN_PREF_INDICES_t index,
                                           uint32_t *pref);

/*****************************************************************/
open_error_t openapiIp6RouterPreferenceSet(openapiClientHandle_t *client_handle,
                                           OPEN_PREF_INDICES_t index,
                                           uint32_t pref);

/******* NEW OpENAPIs Added for virtual router support *************/

/*****************************************************************/
open_error_t openapiBestRouteEventRegisterVr(openapiClientHandle_t *client_handle,
                                           uint32_t vrfId,
                                           OPEN_AF_t family,
                                           uint32_t pid,
                                           open_buffdesc *clientName,
                                           uint32_t   *clientId);

/*****************************************************************/
open_error_t openapiRouteAddVr(openapiClientHandle_t *client_handle,
                               uint32_t vrfId,
                               openRoute_t *routeEntry,
                               open_buffdesc *nextHopListBuff);


/**************************************************************************/
open_error_t openapiBfdModeSet(OPEN_BFD_ADMIN_MODE_t mode);

/*****************************************************************/
open_error_t openapiBfdSessionCreate(openapiClientHandle_t *client_handle,
                                     openBfdEndpoint_t *ep, 
                                     uint32_t *id);

/*****************************************************************/
open_error_t openapiBfdSessionDelete(openapiClientHandle_t *client_handle,
                                     openBfdEndpoint_t *ep, 
                                     uint32_t id);

/*****************************************************************/
open_error_t openapiBfdSessionFind(openapiClientHandle_t *client_handle,
                                   open_inet_addr_t peer,
                                   uint32_t *id);

/*****************************************************************/
open_error_t openapiBfdSessionInfoGet(openapiClientHandle_t *client_handle,
                                      uint32_t id,
                                      openBfdSessionInfo_t *info);

/*****************************************************************/
open_error_t openapiBfdSessionStatsGet(openapiClientHandle_t *client_handle,
                                       uint32_t id, openBfdSessionStats_t *stats);


/*****************************************************************/
open_error_t openapiKernelRouteAddVr(openapiClientHandle_t *client_handle,
                               uint32_t vrfId,
                               openRoute_t *routeEntry,
                               open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiRouteModVr(openapiClientHandle_t *client_handle,
                               uint32_t vrfId,
                               openRoute_t *routeEntry,
                               open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiRouteDelVr(openapiClientHandle_t *client_handle,
                               uint32_t vrfId,
                               openRoute_t *routeEntry,
                               open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t openapiKernelRouteDelVr(openapiClientHandle_t *client_handle,
                               uint32_t vrfId,
                               openRoute_t *routeEntry,
                               open_buffdesc *nextHopListBuff);

/*****************************************************************/
open_error_t
openapiRtoFreeRouteCountGet (openapiClientHandle_t *client_handle,
                             uint32_t vrfId,
                             uint32_t *rtoFreeRouteCount);

/*****************************************************************/
open_error_t
openapiRtrAdminModeGetVrf (openapiClientHandle_t *client_handle,
                           OPEN_AF_t af,
                           uint32_t vrfId,
                           OPEN_CONTROL_t *enable);

/*****************************************************************/
open_error_t
openapiPlatRtrRouteMaxEqualCostEntriesGet (openapiClientHandle_t *client_handle,
                                           uint32_t *pval);

/*****************************************************************/
open_error_t
openapiPlatRtrRouteMaxEntriesGet (openapiClientHandle_t *client_handle,
                                  uint32_t *pval);

/*****************************************************************/
open_error_t
openapiIpMapNsfRouteSource(openapiClientHandle_t *client_handle,
                           uint32_t vrfId,
                           OPEN_NSF_PROTOCOL_t protocol);

/*****************************************************************/
open_error_t
openapiIpMapInitialRoutesDone(openapiClientHandle_t *client_handle,
                              uint32_t vrfId,
                              OPEN_NSF_PROTOCOL_t protocol);

/*****************************************************************/
open_error_t openapiIpMapIsBackupElectedGet(openapiClientHandle_t *client_handle,
                                            OPEN_BOOL_t *isBackupElected);

/*****************************************************************/
open_error_t
openapiUnnumberedPeerInfoSet (openapiClientHandle_t *client_handle,
                              uint32_t intIfNum, uint32_t peerIp, OPEN_BOOL_t isAdd, uint32_t flag);

/*****************************************************************/
open_error_t openapiKernelArpAdd (openapiClientHandle_t *client_handle,
                                  uint32_t vrfId, 
                                  open_inet_addr_t *dest_addr,
                                  open_buffdesc *mac,
                                  int32_t stkIfIndex,
                                  uint16_t state);

/*****************************************************************/
open_error_t openapiKernelArpDelete (openapiClientHandle_t *client_handle,
                                     uint32_t vrfId,
                                     open_inet_addr_t *dest_addr,
                                     int32_t stkIfIndex);

/*****************************************************************/
open_error_t openapiIpRouterPreferenceGetVr (openapiClientHandle_t *client_handle,
                                             uint32_t vrfId,
                                             OPEN_PREF_INDICES_t index,
                                             uint32_t *pref);

#endif /* OPENAPI_ROUTING_H_INCLUDED */