1a319aadc6
The VPP API auto-generated endian conversion functions are intended to be symmetrical. They are used both by the API client and the API server. Called on send to convert from host endian to network endian and on receive to convert back. For variable length arrays, we have to iterate over the array and call a more specific handler for the array type. Unfortunately the length of the array is part of the api definition, and if it's endian swapped prior to the for loop, unexpected behaviour will ensue. There was an earlier fix, for some specific messages, but unfortunately that only fixed the problem from the VPP (server) side. This adds a new parameters to the endian handler, so the boundary argument to the loop can be treated differently depending on if this message is to the network or from the network. Type: fix Change-Id: I43011aed384e3b847579a1dd2c390867ae17a9ad Signed-off-by: Ole Troan <otroan@employees.org>
750 lines
46 KiB
C
750 lines
46 KiB
C
/*
|
|
*------------------------------------------------------------------
|
|
* api_helper_macros.h - message handler helper macros
|
|
*
|
|
* Copyright (c) 2016 Cisco and/or its affiliates.
|
|
* 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.
|
|
*------------------------------------------------------------------
|
|
*/
|
|
|
|
#ifndef __api_helper_macros_h__
|
|
#define __api_helper_macros_h__
|
|
|
|
#define f64_endian(a)
|
|
#define f64_print(a,b)
|
|
|
|
#ifndef REPLY_MSG_ID_BASE
|
|
#define REPLY_MSG_ID_BASE 0
|
|
#endif
|
|
|
|
#define _NATIVE_TO_NETWORK(t, rmp) \
|
|
api_main_t *am = vlibapi_get_main (); \
|
|
void (*endian_fp) (void *, bool); \
|
|
endian_fp = am->msg_data[t + (REPLY_MSG_ID_BASE)].endian_handler; \
|
|
(*endian_fp) (rmp, 1 /* to network */);
|
|
|
|
#define REPLY_MACRO(msg) \
|
|
do \
|
|
{ \
|
|
STATIC_ASSERT ( \
|
|
msg##_IS_CONSTANT_SIZE, \
|
|
"REPLY_MACRO can only be used with constant size messages, " \
|
|
"use REPLY_MACRO[3|4]* instead"); \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = htons (msg + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = ntohl (rv); \
|
|
\
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO_END(t) \
|
|
do \
|
|
{ \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = t + (REPLY_MSG_ID_BASE); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = rv; \
|
|
_NATIVE_TO_NETWORK (t, rmp); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO2(t, body) \
|
|
do \
|
|
{ \
|
|
STATIC_ASSERT ( \
|
|
t##_IS_CONSTANT_SIZE, \
|
|
"REPLY_MACRO2 can only be used with constant size messages, " \
|
|
"use REPLY_MACRO[3|4]* instead"); \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = htons ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = ntohl (rv); \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO2_END(t, body) \
|
|
do \
|
|
{ \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = t + (REPLY_MSG_ID_BASE); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = rv; \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
_NATIVE_TO_NETWORK (t, rmp); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO2_ZERO(t, body) \
|
|
do { \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc_zero (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = htons((t)+(REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = ntohl(rv); \
|
|
do {body;} while (0); \
|
|
vl_api_send_msg (rp, (u8 *)rmp); \
|
|
} while(0);
|
|
|
|
#define REPLY_MACRO2_ZERO_END(t, body) \
|
|
do \
|
|
{ \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc_zero (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = rv; \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
_NATIVE_TO_NETWORK (t, rmp); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO_DETAILS2(t, body) \
|
|
do { \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = htons((t)+(REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
do {body;} while (0); \
|
|
vl_api_send_msg (rp, (u8 *)rmp); \
|
|
} while(0);
|
|
|
|
#define REPLY_MACRO_DETAILS2_END(t, body) \
|
|
do \
|
|
{ \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
_NATIVE_TO_NETWORK (t, rmp); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO_DETAILS4(t, rp, context, body) \
|
|
do { \
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = htons((t)+(REPLY_MSG_ID_BASE)); \
|
|
rmp->context = context; \
|
|
do {body;} while (0); \
|
|
vl_api_send_msg (rp, (u8 *)rmp); \
|
|
} while(0);
|
|
|
|
#define REPLY_MACRO_DETAILS4_END(t, rp, context, body) \
|
|
do \
|
|
{ \
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
rmp->_vl_msg_id = ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = context; \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
_NATIVE_TO_NETWORK (t, rmp); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO_DETAILS5(t, n, rp, context, body) \
|
|
do \
|
|
{ \
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp) + n); \
|
|
rmp->_vl_msg_id = htons ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = context; \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO_DETAILS5_END(t, n, rp, context, body) \
|
|
do \
|
|
{ \
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp) + n); \
|
|
rmp->_vl_msg_id = ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = context; \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
_NATIVE_TO_NETWORK (t, rmp); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO3(t, n, body) \
|
|
do \
|
|
{ \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp) + (n)); \
|
|
rmp->_vl_msg_id = htons ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = ntohl (rv); \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO3_END(t, n, body) \
|
|
do \
|
|
{ \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp) + n); \
|
|
rmp->_vl_msg_id = ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = rv; \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
_NATIVE_TO_NETWORK (t, rmp); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO3_ZERO(t, n, body) \
|
|
do { \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc_zero (sizeof (*rmp) + n); \
|
|
rmp->_vl_msg_id = htons((t)+(REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = ntohl(rv); \
|
|
do {body;} while (0); \
|
|
vl_api_send_msg (rp, (u8 *)rmp); \
|
|
} while(0);
|
|
|
|
#define REPLY_MACRO3_ZERO_END(t, n, body) \
|
|
do \
|
|
{ \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc_zero (sizeof (*rmp) + n); \
|
|
rmp->_vl_msg_id = ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = rv; \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
_NATIVE_TO_NETWORK (t, rmp); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_MACRO4(t, n, body) \
|
|
do { \
|
|
vl_api_registration_t *rp; \
|
|
u8 is_error = 0; \
|
|
\
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc_or_null (sizeof (*rmp) + n); \
|
|
if (!rmp) \
|
|
{ \
|
|
/* if there isn't enough memory, try to allocate */ \
|
|
/* some at least for returning an error */ \
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
if (!rmp) \
|
|
return; \
|
|
\
|
|
clib_memset (rmp, 0, sizeof (*rmp)); \
|
|
rv = VNET_API_ERROR_TABLE_TOO_BIG; \
|
|
is_error = 1; \
|
|
} \
|
|
rmp->_vl_msg_id = htons((t)+(REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = ntohl(rv); \
|
|
if (!is_error) \
|
|
do {body;} while (0); \
|
|
vl_api_send_msg (rp, (u8 *)rmp); \
|
|
} while(0);
|
|
|
|
#define REPLY_MACRO4_END(t, n, body) \
|
|
do \
|
|
{ \
|
|
vl_api_registration_t *rp; \
|
|
u8 is_error = 0; \
|
|
\
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
\
|
|
rmp = vl_msg_api_alloc_or_null (sizeof (*rmp) + n); \
|
|
if (!rmp) \
|
|
{ \
|
|
/* if there isn't enough memory, try to allocate */ \
|
|
/* some at least for returning an error */ \
|
|
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
|
|
if (!rmp) \
|
|
return; \
|
|
\
|
|
clib_memset (rmp, 0, sizeof (*rmp)); \
|
|
rv = VNET_API_ERROR_TABLE_TOO_BIG; \
|
|
is_error = 1; \
|
|
} \
|
|
rmp->_vl_msg_id = ((t) + (REPLY_MSG_ID_BASE)); \
|
|
rmp->context = mp->context; \
|
|
rmp->retval = rv; \
|
|
if (!is_error) \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
_NATIVE_TO_NETWORK (t, rmp); \
|
|
vl_api_send_msg (rp, (u8 *) rmp); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_AND_DETAILS_MACRO(t, p, body) \
|
|
do \
|
|
{ \
|
|
if (pool_elts (p) == 0) \
|
|
{ \
|
|
REPLY_MACRO (t); \
|
|
break; \
|
|
} \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
u32 cursor = clib_net_to_host_u32 (mp->cursor); \
|
|
vlib_main_t *vm = vlib_get_main (); \
|
|
f64 start = vlib_time_now (vm); \
|
|
if (pool_is_free_index (p, cursor)) \
|
|
{ \
|
|
cursor = pool_next_index (p, cursor); \
|
|
if (cursor == ~0) \
|
|
rv = VNET_API_ERROR_INVALID_VALUE; \
|
|
} \
|
|
while (cursor != ~0) \
|
|
{ \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
cursor = pool_next_index (p, cursor); \
|
|
if (vl_api_process_may_suspend (vm, rp, start)) \
|
|
{ \
|
|
if (cursor != ~0) \
|
|
rv = VNET_API_ERROR_EAGAIN; \
|
|
break; \
|
|
} \
|
|
} \
|
|
REPLY_MACRO2 (t, ({ rmp->cursor = clib_host_to_net_u32 (cursor); })); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_AND_DETAILS_MACRO_END(t, p, body) \
|
|
do \
|
|
{ \
|
|
if (pool_elts (p) == 0) \
|
|
{ \
|
|
REPLY_MACRO_END (t); \
|
|
break; \
|
|
} \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
u32 cursor = mp->cursor; \
|
|
vlib_main_t *vm = vlib_get_main (); \
|
|
f64 start = vlib_time_now (vm); \
|
|
if (pool_is_free_index (p, cursor)) \
|
|
{ \
|
|
cursor = pool_next_index (p, cursor); \
|
|
if (cursor == ~0) \
|
|
rv = VNET_API_ERROR_INVALID_VALUE; \
|
|
} \
|
|
while (cursor != ~0) \
|
|
{ \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
cursor = pool_next_index (p, cursor); \
|
|
if (vl_api_process_may_suspend (vm, rp, start)) \
|
|
{ \
|
|
if (cursor != ~0) \
|
|
rv = VNET_API_ERROR_EAGAIN; \
|
|
break; \
|
|
} \
|
|
} \
|
|
REPLY_MACRO2_END (t, ({ rmp->cursor = cursor; })); \
|
|
} \
|
|
while (0);
|
|
|
|
#define REPLY_AND_DETAILS_VEC_MACRO(t, v, mp, rmp, rv, body) \
|
|
do { \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
u32 cursor = clib_net_to_host_u32 (mp->cursor); \
|
|
vlib_main_t *vm = vlib_get_main (); \
|
|
f64 start = vlib_time_now (vm); \
|
|
if (!v || vec_len (v) == 0) { \
|
|
cursor = ~0; \
|
|
rv = VNET_API_ERROR_INVALID_VALUE; \
|
|
} else if (cursor == ~0) \
|
|
cursor = 0; \
|
|
while (cursor != ~0 && cursor < vec_len (v)) { \
|
|
do {body;} while (0); \
|
|
++cursor; \
|
|
if (vl_api_process_may_suspend (vm, rp, start)) { \
|
|
if (cursor < vec_len (v)) \
|
|
rv = VNET_API_ERROR_EAGAIN; \
|
|
break; \
|
|
} \
|
|
} \
|
|
REPLY_MACRO2 (t, ({ \
|
|
rmp->cursor = clib_host_to_net_u32 (cursor); \
|
|
})); \
|
|
} while(0);
|
|
|
|
#define REPLY_AND_DETAILS_VEC_MACRO_END(t, v, mp, rmp, rv, body) \
|
|
do \
|
|
{ \
|
|
vl_api_registration_t *rp; \
|
|
rp = vl_api_client_index_to_registration (mp->client_index); \
|
|
if (rp == 0) \
|
|
return; \
|
|
u32 cursor = mp->cursor; \
|
|
vlib_main_t *vm = vlib_get_main (); \
|
|
f64 start = vlib_time_now (vm); \
|
|
if (!v || vec_len (v) == 0) \
|
|
{ \
|
|
cursor = ~0; \
|
|
rv = VNET_API_ERROR_INVALID_VALUE; \
|
|
} \
|
|
else if (cursor == ~0) \
|
|
cursor = 0; \
|
|
while (cursor != ~0 && cursor < vec_len (v)) \
|
|
{ \
|
|
do \
|
|
{ \
|
|
body; \
|
|
} \
|
|
while (0); \
|
|
++cursor; \
|
|
if (vl_api_process_may_suspend (vm, rp, start)) \
|
|
{ \
|
|
if (cursor < vec_len (v)) \
|
|
rv = VNET_API_ERROR_EAGAIN; \
|
|
break; \
|
|
} \
|
|
} \
|
|
REPLY_MACRO2_END (t, ({ rmp->cursor = cursor; })); \
|
|
} \
|
|
while (0);
|
|
|
|
/* "trust, but verify" */
|
|
#define vnet_sw_if_index_is_api_valid(sw_if_index) \
|
|
vnet_sw_interface_is_api_valid (vnet_get_main (), sw_if_index)
|
|
|
|
#define VALIDATE_SW_IF_INDEX(mp) \
|
|
do { u32 __sw_if_index = ntohl((mp)->sw_if_index); \
|
|
if (!vnet_sw_if_index_is_api_valid(__sw_if_index)) { \
|
|
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \
|
|
goto bad_sw_if_index; \
|
|
} \
|
|
} while(0);
|
|
|
|
#define VALIDATE_SW_IF_INDEX_END(mp) \
|
|
do \
|
|
{ \
|
|
if (!vnet_sw_if_index_is_api_valid ((mp)->sw_if_index)) \
|
|
{ \
|
|
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \
|
|
goto bad_sw_if_index; \
|
|
} \
|
|
} \
|
|
while (0);
|
|
|
|
#define BAD_SW_IF_INDEX_LABEL \
|
|
do { \
|
|
bad_sw_if_index: \
|
|
; \
|
|
} while (0);
|
|
|
|
#define VALIDATE_RX_SW_IF_INDEX(mp) \
|
|
do { u32 __rx_sw_if_index = ntohl((mp)->rx_sw_if_index); \
|
|
if (!vnet_sw_if_index_is_api_valid(__rx_sw_if_index)) { \
|
|
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \
|
|
goto bad_rx_sw_if_index; \
|
|
} \
|
|
} while(0);
|
|
|
|
#define VALIDATE_RX_SW_IF_INDEX_END(mp) \
|
|
do \
|
|
{ \
|
|
if (!vnet_sw_if_index_is_api_valid ((mp)->rx_sw_if_index)) \
|
|
{ \
|
|
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \
|
|
goto bad_rx_sw_if_index; \
|
|
} \
|
|
} \
|
|
while (0);
|
|
|
|
#define BAD_RX_SW_IF_INDEX_LABEL \
|
|
do { \
|
|
bad_rx_sw_if_index: \
|
|
; \
|
|
} while (0);
|
|
|
|
#define VALIDATE_TX_SW_IF_INDEX(mp) \
|
|
do { u32 __tx_sw_if_index = ntohl(mp->tx_sw_if_index); \
|
|
if (!vnet_sw_if_index_is_api_valid(__tx_sw_if_index)) { \
|
|
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \
|
|
goto bad_tx_sw_if_index; \
|
|
} \
|
|
} while(0);
|
|
|
|
#define VALIDATE_TX_SW_IF_INDEX_END(mp) \
|
|
do \
|
|
{ \
|
|
if (!vnet_sw_if_index_is_api_valid (mp->tx_sw_if_index)) \
|
|
{ \
|
|
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \
|
|
goto bad_tx_sw_if_index; \
|
|
} \
|
|
} \
|
|
while (0);
|
|
|
|
#define BAD_TX_SW_IF_INDEX_LABEL \
|
|
do { \
|
|
bad_tx_sw_if_index: \
|
|
; \
|
|
} while (0);
|
|
|
|
#define VALIDATE_BD_ID(mp) \
|
|
do { u32 __rx_bd_id = ntohl(mp->bd_id); \
|
|
if (__rx_bd_id > L2_BD_ID_MAX) { \
|
|
rv = VNET_API_ERROR_BD_ID_EXCEED_MAX; \
|
|
goto bad_bd_id; \
|
|
} \
|
|
} while(0);
|
|
|
|
#define VALIDATE_BD_ID_END(mp) \
|
|
do \
|
|
{ \
|
|
if (mp->bd_id > L2_BD_ID_MAX) \
|
|
{ \
|
|
rv = VNET_API_ERROR_BD_ID_EXCEED_MAX; \
|
|
goto bad_bd_id; \
|
|
} \
|
|
} \
|
|
while (0);
|
|
|
|
#define BAD_BD_ID_LABEL \
|
|
do { \
|
|
bad_bd_id: \
|
|
; \
|
|
} while (0);
|
|
|
|
#define pub_sub_handler(lca, UCA) \
|
|
static void vl_api_want_##lca##_t_handler (vl_api_want_##lca##_t *mp) \
|
|
{ \
|
|
vpe_api_main_t *vam = &vpe_api_main; \
|
|
vpe_client_registration_t *rp; \
|
|
vl_api_want_##lca##_reply_t *rmp; \
|
|
uword *p; \
|
|
i32 rv = 0; \
|
|
\
|
|
p = hash_get (vam->lca##_registration_hash, mp->client_index); \
|
|
if (p) \
|
|
{ \
|
|
if (mp->enable_disable) \
|
|
{ \
|
|
clib_warning ("pid %d: already enabled...", ntohl (mp->pid)); \
|
|
rv = VNET_API_ERROR_INVALID_REGISTRATION; \
|
|
goto reply; \
|
|
} \
|
|
else \
|
|
{ \
|
|
rp = pool_elt_at_index (vam->lca##_registrations, p[0]); \
|
|
pool_put (vam->lca##_registrations, rp); \
|
|
hash_unset (vam->lca##_registration_hash, mp->client_index); \
|
|
goto reply; \
|
|
} \
|
|
} \
|
|
if (mp->enable_disable == 0) \
|
|
{ \
|
|
clib_warning ("pid %d: already disabled...", mp->pid); \
|
|
rv = VNET_API_ERROR_INVALID_REGISTRATION; \
|
|
goto reply; \
|
|
} \
|
|
pool_get (vam->lca##_registrations, rp); \
|
|
rp->client_index = mp->client_index; \
|
|
rp->client_pid = mp->pid; \
|
|
hash_set (vam->lca##_registration_hash, rp->client_index, \
|
|
rp - vam->lca##_registrations); \
|
|
\
|
|
reply: \
|
|
REPLY_MACRO (VL_API_WANT_##UCA##_REPLY); \
|
|
} \
|
|
\
|
|
static clib_error_t *vl_api_want_##lca##_t_reaper (u32 client_index) \
|
|
{ \
|
|
vpe_api_main_t *vam = &vpe_api_main; \
|
|
vpe_client_registration_t *rp; \
|
|
uword *p; \
|
|
\
|
|
p = hash_get (vam->lca##_registration_hash, client_index); \
|
|
if (p) \
|
|
{ \
|
|
rp = pool_elt_at_index (vam->lca##_registrations, p[0]); \
|
|
pool_put (vam->lca##_registrations, rp); \
|
|
hash_unset (vam->lca##_registration_hash, client_index); \
|
|
} \
|
|
return (NULL); \
|
|
} \
|
|
\
|
|
VL_MSG_API_REAPER_FUNCTION (vl_api_want_##lca##_t_reaper);
|
|
|
|
#define foreach_registration_hash \
|
|
_(interface_events) \
|
|
_(to_netconf_server) \
|
|
_(from_netconf_server) \
|
|
_(to_netconf_client) \
|
|
_(from_netconf_client) \
|
|
_(oam_events) \
|
|
_(bfd_events) \
|
|
_(l2_arp_term_events) \
|
|
_(ip6_ra_events) \
|
|
_(dhcp6_pd_reply_events) \
|
|
_(dhcp6_reply_events) \
|
|
_(vrrp_vr_events)
|
|
|
|
typedef struct
|
|
{
|
|
u32 client_index; /* in memclnt registration pool */
|
|
u32 client_pid;
|
|
} vpe_client_registration_t;
|
|
|
|
typedef struct
|
|
{
|
|
#define _(a) \
|
|
uword *a##_registration_hash; \
|
|
vpe_client_registration_t * a##_registrations;
|
|
foreach_registration_hash
|
|
#undef _
|
|
/* notifications happen really early in the game */
|
|
u8 link_state_process_up;
|
|
|
|
/* convenience */
|
|
vlib_main_t *vlib_main;
|
|
struct vnet_main_t *vnet_main;
|
|
} vpe_api_main_t;
|
|
|
|
extern vpe_api_main_t vpe_api_main;
|
|
|
|
#endif /* __api_helper_macros_h__ */
|
|
|
|
/*
|
|
* fd.io coding-style-patch-verification: ON
|
|
*
|
|
* Local Variables:
|
|
* eval: (c-set-style "gnu")
|
|
* End:
|
|
*/
|