openapi_common.h

Go to the documentation of this file.

/*********************************************************************
*
*  Copyright 2016-2023 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_common.h
*
* @purpose   Base Services. 
*
* @component OpEN
*
* @create    07/13/2012
*
* @end
*
**********************************************************************/
#ifndef _OPENAPI_COMMON_H_
#define _OPENAPI_COMMON_H_

#include <stdint.h>
#include <arpa/inet.h>
#include <netinet/in.h>

/* Some structures need to be packed on platforms that use
** 64 bit OpEN API libraries and 32 bit network operating system.
*/
#if defined (__i386__) || defined (__x86_64__)
  #define OPEN_PACKED_STRUCT typedef struct __attribute__((__packed__))
#else
  #define OPEN_PACKED_STRUCT typedef struct
#endif


/* 
 * OPEN API error codes.
 * 
 * Note: Values used in this enum for non-zero entries must 
 *       be different than those used in L7_RPCCLT_RC_t.
 *       OPEN API calls via RPC may return error code values
 *       from L7_RPCCLT_RC_t in certain situations.
 */
typedef enum
{
  OPEN_E_NONE                 = 0,   
  OPEN_E_RPC                  = -20, 
  OPEN_E_INTERNAL             = -21, 
  OPEN_E_PARAM                = -22, 
  OPEN_E_FULL                 = -23, 
  OPEN_E_EXISTS               = -24, 
  OPEN_E_TIMEOUT              = -25, 
  OPEN_E_FAIL                 = -26, 
  OPEN_E_DISABLED             = -27, 
  OPEN_E_UNAVAIL              = -28, 
  OPEN_E_NOT_FOUND            = -29, 
  OPEN_E_EMPTY                = -30, 
  OPEN_E_ERROR                = -31, 
  OPEN_E_DEPENDENCY_NOT_MET   = -32, 
  OPEN_E_BUSY                 = -33  
} open_error_t;

typedef enum
{
  OPEN_EVENT_INTERFACE          = 0, /* This first event must be 0 */
  OPEN_EVENT_VLAN               = 1,
  OPEN_EVENT_ROUTE              = 2,
  OPEN_EVENT_ROUTING_INTERFACE  = 3,
  OPEN_EVENT_ISSU_START         = 4,
  OPEN_EVENT_READY_STATE        = 5, /* Configurator transition to/from execute state */
  OPEN_EVENT_CONFIG             = 6,
  OPEN_EVENT_LAST                    /* Must be last. Can be incremented as needed */
} OPEN_EVENT_e;

typedef struct
{
  unsigned char open_event_mask [((OPEN_EVENT_LAST) / 8) + 1];
} openapiEventList_t;

/* OpEN registration service identifiers supported for
 * external OpEN API clients. 
 *  
 * Internal clients have their own set of identifiers 
 * (unpublished) that are not included here, hence the 
 * use of #define instead of an enumeration. 
 *  
 * NOTE: Defining values that are not likely to get
 *       confused with the actual service ID values.
 *       All values listed here get converted to their
 *       real server ID values by the API implementation.
 */
#define OPEN_REGISTRATION_SERVICE_USERAPPS      100001      /* all user-provided applications */

/* First instance number for a given RPC client (by convention).
 * 
 * Note: Mirrors L7_RPCCLT_INSTANCE_FIRST definition.
 */
#define OPEN_CLIENT_INSTANCE_FIRST              1

typedef enum
{
  OPEN_REGISTER_FLAGS_NONE              = 0x00000000,       
  OPEN_REGISTER_FLAGS_THREADED          = 0x00000001        
} OPEN_REGISTER_FLAGS_t;

/* OpEN client handle struct. Only use provided accessor functions to
 * retrieve any contents.
 */
struct openapiClientHandle_s
{
  char   content[256];
};

typedef struct openapiClientHandle_s openapiClientHandle_t;

typedef struct
{
  uint32_t                size;          /* total buffer size (IN) / content length (OUT) */
  void                   *pstart;        /* ptr to buffer starting location */
} open_buffdesc;

typedef struct
{
  uint8_t release;
  uint8_t version;
  uint8_t maint_level;
  uint8_t build_num;
} open_revision_data_t;

/* Network interface */
typedef struct
{
  uint8_t       unit;
  uint8_t       slot;
  uint16_t      port;

} open_USP_t;

typedef enum
{
  OPEN_DISABLE = 0, 
  OPEN_ENABLE  = 1,  
} OPEN_CONTROL_t;

