src/vpp-api/vapi/vapi.h

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2017 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #ifndef vpp_api_h_included
  19 #define vpp_api_h_included
  20
  21 #include <string.h>
  22 #include <stdbool.h>
  23 #include <vppinfra/types.h>
  24 #include <vapi/vapi_common.h>
  25
  26 #ifdef __cplusplus
  27 extern "C"
  28 {
  29 #endif
  30
  31 /**
  32  * @file vapi.h
  33  *
  34  * common vpp api C declarations
  35  *
  36  * This file declares the common C API functions. These include connect,
  37  * disconnect and utility functions as well as the low-level vapi_send and
  38  * vapi_recv API. This is only the transport layer.
  39  *
  40  * Message formats and higher-level APIs are generated by running the
  41  * vapi_c_gen.py script (which is run for in-tree APIs as part of the build
  42  * process). It's not recommended to mix the higher and lower level APIs. Due
  43  * to version issues, the higher-level APIs are not part of the shared library.
  44  */
  45   typedef struct vapi_ctx_s *vapi_ctx_t;
  46
  47 /**
  48  * @brief allocate vapi message of given size
  49  *
  50  * @note message must be freed by vapi_msg_free if not consumed by vapi_send
  51  * call
  52  *
  53  * @param ctx opaque vapi context
  54  *
  55  * @return pointer to message or NULL if out of memory
  56  */
  57   void *vapi_msg_alloc (vapi_ctx_t ctx, size_t size);
  58
  59 /**
  60  * @brief free a vapi message
  61  *
  62  * @note messages received by vapi_recv must be freed when no longer needed
  63  *
  64  * @param ctx opaque vapi context
  65  * @param msg message to be freed
  66  */
  67   void vapi_msg_free (vapi_ctx_t ctx, void *msg);
  68
  69 /**
  70  * @brief allocate vapi context
  71  *
  72  * @param[out] pointer to result variable
  73  *
  74  * @return VAPI_OK on success, other error code on error
  75  */
  76   vapi_error_e vapi_ctx_alloc (vapi_ctx_t * result);
  77
  78 /**
  79  * @brief free vapi context
  80  */
  81   void vapi_ctx_free (vapi_ctx_t ctx);
  82
  83 /**
  84  * @brief check if message identified by it's message id is known by the vpp to
  85  * which the connection is open
  86  */
  87   bool vapi_is_msg_available (vapi_ctx_t ctx, vapi_msg_id_t type);
  88
  89 /**
  90  * @brief connect to vpp
  91  *
  92  * @param ctx opaque vapi context, must be allocated using vapi_ctx_alloc first
  93  * @param name application name
  94  * @param chroot_prefix shared memory prefix
  95  * @param max_outstanding_requests max number of outstanding requests queued
  96  * @param response_queue_size size of the response queue
  97  * @param mode mode of operation - blocking or nonblocking
  98  *
  99  * @return VAPI_OK on success, other error code on error
 100  */
 101   vapi_error_e vapi_connect (vapi_ctx_t ctx, const char *name,
 102                              const char *chroot_prefix,
 103                              int max_outstanding_requests,
 104                              int response_queue_size, vapi_mode_e mode);
 105
 106 /**
 107  * @brief disconnect from vpp
 108  *
 109  * @param ctx opaque vapi context
 110  *
 111  * @return VAPI_OK on success, other error code on error
 112  */
 113   vapi_error_e vapi_disconnect (vapi_ctx_t ctx);
 114
 115 /**
 116  * @brief get event file descriptor
 117  *
 118  * @note this file descriptor becomes readable when messages (from vpp)
 119  * are waiting in queue
 120  *
 121  * @param ctx opaque vapi context
 122  * @param[out] fd pointer to result variable
 123  *
 124  * @return VAPI_OK on success, other error code on error
 125  */
 126   vapi_error_e vapi_get_fd (vapi_ctx_t ctx, int *fd);
 127
 128 /**
 129  * @brief low-level api for sending messages to vpp
 130  *
 131  * @note it is not recommended to use this api directly, use generated api
 132  * instead
 133  *
 134  * @param ctx opaque vapi context
 135  * @param msg message to send
 136  *
 137  * @return VAPI_OK on success, other error code on error
 138  */
 139   vapi_error_e vapi_send (vapi_ctx_t ctx, void *msg);
 140
 141 /**
 142  * @brief low-level api for atomically sending two messages to vpp - either
 143  * both messages are sent or neither one is
 144  *
 145  * @note it is not recommended to use this api directly, use generated api
 146  * instead
 147  *
 148  * @param ctx opaque vapi context
 149  * @param msg1 first message to send
 150  * @param msg2 second message to send
 151  *
 152  * @return VAPI_OK on success, other error code on error
 153  */
 154   vapi_error_e vapi_send2 (vapi_ctx_t ctx, void *msg1, void *msg2);
 155
 156 /**
 157  * @brief low-level api for reading messages from vpp
 158  *
 159  * @note it is not recommended to use this api directly, use generated api
 160  * instead
 161  *
 162  * @param ctx opaque vapi context
 163  * @param[out] msg pointer to result variable containing message
 164  * @param[out] msg_size pointer to result variable containing message size
 165  *
 166  * @return VAPI_OK on success, other error code on error
 167  */
 168   vapi_error_e vapi_recv (vapi_ctx_t ctx, void **msg, size_t * msg_size);
 169
 170 /**
 171  * @brief wait for connection to become readable or writable
 172  *
 173  * @param ctx opaque vapi context
 174  * @param mode type of property to wait for - readability, writability or both
 175  *
 176  * @return VAPI_OK on success, other error code on error
 177  */
 178   vapi_error_e vapi_wait (vapi_ctx_t ctx, vapi_wait_mode_e mode);
 179
 180 /**
 181  * @brief pick next message sent by vpp and call the appropriate callback
 182  *
 183  * @return VAPI_OK on success, other error code on error
 184  */
 185   vapi_error_e vapi_dispatch_one (vapi_ctx_t ctx);
 186
 187 /**
 188  * @brief loop vapi_dispatch_one until responses to all currently outstanding
 189  * requests have been received and their callbacks called
 190  *
 191  * @note the dispatch loop is interrupted if any error is encountered or
 192  * returned from the callback, in which case this error is returned as the
 193  * result of vapi_dispatch. In this case it might be necessary to call dispatch
 194  * again to process the remaining messages. Returning VAPI_EUSER from
 195  * a callback allows the user to break the dispatch loop (and distinguish
 196  * this case in the calling code from other failures). VAPI never returns
 197  * VAPI_EUSER on its own.
 198  *
 199  * @return VAPI_OK on success, other error code on error
 200  */
 201   vapi_error_e vapi_dispatch (vapi_ctx_t ctx);
 202
 203 /** generic vapi event callback */
 204   typedef vapi_error_e (*vapi_event_cb) (vapi_ctx_t ctx, void *callback_ctx,
 205                                          void *payload);
 206
 207 /**
 208  * @brief set event callback to call when message with given id is dispatched
 209  *
 210  * @param ctx opaque vapi context
 211  * @param id message id
 212  * @param callback callback
 213  * @param callback_ctx context pointer stored and passed to callback
 214  */
 215   void vapi_set_event_cb (vapi_ctx_t ctx, vapi_msg_id_t id,
 216                           vapi_event_cb callback, void *callback_ctx);
 217
 218 /**
 219  * @brief clear event callback for given message id
 220  *
 221  * @param ctx opaque vapi context
 222  * @param id message id
 223  */
 224   void vapi_clear_event_cb (vapi_ctx_t ctx, vapi_msg_id_t id);
 225
 226 /** generic vapi event callback */
 227   typedef vapi_error_e (*vapi_generic_event_cb) (vapi_ctx_t ctx,
 228                                                  void *callback_ctx,
 229                                                  vapi_msg_id_t id, void *msg);
 230 /**
 231  * @brief set generic event callback
 232  *
 233  * @note this callback is called by dispatch if no message-type specific
 234  * callback is set (so it's a fallback callback)
 235  *
 236  * @param ctx opaque vapi context
 237  * @param callback callback
 238  * @param callback_ctx context pointer stored and passed to callback
 239  */
 240   void vapi_set_generic_event_cb (vapi_ctx_t ctx,
 241                                   vapi_generic_event_cb callback,
 242                                   void *callback_ctx);
 243
 244 /**
 245  * @brief clear generic event callback
 246  *
 247  * @param ctx opaque vapi context
 248  */
 249   void vapi_clear_generic_event_cb (vapi_ctx_t ctx);
 250
 251 #ifdef __cplusplus
 252 }
 253 #endif
 254
 255 #endif
 256
 257 /*
 258  * fd.io coding-style-patch-verification: ON
 259  *
 260  * Local Variables:
 261  * eval: (c-set-style "gnu")
 262  * End:
 263  */