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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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 *------------------------------------------------------------------
18 #ifndef vpp_api_h_included
19 #define vpp_api_h_included
23 #include <vppinfra/types.h>
24 #include <vlibapi/api_types.h>
25 #include <vapi/vapi_common.h>
26 #include <svm/queue.h>
36 * common vpp api C declarations
38 * This file declares the common C API functions. These include connect,
39 * disconnect and utility functions as well as the low-level vapi_send and
40 * vapi_recv API. This is only the transport layer.
42 * Message formats and higher-level APIs are generated by running the
43 * vapi_c_gen.py script (which is run for in-tree APIs as part of the build
44 * process). It's not recommended to mix the higher and lower level APIs. Due
45 * to version issues, the higher-level APIs are not part of the shared library.
47 typedef struct vapi_ctx_s *vapi_ctx_t;
50 * @brief allocate vapi message of given size
52 * @note message must be freed by vapi_msg_free if not consumed by vapi_send
55 * @param ctx opaque vapi context
57 * @return pointer to message or NULL if out of memory
59 void *vapi_msg_alloc (vapi_ctx_t ctx, size_t size);
62 * @brief free a vapi message
64 * @note messages received by vapi_recv must be freed when no longer needed
66 * @param ctx opaque vapi context
67 * @param msg message to be freed
69 void vapi_msg_free (vapi_ctx_t ctx, void *msg);
72 * @brief allocate vapi context
74 * @param[out] pointer to result variable
76 * @return VAPI_OK on success, other error code on error
78 vapi_error_e vapi_ctx_alloc (vapi_ctx_t * result);
81 * @brief free vapi context
83 void vapi_ctx_free (vapi_ctx_t ctx);
86 * @brief check if message identified by it's message id is known by the vpp to
87 * which the connection is open
89 bool vapi_is_msg_available (vapi_ctx_t ctx, vapi_msg_id_t type);
92 * @brief connect to vpp
94 * @param ctx opaque vapi context, must be allocated using vapi_ctx_alloc first
95 * @param name application name
96 * @param chroot_prefix shared memory prefix
97 * @param max_outstanding_requests max number of outstanding requests queued
98 * @param response_queue_size size of the response queue
99 * @param mode mode of operation - blocking or nonblocking
100 * @param handle_keepalives - if true, automatically handle memclnt_keepalive
102 * @return VAPI_OK on success, other error code on error
104 vapi_error_e vapi_connect (vapi_ctx_t ctx, const char *name,
105 const char *chroot_prefix,
106 int max_outstanding_requests,
107 int response_queue_size, vapi_mode_e mode,
108 bool handle_keepalives);
111 * @brief disconnect from vpp
113 * @param ctx opaque vapi context
115 * @return VAPI_OK on success, other error code on error
117 vapi_error_e vapi_disconnect (vapi_ctx_t ctx);
120 * @brief get event file descriptor
122 * @note this file descriptor becomes readable when messages (from vpp)
123 * are waiting in queue
125 * @param ctx opaque vapi context
126 * @param[out] fd pointer to result variable
128 * @return VAPI_OK on success, other error code on error
130 vapi_error_e vapi_get_fd (vapi_ctx_t ctx, int *fd);
133 * @brief low-level api for sending messages to vpp
135 * @note it is not recommended to use this api directly, use generated api
138 * @param ctx opaque vapi context
139 * @param msg message to send
141 * @return VAPI_OK on success, other error code on error
143 vapi_error_e vapi_send (vapi_ctx_t ctx, void *msg);
146 * @brief low-level api for atomically sending two messages to vpp - either
147 * both messages are sent or neither one is
149 * @note it is not recommended to use this api directly, use generated api
152 * @param ctx opaque vapi context
153 * @param msg1 first message to send
154 * @param msg2 second message to send
156 * @return VAPI_OK on success, other error code on error
158 vapi_error_e vapi_send2 (vapi_ctx_t ctx, void *msg1, void *msg2);
161 * @brief low-level api for reading messages from vpp
163 * @note it is not recommended to use this api directly, use generated api
166 * @param ctx opaque vapi context
167 * @param[out] msg pointer to result variable containing message
168 * @param[out] msg_size pointer to result variable containing message size
169 * @param cond enum type for blocking, non-blocking or timed wait call
170 * @param time in sec for timed wait
172 * @return VAPI_OK on success, other error code on error
174 vapi_error_e vapi_recv (vapi_ctx_t ctx, void **msg, size_t * msg_size,
175 svm_q_conditional_wait_t cond, u32 time);
178 * @brief wait for connection to become readable or writable
180 * @param ctx opaque vapi context
181 * @param mode type of property to wait for - readability, writability or both
183 * @return VAPI_OK on success, other error code on error
185 vapi_error_e vapi_wait (vapi_ctx_t ctx, vapi_wait_mode_e mode);
188 * @brief pick next message sent by vpp and call the appropriate callback
190 * @return VAPI_OK on success, other error code on error
192 vapi_error_e vapi_dispatch_one (vapi_ctx_t ctx);
195 * @brief loop vapi_dispatch_one until responses to all currently outstanding
196 * requests have been received and their callbacks called
198 * @note the dispatch loop is interrupted if any error is encountered or
199 * returned from the callback, in which case this error is returned as the
200 * result of vapi_dispatch. In this case it might be necessary to call dispatch
201 * again to process the remaining messages. Returning VAPI_EUSER from
202 * a callback allows the user to break the dispatch loop (and distinguish
203 * this case in the calling code from other failures). VAPI never returns
204 * VAPI_EUSER on its own.
206 * @return VAPI_OK on success, other error code on error
208 vapi_error_e vapi_dispatch (vapi_ctx_t ctx);
210 /** generic vapi event callback */
211 typedef vapi_error_e (*vapi_event_cb) (vapi_ctx_t ctx, void *callback_ctx,
215 * @brief set event callback to call when message with given id is dispatched
217 * @param ctx opaque vapi context
218 * @param id message id
219 * @param callback callback
220 * @param callback_ctx context pointer stored and passed to callback
222 void vapi_set_event_cb (vapi_ctx_t ctx, vapi_msg_id_t id,
223 vapi_event_cb callback, void *callback_ctx);
226 * @brief clear event callback for given message id
228 * @param ctx opaque vapi context
229 * @param id message id
231 void vapi_clear_event_cb (vapi_ctx_t ctx, vapi_msg_id_t id);
233 /** generic vapi event callback */
234 typedef vapi_error_e (*vapi_generic_event_cb) (vapi_ctx_t ctx,
236 vapi_msg_id_t id, void *msg);
238 * @brief set generic event callback
240 * @note this callback is called by dispatch if no message-type specific
241 * callback is set (so it's a fallback callback)
243 * @param ctx opaque vapi context
244 * @param callback callback
245 * @param callback_ctx context pointer stored and passed to callback
247 void vapi_set_generic_event_cb (vapi_ctx_t ctx,
248 vapi_generic_event_cb callback,
252 * @brief clear generic event callback
254 * @param ctx opaque vapi context
256 void vapi_clear_generic_event_cb (vapi_ctx_t ctx);
265 * fd.io coding-style-patch-verification: ON
268 * eval: (c-set-style "gnu")