typedef enum
{
  OPEN_PORT_DISABLE = 0, 
  OPEN_PORT_ENABLE = 1, 
  OPEN_PORT_DIAG_DISABLE = 2 
} OPEN_PORT_STATE_t;

typedef enum
{
  OPEN_FALSE = 0, 
  OPEN_TRUE  = 1  
} OPEN_BOOL_t;

typedef enum
{
  OPEN_LINK_UP   = 0, 
  OPEN_LINK_DOWN = 1  
} OPEN_LINK_STATE_t;

typedef enum
{
  OPEN_ACTION_ADD    = 0,
  OPEN_ACTION_DELETE = 1

} OPEN_ACTION_t;

typedef enum
{
  OPEN_INTF_TYPE_PHY            = 0, 
  OPEN_INTF_TYPE_CPU            = 1, 
  OPEN_INTF_TYPE_LAG            = 2, 
  OPEN_INTF_TYPE_VLAN           = 3, 
  OPEN_INTF_TYPE_LOOPBACK       = 4, 
  OPEN_INTF_TYPE_TUNNEL         = 5, 
  OPEN_INTF_TYPE_SERVICE_PORT   = 6, 
  OPEN_INTF_TYPE_OTHER          = 7, 
  OPEN_INTF_TYPE_ANY            = 8  
} OPEN_INTF_TYPE_t;

typedef enum
{
  OPEN_VLAN_PARTICIPATION_MODE_INCLUDE  = 0, 
  OPEN_VLAN_PARTICIPATION_MODE_AUTO     = 1, 
  OPEN_VLAN_PARTICIPATION_MODE_EXCLUDE  = 2  
} OPEN_VLAN_PARTICIPATION_MODE_t;

typedef enum
{
  OPEN_DOT1Q_ADMIT_ALL                = 1, 
  OPEN_DOT1Q_ADMIN_ONLY_VLAN_TAGGED   = 2, 
  OPEN_DOT1Q_ADMIN_ONLY_VLAN_UNTAGGED = 3  
} OPEN_DOT1Q_ACCEPT_FRAME_TYPE_t;

#define OPEN_MAC_ADDR_LEN 6
#define OPEN_MAC_ADDR_STR_LEN (OPEN_MAC_ADDR_LEN * 3)

#define OPEN_MIN_U64_STR_BUFFER_SIZE 21    
#define OPEN_DATE_TIME_OUTPUT_FORMAT    "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d"
#define OPEN_DATE_TIME_BUF_LEN          20 /* includes trailing '\0' */

typedef enum
{
  OPEN_AF_NONE  = 0, 
  OPEN_AF_INET  = 1, 
  OPEN_AF_INET6 = 2  
} OPEN_AF_t;

typedef enum
{
  OPEN_AFX_IP4 = 0, 
  OPEN_AFX_IP6 = 1  
} OPEN_AFX_t;

typedef enum
{
  OPEN_PREF_RESERVED                = 0,  /* Not a valid protocol */
  OPEN_PREF_LOCAL                   = 1,
  OPEN_PREF_STATIC                  = 2,
  OPEN_PREF_MPLS                    = 3,
  OPEN_PREF_OSPF_INTRA_AREA         = 4,
  OPEN_PREF_OSPF_INTER_AREA         = 5,
  OPEN_PREF_OSPF_EXTERNAL           = 6,
  OPEN_PREF_RIP                     = 7,
  OPEN_PREF_IBGP                    = 8,
  OPEN_PREF_EBGP                    = 9,
  OPEN_PREF_6TO4                    = 10,
  OPEN_PREF_GLOBAL_DEFAULT_GATEWAY  = 11,
  OPEN_PREF_DEFAULT_DHCP            = 12,
  OPEN_PREF_LOCAL_BGP               = 13,
  OPEN_PREF_LAST                          /* Always keep this last */
} OPEN_PREF_INDICES_t;

typedef enum
{
  OPEN_REDIST_RT_FIRST  = 0,
  OPEN_REDIST_RT_LOCAL  = 1,
  OPEN_REDIST_RT_STATIC = 2,
  OPEN_REDIST_RT_RIP    = 3,
  OPEN_REDIST_RT_OSPF   = 4,
  OPEN_REDIST_RT_BGP    = 5,
  OPEN_REDIST_RT_OSPFV3 = 6,
  OPEN_REDIST_RT_LAST
} OPEN_REDIST_RT_INDICES_t;

typedef struct open_in6_addr_s 
{
  union
  {
    uint32_t  addr32[4];
    uint16_t  addr16[8];
    uint8_t   addr8[16];
  }u;
} open_in6_addr_t;

typedef struct open_inet_addr_s
{
  OPEN_AF_t     family;  
  union
  {
    /* IPv4 address always in host byte order */
    uint32_t    ipv4;
    open_in6_addr_t   ipv6;
  } addr;
} open_inet_addr_t;

typedef struct open_inet_pfx_s
{
  open_inet_addr_t ipAddr;
  uint32_t pfxLen;

} open_inet_pfx_t;


typedef enum
{
  OPEN_ACCESS_LINE_UNKNOWN = 0, 
  OPEN_ACCESS_LINE_CONSOLE,     
  OPEN_ACCESS_LINE_TELNET,     
  OPEN_ACCESS_LINE_SSH,        
  OPEN_ACCESS_LINE_HTTPS,      
  OPEN_ACCESS_LINE_HTTP,       
  OPEN_ACCESS_LINE_DOT1X       
} OPEN_ACCESS_LINE_t;


#define OPEN_IS_ADDR_EQUAL(xaddr, yaddr) \
  ( (OPEN_AF_INET6 == ((open_inet_addr_t *)(xaddr))->family) ? \
    ( (((open_inet_addr_t *)(xaddr))->addr.ipv6.u.addr32[0] == \
       ((open_inet_addr_t *)(yaddr))->addr.ipv6.u.addr32[0]) && \
      (((open_inet_addr_t *)(xaddr))->addr.ipv6.u.addr32[1] == \
       ((open_inet_addr_t *)(yaddr))->addr.ipv6.u.addr32[1]) && \
      (((open_inet_addr_t *)(xaddr))->addr.ipv6.u.addr32[2] == \
       ((open_inet_addr_t *)(yaddr))->addr.ipv6.u.addr32[2]) && \
      (((open_inet_addr_t *)(xaddr))->addr.ipv6.u.addr32[3] == \
       ((open_inet_addr_t *)(yaddr))->addr.ipv6.u.addr32[3]) ) : \
    ( ((open_inet_addr_t *)(xaddr))->addr.ipv4 == \
      ((open_inet_addr_t *)(yaddr))->addr.ipv4) )

#define OPEN_INTF_NAME_MAX_LENGTH 60
#define OPEN_IP_ADDR_DISP_LENGTH  46
#define OPENAPI_VER_BUFF_MAX_SIZE 128
#define OPEN_IP_ADDR_LENGTH 16
#define OPENAPI_VER_BUFF_MAX_SIZE 128

typedef enum
{
  OPEN_PASSWORD_ENCRYPT_NONE    = 0,
  OPEN_PASSWORD_ENCRYPT_AES     = 1,
  OPEN_PASSWORD_ENCRYPT_MD5     = 2
} OPEN_PASSWORD_ENCRYPT_ALG_t;

typedef enum
{
  OPEN_IP_ADDRESS_UNKNOWN = 0, 
  OPEN_IP_ADDRESS_IPV4    = 1, 
  OPEN_IP_ADDRESS_IPV6    = 2, 
  OPEN_IP_ADDRESS_DNS     = 16  
} OPEN_IP_ADDRESS_TYPE_t;

typedef enum
{
  OPEN_RATE_UNIT_NONE            = 0, 
  OPEN_RATE_UNIT_PERCENT         = 1, 
  OPEN_RATE_UNIT_PPS             = 2, 
  OPEN_RATE_UNIT_KBPS            = 3  
} OPEN_RATE_UNIT_t;

typedef unsigned char maskValue_t;

#define OPEN_MASK_UNIT            (sizeof(maskValue_t) * 8)
#define OPEN_MASK_LEN(_size)      ((((_size) - 1) / OPEN_MASK_UNIT) + 1)

#define OPEN_SETMASKBIT(j, k)                                          \
  ((j)[(k - 1) / L7_MASK_UNIT] |= 1 << ((k - 1) % L7_MASK_UNIT))

#define OPEN_CLRMASKBIT(j, k)                                          \
  ((j)[(k - 1) / OPEN_MASK_UNIT] &= ~(1 << ((k - 1) % L7_MASK_UNIT)))


#define OPEN_NONZEROMASK(_mask, _result, _size)             \
  do                                                      \
  {                                                       \
    uint32_t _i_;                                        \
    maskValue_t *_p_ = (maskValue_t *)&(_mask); \
                                                          \
    (_result) = 0;                                        \
    for (_i_ = 0; _i_ < OPEN_MASK_LEN(_size); _i_++)        \
    {                                                     \
      if (_p_[_i_] != 0)                                  \
      {                                                   \
        (_result) = 1;                                    \
        break;                                            \
      }                                                   \
    }                                                     \
  } while (0)


#define OPEN_ISMASKBITSET(j, k)                                        \
  ((j)[((k - 1) / OPEN_MASK_UNIT)] & ( 1 << ((k - 1) % OPEN_MASK_UNIT)))

#define OPENAPI_PROTOCOL_HEX_IP   0x0800  
#define OPENAPI_PROTOCOL_HEX_ARP  0x0806  
#define OPENAPI_PROTOCOL_HEX_IPX  0x8137  
#define OPENAPI_PROTOCOL_HEX_MIN  0x0600  
#define OPENAPI_PROTOCOL_HEX_MAX  0xFFFF  
#define OPEN_MATCH_EXACT     1
#define OPEN_MATCH_GETNEXT   2
#define OPEN_MATCH_FREE      3

#define OPEN_VRF_MAX_NAME_LEN 15

#define OPEN_RPC_CLT_RECV_DEF_TIMEOUT  0  
#define OPEN_RPC_CLT_RECV_MIN_TIMEOUT  1  
#define OPEN_RPC_CLT_RECV_MAX_TIMEOUT  65535 
/* RPC debug counters */
typedef struct 
{
  uint32_t msendok;                    
  uint32_t mrecvok;                    
  uint32_t mnowait;                    
  uint32_t msendfail;                  
  uint32_t mrecvfail;                  
  uint32_t mrecvseqerr;                
  uint32_t mrecvtimeout;               
  uint32_t mrecvtrunc;                 
  uint32_t mconnfail;                  
} openapiClientRpcStats_t;

/*****************************************************************/
open_error_t openapiApiVersionGet(openapiClientHandle_t *client_handle,
                                  open_revision_data_t *version);

/*****************************************************************/
open_error_t openapiCpuIntfGet(openapiClientHandle_t *client_handle,
                               uint32_t *intf);

/*****************************************************************/
open_error_t openapiOspfEqualCostRoutesMax(openapiClientHandle_t *client_handle,
                                           uint32_t *maxPaths);

/*****************************************************************/
void openapiEventListClear(openapiEventList_t *event_mask);

/*****************************************************************/
void openapiEventSet(openapiEventList_t *event_mask, OPEN_EVENT_e event_handle);

/*****************************************************************/
int openapiEventIsSet(openapiEventList_t *event_mask, OPEN_EVENT_e event_handle);

/*****************************************************************/
open_error_t openapiClientRegister(char *client_name,
                                   openapiClientHandle_t *client_handle);

/*****************************************************************/
open_error_t openapiClientRegisterEnhanced(char *client_name,
                                           OPEN_REGISTER_FLAGS_t reg_flags,
                                           openapiClientHandle_t *client_handle);

/*****************************************************************/
open_error_t openapiServiceClientRegister(char *client_name,
                                          int32_t client_inst,
                                          int32_t server_id,
                                          openapiClientHandle_t *client_handle);

/*****************************************************************/
open_error_t openapiInternalClientRegister(char *client_name,
                                           openapiClientHandle_t *client_handle);

/*****************************************************************/
open_error_t openapiClientTearDown(openapiClientHandle_t *client_handle);

/*****************************************************************/
open_error_t openapiInternalClientTearDown(openapiClientHandle_t *client_handle);

/*****************************************************************/
open_error_t openapiEventRegister(openapiClientHandle_t *client_handle,
                                  openapiEventList_t *event_mask);

/*****************************************************************/
open_error_t openapiPendingEventsGet(openapiClientHandle_t *client_handle,
                                     openapiEventList_t *changed_mask,
                                     openapiEventList_t *purged_mask);

/*****************************************************************/
open_error_t openapiEventWait(openapiClientHandle_t *client_handle,
                              int32_t timeout_secs);


/*****************************************************************/
open_error_t openapiMaxInterfaceCountGet(openapiClientHandle_t *client_handle,
                                         uint32_t *max_interface_count);

/*****************************************************************/
open_error_t openapiSystemReadyStateGet(openapiClientHandle_t *client_handle,
                                         uint32_t *system_is_ready);

/*****************************************************************/
open_error_t openapiSystemReadyStateTransitionNextGet(
                                         openapiClientHandle_t *client_handle,
                                         uint32_t *system_is_ready);

/*****************************************************************/
int openapiClientNotifySocketFDGet(openapiClientHandle_t *client_handle);

/*****************************************************************/
open_error_t openapiConnectivityCheck(openapiClientHandle_t *client_handle);

/*****************************************************************/
open_error_t openapiNetworkOSVersionGet(openapiClientHandle_t *client_handle,
                                        open_buffdesc *version);

/*****************************************************************/
open_error_t openapiInetAddrMaxSizeGet(openapiClientHandle_t *client_handle,
                                       uint32_t *inetAddrMaxSize);

/*****************************************************************/
open_error_t openapiHardwareVersionGet(openapiClientHandle_t *client_handle,
                                        open_buffdesc *version);

/*****************************************************************/
open_error_t openapiInetAddrCompare(openapiClientHandle_t *client_handle,
                                    open_buffdesc *ip1Str,
                                    open_buffdesc *ip2Str,
                                    OPEN_BOOL_t *equal);

/*****************************************************************/
open_error_t openapiInetAddrGet(openapiClientHandle_t *client_handle,
                                open_buffdesc *ipStr,
                                open_inet_addr_t *ipAddr);

/*****************************************************************/
open_error_t openapiInetAddrFromIPAddrHostNameStr(openapiClientHandle_t *client_handle, 
                                                  open_buffdesc *ipOrHostStr,
                                                  open_inet_addr_t *inetAddr);

/*****************************************************************/
open_error_t openapiPingCallback(openapiClientHandle_t *client_handle,
                                uint16_t seqNo, uint32_t rtt, uint32_t type, open_buffdesc *srcIp );

/*****************************************************************/
open_error_t openapiTraceRouteCallbackFn(openapiClientHandle_t *client_handle, uint32_t numProbes, uint32_t ttl, uint32_t ipDa,
                                uint16_t hopCount, uint16_t probeCount, uint32_t rtt, uint8_t errSym);

/*****************************************************************/
open_error_t openapiCurrentSDMGet(openapiClientHandle_t *client_handle, uint32_t *sdm_template);

/*****************************************************************/
open_error_t openapiIsInetAddrZero (openapiClientHandle_t * client_handle,
                                    open_inet_addr_t ipAddr,
                                    OPEN_BOOL_t * isZero);

/*****************************************************************/
open_error_t openapiIntfNameMaxLengthGet (openapiClientHandle_t * client_handle,
                                          uint32_t * maxLen);

/*****************************************************************/
open_error_t openapiIntfNameGet (openapiClientHandle_t * client_handle,
                                 uint32_t intfNum, 
                                 open_buffdesc * bufdName);

/*****************************************************************/
open_error_t openapiIpAddressMaxStringLength (openapiClientHandle_t * client_handle,
                                              uint32_t * maxLen);

/*****************************************************************/
open_error_t openapiOpenIPtoStringGet (openapiClientHandle_t * client_handle,
                                       open_inet_addr_t openAddr,
                                       open_buffdesc * bufdName);

/*****************************************************************/
open_error_t openapiSystemFileNameMaxLengthGet(openapiClientHandle_t *client_handle,
                                               uint32_t *fileNameLen);

/*****************************************************************/
open_error_t openapiImageFileNameMaxLengthGet(openapiClientHandle_t *client_handle,
                                              uint32_t *fileNameLen);

/*****************************************************************/
open_error_t openapiIntfDisplayNameGet (openapiClientHandle_t * client_handle, 
                                        uint32_t unit, 
                                        uint32_t slot,
                                        uint32_t port, 
                                        open_buffdesc * bufdName);

/*****************************************************************/
open_error_t openapiAllIntfNumGet(openapiClientHandle_t *client_handle,
                                  uint32_t *intfNum);

/*****************************************************************/
open_error_t openapiMacAddrStringToHexGet(openapiClientHandle_t * client_handle,
                                          open_buffdesc *inputMac,
                                          open_buffdesc *outputMac);

/*****************************************************************/
open_error_t openapiTimeToCalenderTimeGet(openapiClientHandle_t * client_handle,
                                          uint32_t inputTime,
                                          open_buffdesc *outputTime);

/*****************************************************************/
open_error_t openapiClientReceiveTimeoutSet(openapiClientHandle_t *client_handle,
                                            uint32_t timeout);

/*****************************************************************/
open_error_t openapiClientReceiveTimeoutGet(openapiClientHandle_t *client_handle,
                                            uint32_t *timeout);

/*****************************************************************/
open_error_t openapiClientRpcStatsGet(openapiClientRpcStats_t *stats);

/*****************************************************************/
open_error_t openapiClientStatsPrint(void);

#endif  /* _OPENAPI_COMMON_H_ */