blob: 78c05c34431a32ae8cca76102a213884fd750bb4 [file] [log] [blame]
Dave Barach68b0fb02017-02-28 15:15:56 -05001/*
2 * Copyright (c) 2015-2016 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <vnet/vnet.h>
17#include <vlibmemory/api.h>
18#include <vnet/session/application.h>
Florin Coras1c710452017-10-17 00:03:13 -070019#include <vnet/session/application_interface.h>
20#include <vnet/session/session_rules_table.h>
Florin Coras6c36f532017-11-03 18:32:34 -070021#include <vnet/session/session_table.h>
Dave Barach68b0fb02017-02-28 15:15:56 -050022
23#include <vnet/vnet_msg_enum.h>
Dave Barach68b0fb02017-02-28 15:15:56 -050024
25#define vl_typedefs /* define message structures */
26#include <vnet/vnet_all_api_h.h>
27#undef vl_typedefs
28
29#define vl_endianfun /* define message structures */
30#include <vnet/vnet_all_api_h.h>
31#undef vl_endianfun
32
33/* instantiate all the print functions we know about */
34#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
35#define vl_printfun
36#include <vnet/vnet_all_api_h.h>
37#undef vl_printfun
38
39#include <vlibapi/api_helper_macros.h>
40
41#define foreach_session_api_msg \
42_(MAP_ANOTHER_SEGMENT_REPLY, map_another_segment_reply) \
Florin Coras6cf30ad2017-04-04 23:08:23 -070043_(APPLICATION_ATTACH, application_attach) \
44_(APPLICATION_DETACH, application_detach) \
Dave Barach68b0fb02017-02-28 15:15:56 -050045_(BIND_URI, bind_uri) \
46_(UNBIND_URI, unbind_uri) \
47_(CONNECT_URI, connect_uri) \
48_(DISCONNECT_SESSION, disconnect_session) \
49_(DISCONNECT_SESSION_REPLY, disconnect_session_reply) \
50_(ACCEPT_SESSION_REPLY, accept_session_reply) \
51_(RESET_SESSION_REPLY, reset_session_reply) \
Florin Corascea194d2017-10-02 00:18:51 -070052_(BIND_SOCK, bind_sock) \
Dave Barach68b0fb02017-02-28 15:15:56 -050053_(UNBIND_SOCK, unbind_sock) \
54_(CONNECT_SOCK, connect_sock) \
Florin Corase04c2992017-03-01 08:17:34 -080055_(SESSION_ENABLE_DISABLE, session_enable_disable) \
Florin Corascea194d2017-10-02 00:18:51 -070056_(APP_NAMESPACE_ADD_DEL, app_namespace_add_del) \
Florin Coras1c710452017-10-17 00:03:13 -070057_(SESSION_RULE_ADD_DEL, session_rule_add_del) \
Florin Coras6c36f532017-11-03 18:32:34 -070058_(SESSION_RULES_DUMP, session_rules_dump) \
Florin Coras371ca502018-02-21 12:07:41 -080059_(APPLICATION_TLS_CERT_ADD, application_tls_cert_add) \
60_(APPLICATION_TLS_KEY_ADD, application_tls_key_add) \
Florin Coras15531972018-08-12 23:50:53 -070061_(APP_WORKER_ADD_DEL, app_worker_add_del) \
Florin Corase04c2992017-03-01 08:17:34 -080062
Dave Barach68b0fb02017-02-28 15:15:56 -050063static int
Florin Coras99368312018-08-02 10:45:44 -070064session_send_fds (vl_api_registration_t * reg, int fds[], int n_fds)
Florin Corasb384b542018-01-15 01:08:33 -080065{
66 clib_error_t *error;
67 if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
68 {
69 clib_warning ("can't send memfd fd");
70 return -1;
71 }
Florin Coras99368312018-08-02 10:45:44 -070072 error = vl_api_send_fd_msg (reg, fds, n_fds);
Florin Corasb384b542018-01-15 01:08:33 -080073 if (error)
74 {
75 clib_error_report (error);
76 return -1;
77 }
78 return 0;
79}
80
81static int
82send_add_segment_callback (u32 api_client_index, const ssvm_private_t * sp)
Dave Barach68b0fb02017-02-28 15:15:56 -050083{
Florin Coras99368312018-08-02 10:45:44 -070084 int fds[SESSION_N_FD_TYPE], n_fds = 0;
Dave Barach68b0fb02017-02-28 15:15:56 -050085 vl_api_map_another_segment_t *mp;
Florin Corasb384b542018-01-15 01:08:33 -080086 vl_api_registration_t *reg;
Florin Coras99368312018-08-02 10:45:44 -070087 u8 fd_flags = 0;
Dave Barach68b0fb02017-02-28 15:15:56 -050088
Florin Corasb384b542018-01-15 01:08:33 -080089 reg = vl_mem_api_client_index_to_registration (api_client_index);
90 if (!reg)
91 {
92 clib_warning ("no registration: %u", api_client_index);
93 return -1;
94 }
Dave Barach68b0fb02017-02-28 15:15:56 -050095
Florin Coras99368312018-08-02 10:45:44 -070096 if (ssvm_type (sp) == SSVM_SEGMENT_MEMFD)
Florin Corasb384b542018-01-15 01:08:33 -080097 {
Florin Coras99368312018-08-02 10:45:44 -070098 if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
99 {
100 clib_warning ("can't send memfd fd");
101 return -1;
102 }
103
104 fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
105 fds[n_fds] = sp->fd;
106 n_fds += 1;
Florin Corasb384b542018-01-15 01:08:33 -0800107 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500108
Florin Coras99368312018-08-02 10:45:44 -0700109 mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
Dave Barach68b0fb02017-02-28 15:15:56 -0500110 memset (mp, 0, sizeof (*mp));
111 mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MAP_ANOTHER_SEGMENT);
Florin Corasb384b542018-01-15 01:08:33 -0800112 mp->segment_size = sp->ssvm_size;
Florin Coras99368312018-08-02 10:45:44 -0700113 mp->fd_flags = fd_flags;
Florin Corasb384b542018-01-15 01:08:33 -0800114 strncpy ((char *) mp->segment_name, (char *) sp->name,
Dave Barach68b0fb02017-02-28 15:15:56 -0500115 sizeof (mp->segment_name) - 1);
116
Florin Corasb384b542018-01-15 01:08:33 -0800117 vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
118
Florin Coras99368312018-08-02 10:45:44 -0700119 if (n_fds)
120 return session_send_fds (reg, fds, n_fds);
Dave Barach68b0fb02017-02-28 15:15:56 -0500121
122 return 0;
123}
124
125static int
Florin Corasf8f516a2018-02-08 15:10:09 -0800126send_del_segment_callback (u32 api_client_index, const ssvm_private_t * fs)
127{
128 vl_api_unmap_segment_t *mp;
129 vl_api_registration_t *reg;
130
131 reg = vl_mem_api_client_index_to_registration (api_client_index);
132 if (!reg)
133 {
134 clib_warning ("no registration: %u", api_client_index);
135 return -1;
136 }
137
Florin Coras99368312018-08-02 10:45:44 -0700138 mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
Florin Corasf8f516a2018-02-08 15:10:09 -0800139 memset (mp, 0, sizeof (*mp));
140 mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_UNMAP_SEGMENT);
Florin Coras15531972018-08-12 23:50:53 -0700141 strncpy ((char *) mp->segment_name, (char *) fs->name,
142 sizeof (mp->segment_name) - 1);
Florin Corasf8f516a2018-02-08 15:10:09 -0800143
144 vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
145
Florin Coras99368312018-08-02 10:45:44 -0700146 return 0;
147}
148
149static int
Florin Coras134a9962018-08-28 11:32:04 -0700150send_app_cut_through_registration_add (u32 api_client_index,
151 u32 wrk_map_index, u64 mq_addr,
Florin Coras99368312018-08-02 10:45:44 -0700152 u64 peer_mq_addr)
153{
154 vl_api_app_cut_through_registration_add_t *mp;
155 vl_api_registration_t *reg;
156 svm_msg_q_t *mq, *peer_mq;
157 int fds[2];
158
159 reg = vl_mem_api_client_index_to_registration (api_client_index);
160 if (!reg)
161 {
162 clib_warning ("no registration: %u", api_client_index);
163 return -1;
164 }
165
166 mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
167 memset (mp, 0, sizeof (*mp));
168 mp->_vl_msg_id =
169 clib_host_to_net_u16 (VL_API_APP_CUT_THROUGH_REGISTRATION_ADD);
170
171 mp->evt_q_address = mq_addr;
172 mp->peer_evt_q_address = peer_mq_addr;
Florin Coras134a9962018-08-28 11:32:04 -0700173 mp->wrk_index = wrk_map_index;
Florin Coras99368312018-08-02 10:45:44 -0700174
175 mq = uword_to_pointer (mq_addr, svm_msg_q_t *);
176 peer_mq = uword_to_pointer (peer_mq_addr, svm_msg_q_t *);
177
178 if (svm_msg_q_get_producer_eventfd (mq) != -1)
179 {
180 mp->fd_flags |= SESSION_FD_F_MQ_EVENTFD;
181 mp->n_fds = 2;
182 /* app will overwrite exactly the fds we pass here. So
183 * when we swap mq with peer_mq (accept vs connect) the
184 * fds will still be valid */
185 fds[0] = svm_msg_q_get_consumer_eventfd (mq);
186 fds[1] = svm_msg_q_get_producer_eventfd (peer_mq);
187 }
188
189 vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
190
191 if (mp->n_fds != 0)
192 session_send_fds (reg, fds, mp->n_fds);
Florin Corasf8f516a2018-02-08 15:10:09 -0800193
194 return 0;
195}
196
197static int
Florin Coras6cf30ad2017-04-04 23:08:23 -0700198send_session_accept_callback (stream_session_t * s)
Dave Barach68b0fb02017-02-28 15:15:56 -0500199{
Florin Coras15531972018-08-12 23:50:53 -0700200 app_worker_t *server_wrk = app_worker_get (s->app_wrk_index);
Florin Coras6cf30ad2017-04-04 23:08:23 -0700201 transport_proto_vft_t *tp_vft;
Florin Corasb384b542018-01-15 01:08:33 -0800202 vl_api_accept_session_t *mp;
203 vl_api_registration_t *reg;
204 transport_connection_t *tc;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700205 stream_session_t *listener;
Florin Coras3c2fed52018-07-04 04:15:05 -0700206 svm_msg_q_t *vpp_queue;
Florin Coras15531972018-08-12 23:50:53 -0700207 application_t *server;
Dave Barach68b0fb02017-02-28 15:15:56 -0500208
Florin Coras15531972018-08-12 23:50:53 -0700209 server = application_get (server_wrk->app_index);
Florin Corasb384b542018-01-15 01:08:33 -0800210 reg = vl_mem_api_client_index_to_registration (server->api_client_index);
211 if (!reg)
212 {
213 clib_warning ("no registration: %u", server->api_client_index);
214 return -1;
215 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500216
Florin Corasb384b542018-01-15 01:08:33 -0800217 mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
Florin Coras6cf30ad2017-04-04 23:08:23 -0700218 memset (mp, 0, sizeof (*mp));
219
Dave Barach68b0fb02017-02-28 15:15:56 -0500220 mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_ACCEPT_SESSION);
Florin Coras15531972018-08-12 23:50:53 -0700221 mp->context = server_wrk->wrk_index;
Damjan Marion7bee80c2017-04-26 15:32:12 +0200222 mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo);
223 mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo);
Florin Corasf8f516a2018-02-08 15:10:09 -0800224
225 if (session_has_transport (s))
226 {
Florin Coras5c9083d2018-04-13 06:39:07 -0700227 listener = listen_session_get (s->listener_index);
Florin Corasf8f516a2018-02-08 15:10:09 -0800228 mp->listener_handle = listen_session_get_handle (listener);
229 if (application_is_proxy (server))
230 {
231 listener =
Florin Coras15531972018-08-12 23:50:53 -0700232 app_worker_first_listener (server_wrk, session_get_fib_proto (s),
233 session_get_transport_proto (s));
Florin Corasf8f516a2018-02-08 15:10:09 -0800234 if (listener)
235 mp->listener_handle = listen_session_get_handle (listener);
236 }
237 vpp_queue = session_manager_get_vpp_event_queue (s->thread_index);
238 mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
239 mp->handle = session_handle (s);
240 tp_vft = transport_protocol_get_vft (session_get_transport_proto (s));
241 tc = tp_vft->get_connection (s->connection_index, s->thread_index);
242 mp->port = tc->rmt_port;
243 mp->is_ip4 = tc->is_ip4;
244 clib_memcpy (&mp->ip, &tc->rmt_ip, sizeof (tc->rmt_ip));
245 }
246 else
247 {
248 local_session_t *ls = (local_session_t *) s;
249 local_session_t *ll;
250 if (application_local_session_listener_has_transport (ls))
251 {
Florin Coras5c9083d2018-04-13 06:39:07 -0700252 listener = listen_session_get (ls->listener_index);
Florin Corasf8f516a2018-02-08 15:10:09 -0800253 mp->listener_handle = listen_session_get_handle (listener);
Florin Coras5fda7a32018-02-14 08:04:31 -0800254 mp->is_ip4 = session_type_is_ip4 (listener->session_type);
Florin Corasf8f516a2018-02-08 15:10:09 -0800255 }
256 else
257 {
Florin Coras15531972018-08-12 23:50:53 -0700258 ll = application_get_local_listen_session (server_wrk,
Florin Corasf8f516a2018-02-08 15:10:09 -0800259 ls->listener_index);
Florin Coras5fda7a32018-02-14 08:04:31 -0800260 if (ll->transport_listener_index != ~0)
261 {
Florin Coras5c9083d2018-04-13 06:39:07 -0700262 listener = listen_session_get (ll->transport_listener_index);
Florin Coras5fda7a32018-02-14 08:04:31 -0800263 mp->listener_handle = listen_session_get_handle (listener);
264 }
265 else
266 {
267 mp->listener_handle = application_local_session_handle (ll);
268 }
269 mp->is_ip4 = session_type_is_ip4 (ll->listener_session_type);
Florin Corasf8f516a2018-02-08 15:10:09 -0800270 }
271 mp->handle = application_local_session_handle (ls);
272 mp->port = ls->port;
273 mp->vpp_event_queue_address = ls->client_evt_q;
274 mp->server_event_queue_address = ls->server_evt_q;
275 }
Florin Corasb384b542018-01-15 01:08:33 -0800276 vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
Dave Barach68b0fb02017-02-28 15:15:56 -0500277
278 return 0;
279}
280
Florin Corasf8f516a2018-02-08 15:10:09 -0800281void
Florin Coras15531972018-08-12 23:50:53 -0700282mq_send_local_session_disconnected_cb (u32 app_wrk_index,
283 local_session_t * ls)
Florin Corasf8f516a2018-02-08 15:10:09 -0800284{
Florin Coras15531972018-08-12 23:50:53 -0700285 app_worker_t *app_wrk = app_worker_get (app_wrk_index);
Florin Coras99368312018-08-02 10:45:44 -0700286 svm_msg_q_msg_t _msg, *msg = &_msg;
287 session_disconnected_msg_t *mp;
288 svm_msg_q_t *app_mq;
289 session_event_t *evt;
Florin Coras15531972018-08-12 23:50:53 -0700290 application_t *app;
Florin Corasf8f516a2018-02-08 15:10:09 -0800291
Florin Coras15531972018-08-12 23:50:53 -0700292 app = application_get (app_wrk->app_index);
293 app_mq = app_wrk->event_queue;
Florin Coras99368312018-08-02 10:45:44 -0700294 svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
295 SVM_Q_WAIT, msg);
296 svm_msg_q_unlock (app_mq);
297 evt = svm_msg_q_msg_data (app_mq, msg);
298 memset (evt, 0, sizeof (*evt));
299 evt->event_type = SESSION_CTRL_EVT_DISCONNECTED;
300 mp = (session_disconnected_msg_t *) evt->data;
Florin Corasf8f516a2018-02-08 15:10:09 -0800301 mp->handle = application_local_session_handle (ls);
302 mp->context = app->api_client_index;
Florin Coras99368312018-08-02 10:45:44 -0700303 svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
Florin Corasf8f516a2018-02-08 15:10:09 -0800304}
305
Dave Barach68b0fb02017-02-28 15:15:56 -0500306static void
Florin Coras6cf30ad2017-04-04 23:08:23 -0700307send_session_disconnect_callback (stream_session_t * s)
Dave Barach68b0fb02017-02-28 15:15:56 -0500308{
Florin Coras15531972018-08-12 23:50:53 -0700309 app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
Florin Corasb384b542018-01-15 01:08:33 -0800310 vl_api_disconnect_session_t *mp;
311 vl_api_registration_t *reg;
Florin Coras15531972018-08-12 23:50:53 -0700312 application_t *app;
Dave Barach68b0fb02017-02-28 15:15:56 -0500313
Florin Coras15531972018-08-12 23:50:53 -0700314 app = application_get (app_wrk->app_index);
Florin Corasb384b542018-01-15 01:08:33 -0800315 reg = vl_mem_api_client_index_to_registration (app->api_client_index);
316 if (!reg)
317 {
318 clib_warning ("no registration: %u", app->api_client_index);
319 return;
320 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500321
Florin Corasb384b542018-01-15 01:08:33 -0800322 mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
Dave Barach68b0fb02017-02-28 15:15:56 -0500323 memset (mp, 0, sizeof (*mp));
324 mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_DISCONNECT_SESSION);
Florin Coras3cbc04b2017-10-02 00:18:51 -0700325 mp->handle = session_handle (s);
Florin Corasf8f516a2018-02-08 15:10:09 -0800326 mp->context = app->api_client_index;
Florin Corasb384b542018-01-15 01:08:33 -0800327 vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
Dave Barach68b0fb02017-02-28 15:15:56 -0500328}
329
Florin Corasd79b41e2017-03-04 05:37:52 -0800330static void
Florin Coras6cf30ad2017-04-04 23:08:23 -0700331send_session_reset_callback (stream_session_t * s)
Florin Corasd79b41e2017-03-04 05:37:52 -0800332{
Florin Coras15531972018-08-12 23:50:53 -0700333 app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
Florin Corasb384b542018-01-15 01:08:33 -0800334 vl_api_registration_t *reg;
335 vl_api_reset_session_t *mp;
Florin Coras15531972018-08-12 23:50:53 -0700336 application_t *app;
Florin Corasd79b41e2017-03-04 05:37:52 -0800337
Florin Coras15531972018-08-12 23:50:53 -0700338 app = application_get (app_wrk->app_index);
Florin Corasb384b542018-01-15 01:08:33 -0800339 reg = vl_mem_api_client_index_to_registration (app->api_client_index);
340 if (!reg)
341 {
342 clib_warning ("no registration: %u", app->api_client_index);
343 return;
344 }
Florin Corasd79b41e2017-03-04 05:37:52 -0800345
Florin Corasb384b542018-01-15 01:08:33 -0800346 mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
Florin Corasd79b41e2017-03-04 05:37:52 -0800347 memset (mp, 0, sizeof (*mp));
348 mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_RESET_SESSION);
Florin Coras3cbc04b2017-10-02 00:18:51 -0700349 mp->handle = session_handle (s);
Florin Corasb384b542018-01-15 01:08:33 -0800350 vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
Florin Corasd79b41e2017-03-04 05:37:52 -0800351}
352
Dave Barach0194f1a2017-05-15 10:11:39 -0400353int
Florin Coras15531972018-08-12 23:50:53 -0700354send_session_connected_callback (u32 app_wrk_index, u32 api_context,
Florin Coras6cf30ad2017-04-04 23:08:23 -0700355 stream_session_t * s, u8 is_fail)
Dave Barach68b0fb02017-02-28 15:15:56 -0500356{
Dave Wallace33e002b2017-09-06 01:20:02 -0400357 vl_api_connect_session_reply_t *mp;
Florin Corasade70e42017-10-14 18:56:41 -0700358 transport_connection_t *tc;
Florin Corasb384b542018-01-15 01:08:33 -0800359 vl_api_registration_t *reg;
Florin Coras3c2fed52018-07-04 04:15:05 -0700360 svm_msg_q_t *vpp_queue;
Florin Coras15531972018-08-12 23:50:53 -0700361 app_worker_t *app_wrk;
Florin Corasb384b542018-01-15 01:08:33 -0800362 application_t *app;
Dave Barach68b0fb02017-02-28 15:15:56 -0500363
Florin Coras15531972018-08-12 23:50:53 -0700364 app_wrk = app_worker_get (app_wrk_index);
365 app = application_get (app_wrk->app_index);
Florin Corasb384b542018-01-15 01:08:33 -0800366 reg = vl_mem_api_client_index_to_registration (app->api_client_index);
367 if (!reg)
368 {
369 clib_warning ("no registration: %u", app->api_client_index);
370 return -1;
371 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500372
Florin Corasb384b542018-01-15 01:08:33 -0800373 mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
Dave Wallace33e002b2017-09-06 01:20:02 -0400374 mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_CONNECT_SESSION_REPLY);
Florin Coras6cf30ad2017-04-04 23:08:23 -0700375 mp->context = api_context;
Dave Wallace965fec92017-10-17 16:19:41 -0400376
377 if (is_fail)
378 goto done;
379
Florin Corasf8f516a2018-02-08 15:10:09 -0800380 if (session_has_transport (s))
Dave Barach68b0fb02017-02-28 15:15:56 -0500381 {
Florin Corasf8f516a2018-02-08 15:10:09 -0800382 tc = session_get_transport (s);
383 if (!tc)
384 {
385 is_fail = 1;
386 goto done;
387 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500388
Florin Corasf8f516a2018-02-08 15:10:09 -0800389 vpp_queue = session_manager_get_vpp_event_queue (s->thread_index);
390 mp->handle = session_handle (s);
391 mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
392 clib_memcpy (mp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip));
393 mp->is_ip4 = tc->is_ip4;
394 mp->lcl_port = tc->lcl_port;
395 mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo);
396 mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo);
397 }
398 else
399 {
400 local_session_t *ls = (local_session_t *) s;
401 mp->handle = application_local_session_handle (ls);
402 mp->lcl_port = ls->port;
403 mp->vpp_event_queue_address = ls->server_evt_q;
404 mp->client_event_queue_address = ls->client_evt_q;
405 mp->server_rx_fifo = pointer_to_uword (s->server_tx_fifo);
406 mp->server_tx_fifo = pointer_to_uword (s->server_rx_fifo);
407 }
Dave Wallace965fec92017-10-17 16:19:41 -0400408
409done:
410 mp->retval = is_fail ?
411 clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT) : 0;
Florin Corasb384b542018-01-15 01:08:33 -0800412 vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
Dave Barach68b0fb02017-02-28 15:15:56 -0500413 return 0;
414}
415
Florin Corascea194d2017-10-02 00:18:51 -0700416static session_cb_vft_t session_cb_vft = {
Dave Barach68b0fb02017-02-28 15:15:56 -0500417 .session_accept_callback = send_session_accept_callback,
418 .session_disconnect_callback = send_session_disconnect_callback,
419 .session_connected_callback = send_session_connected_callback,
Florin Corasd79b41e2017-03-04 05:37:52 -0800420 .session_reset_callback = send_session_reset_callback,
Dave Barach68b0fb02017-02-28 15:15:56 -0500421 .add_segment_callback = send_add_segment_callback,
Florin Corasf8f516a2018-02-08 15:10:09 -0800422 .del_segment_callback = send_del_segment_callback,
Dave Barach68b0fb02017-02-28 15:15:56 -0500423};
424
Florin Coras52207f12018-07-12 14:48:06 -0700425static int
426mq_send_session_accepted_cb (stream_session_t * s)
427{
Florin Coras15531972018-08-12 23:50:53 -0700428 app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
Florin Coras52207f12018-07-12 14:48:06 -0700429 svm_msg_q_msg_t _msg, *msg = &_msg;
430 svm_msg_q_t *vpp_queue, *app_mq;
431 transport_proto_vft_t *tp_vft;
432 transport_connection_t *tc;
433 stream_session_t *listener;
434 session_accepted_msg_t *mp;
435 session_event_t *evt;
Florin Coras15531972018-08-12 23:50:53 -0700436 application_t *app;
Florin Coras52207f12018-07-12 14:48:06 -0700437
Florin Coras15531972018-08-12 23:50:53 -0700438 app = application_get (app_wrk->app_index);
439 app_mq = app_wrk->event_queue;
Florin Coras52207f12018-07-12 14:48:06 -0700440 svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
441 SVM_Q_WAIT, msg);
442 svm_msg_q_unlock (app_mq);
443
444 evt = svm_msg_q_msg_data (app_mq, msg);
445 memset (evt, 0, sizeof (*evt));
446 evt->event_type = SESSION_CTRL_EVT_ACCEPTED;
447 mp = (session_accepted_msg_t *) evt->data;
Florin Coras15531972018-08-12 23:50:53 -0700448 mp->context = app_wrk->wrk_index;
Florin Coras52207f12018-07-12 14:48:06 -0700449 mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo);
450 mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo);
451
452 if (session_has_transport (s))
453 {
454 listener = listen_session_get (s->listener_index);
455 mp->listener_handle = listen_session_get_handle (listener);
456 if (application_is_proxy (app))
457 {
458 listener =
Florin Coras15531972018-08-12 23:50:53 -0700459 app_worker_first_listener (app_wrk, session_get_fib_proto (s),
460 session_get_transport_proto (s));
Florin Coras52207f12018-07-12 14:48:06 -0700461 if (listener)
462 mp->listener_handle = listen_session_get_handle (listener);
463 }
464 vpp_queue = session_manager_get_vpp_event_queue (s->thread_index);
465 mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
466 mp->handle = session_handle (s);
467 tp_vft = transport_protocol_get_vft (session_get_transport_proto (s));
468 tc = tp_vft->get_connection (s->connection_index, s->thread_index);
469 mp->port = tc->rmt_port;
470 mp->is_ip4 = tc->is_ip4;
471 clib_memcpy (&mp->ip, &tc->rmt_ip, sizeof (tc->rmt_ip));
472 }
473 else
474 {
475 local_session_t *ls = (local_session_t *) s;
476 local_session_t *ll;
Florin Coras99368312018-08-02 10:45:44 -0700477 u8 main_thread = vlib_num_workers ()? 1 : 0;
478
479 send_app_cut_through_registration_add (app->api_client_index,
Florin Coras134a9962018-08-28 11:32:04 -0700480 app_wrk->wrk_map_index,
Florin Coras99368312018-08-02 10:45:44 -0700481 ls->server_evt_q,
482 ls->client_evt_q);
483
Florin Coras52207f12018-07-12 14:48:06 -0700484 if (application_local_session_listener_has_transport (ls))
485 {
486 listener = listen_session_get (ls->listener_index);
487 mp->listener_handle = listen_session_get_handle (listener);
488 mp->is_ip4 = session_type_is_ip4 (listener->session_type);
489 }
490 else
491 {
Florin Coras15531972018-08-12 23:50:53 -0700492 ll =
493 application_get_local_listen_session (app_wrk,
494 ls->listener_index);
Florin Coras52207f12018-07-12 14:48:06 -0700495 if (ll->transport_listener_index != ~0)
496 {
497 listener = listen_session_get (ll->transport_listener_index);
498 mp->listener_handle = listen_session_get_handle (listener);
499 }
500 else
501 {
502 mp->listener_handle = application_local_session_handle (ll);
503 }
504 mp->is_ip4 = session_type_is_ip4 (ll->listener_session_type);
505 }
506 mp->handle = application_local_session_handle (ls);
507 mp->port = ls->port;
Florin Coras99368312018-08-02 10:45:44 -0700508 vpp_queue = session_manager_get_vpp_event_queue (main_thread);
Florin Coras54693d22018-07-17 10:46:29 -0700509 mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
510 mp->client_event_queue_address = ls->client_evt_q;
Florin Coras52207f12018-07-12 14:48:06 -0700511 mp->server_event_queue_address = ls->server_evt_q;
512 }
513 svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
514
515 return 0;
516}
517
518static void
519mq_send_session_disconnected_cb (stream_session_t * s)
520{
Florin Coras15531972018-08-12 23:50:53 -0700521 app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
Florin Coras52207f12018-07-12 14:48:06 -0700522 svm_msg_q_msg_t _msg, *msg = &_msg;
523 session_disconnected_msg_t *mp;
524 svm_msg_q_t *app_mq;
525 session_event_t *evt;
Florin Coras15531972018-08-12 23:50:53 -0700526 application_t *app;
Florin Coras52207f12018-07-12 14:48:06 -0700527
Florin Coras15531972018-08-12 23:50:53 -0700528 app = application_get (app_wrk->app_index);
529 app_mq = app_wrk->event_queue;
Florin Coras52207f12018-07-12 14:48:06 -0700530 svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
531 SVM_Q_WAIT, msg);
532 svm_msg_q_unlock (app_mq);
533 evt = svm_msg_q_msg_data (app_mq, msg);
534 memset (evt, 0, sizeof (*evt));
535 evt->event_type = SESSION_CTRL_EVT_DISCONNECTED;
536 mp = (session_disconnected_msg_t *) evt->data;
537 mp->handle = session_handle (s);
538 mp->context = app->api_client_index;
539 svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
540}
541
542static void
543mq_send_session_reset_cb (stream_session_t * s)
544{
Florin Coras15531972018-08-12 23:50:53 -0700545 app_worker_t *app = app_worker_get (s->app_wrk_index);
Florin Coras52207f12018-07-12 14:48:06 -0700546 svm_msg_q_msg_t _msg, *msg = &_msg;
547 session_reset_msg_t *mp;
548 svm_msg_q_t *app_mq;
549 session_event_t *evt;
550
551 app_mq = app->event_queue;
552 svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
553 SVM_Q_WAIT, msg);
554 svm_msg_q_unlock (app_mq);
555 evt = svm_msg_q_msg_data (app_mq, msg);
556 memset (evt, 0, sizeof (*evt));
557 evt->event_type = SESSION_CTRL_EVT_RESET;
558 mp = (session_reset_msg_t *) evt->data;
559 mp->handle = session_handle (s);
560 svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
561}
562
563static int
Florin Coras15531972018-08-12 23:50:53 -0700564mq_send_session_connected_cb (u32 app_wrk_index, u32 api_context,
Florin Coras52207f12018-07-12 14:48:06 -0700565 stream_session_t * s, u8 is_fail)
566{
567 svm_msg_q_msg_t _msg, *msg = &_msg;
568 session_connected_msg_t *mp;
569 svm_msg_q_t *vpp_mq, *app_mq;
570 transport_connection_t *tc;
Florin Coras15531972018-08-12 23:50:53 -0700571 app_worker_t *app_wrk;
Florin Coras52207f12018-07-12 14:48:06 -0700572 session_event_t *evt;
573 application_t *app;
574
Florin Coras15531972018-08-12 23:50:53 -0700575 app_wrk = app_worker_get (app_wrk_index);
576 app = application_get (app_wrk->app_index);
577 app_mq = app_wrk->event_queue;
Florin Coras52207f12018-07-12 14:48:06 -0700578 if (!app_mq)
579 {
Florin Coras15531972018-08-12 23:50:53 -0700580 clib_warning ("app %u with api index: %u not attached", app->app_index,
Florin Coras52207f12018-07-12 14:48:06 -0700581 app->api_client_index);
582 return -1;
583 }
584
585 svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
586 SVM_Q_WAIT, msg);
587 svm_msg_q_unlock (app_mq);
588 evt = svm_msg_q_msg_data (app_mq, msg);
589 memset (evt, 0, sizeof (*evt));
590 evt->event_type = SESSION_CTRL_EVT_CONNECTED;
591 mp = (session_connected_msg_t *) evt->data;
592 mp->context = api_context;
593
594 if (is_fail)
595 goto done;
596
597 if (session_has_transport (s))
598 {
599 tc = session_get_transport (s);
600 if (!tc)
601 {
602 is_fail = 1;
603 goto done;
604 }
605
606 vpp_mq = session_manager_get_vpp_event_queue (s->thread_index);
607 mp->handle = session_handle (s);
608 mp->vpp_event_queue_address = pointer_to_uword (vpp_mq);
609 clib_memcpy (mp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip));
610 mp->is_ip4 = tc->is_ip4;
611 mp->lcl_port = tc->lcl_port;
612 mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo);
613 mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo);
614 }
615 else
616 {
617 local_session_t *ls = (local_session_t *) s;
Florin Coras99368312018-08-02 10:45:44 -0700618 u8 main_thread = vlib_num_workers ()? 1 : 0;
619
620 send_app_cut_through_registration_add (app->api_client_index,
Florin Coras134a9962018-08-28 11:32:04 -0700621 app_wrk->wrk_map_index,
Florin Coras99368312018-08-02 10:45:44 -0700622 ls->client_evt_q,
623 ls->server_evt_q);
624
Florin Coras52207f12018-07-12 14:48:06 -0700625 mp->handle = application_local_session_handle (ls);
626 mp->lcl_port = ls->port;
Florin Coras99368312018-08-02 10:45:44 -0700627 vpp_mq = session_manager_get_vpp_event_queue (main_thread);
Florin Coras54693d22018-07-17 10:46:29 -0700628 mp->vpp_event_queue_address = pointer_to_uword (vpp_mq);
Florin Coras52207f12018-07-12 14:48:06 -0700629 mp->client_event_queue_address = ls->client_evt_q;
Florin Coras54693d22018-07-17 10:46:29 -0700630 mp->server_event_queue_address = ls->server_evt_q;
Florin Coras52207f12018-07-12 14:48:06 -0700631 mp->server_rx_fifo = pointer_to_uword (s->server_tx_fifo);
632 mp->server_tx_fifo = pointer_to_uword (s->server_rx_fifo);
633 }
634
635done:
636 mp->retval = is_fail ?
637 clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT) : 0;
638
639 svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
640 return 0;
641}
642
Florin Coras60116992018-08-27 09:52:18 -0700643static int
644mq_send_session_bound_cb (u32 app_wrk_index, u32 api_context,
645 session_handle_t handle, int rv)
646{
647 svm_msg_q_msg_t _msg, *msg = &_msg;
648 svm_msg_q_t *app_mq, *vpp_evt_q;
649 transport_connection_t *tc;
650 stream_session_t *ls = 0;
651 session_bound_msg_t *mp;
652 app_worker_t *app_wrk;
653 session_event_t *evt;
654 application_t *app;
655
656 app_wrk = app_worker_get (app_wrk_index);
657 app = application_get (app_wrk->app_index);
658 app_mq = app_wrk->event_queue;
659 if (!app_mq)
660 {
661 clib_warning ("app %u with api index: %u not attached", app->app_index,
662 app->api_client_index);
663 return -1;
664 }
665
666 svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
667 SVM_Q_WAIT, msg);
668 svm_msg_q_unlock (app_mq);
669 evt = svm_msg_q_msg_data (app_mq, msg);
670 memset (evt, 0, sizeof (*evt));
671 evt->event_type = SESSION_CTRL_EVT_BOUND;
672 mp = (session_bound_msg_t *) evt->data;
673 mp->context = api_context;
674
675 if (rv)
676 goto done;
677
678 mp->handle = handle;
679 if (application_has_global_scope (app))
680 {
681 ls = listen_session_get_from_handle (handle);
682 tc = listen_session_get_transport (ls);
683 mp->lcl_port = tc->lcl_port;
684 mp->lcl_is_ip4 = tc->is_ip4;
685 clib_memcpy (mp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip));
686 }
687 else
688 {
689 local_session_t *local;
690 local = application_get_local_listen_session_from_handle (handle);
691 mp->lcl_port = local->port;
692 mp->lcl_is_ip4 = session_type_is_ip4 (local->session_type);
693 }
694
695 if (ls && session_transport_service_type (ls) == TRANSPORT_SERVICE_CL)
696 {
697 mp->rx_fifo = pointer_to_uword (ls->server_rx_fifo);
698 mp->tx_fifo = pointer_to_uword (ls->server_tx_fifo);
699 vpp_evt_q = session_manager_get_vpp_event_queue (0);
700 mp->vpp_evt_q = pointer_to_uword (vpp_evt_q);
701 }
702
703done:
704 mp->retval = rv;
705 svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
706 return 0;
707}
708
Florin Coras52207f12018-07-12 14:48:06 -0700709static session_cb_vft_t session_mq_cb_vft = {
710 .session_accept_callback = mq_send_session_accepted_cb,
711 .session_disconnect_callback = mq_send_session_disconnected_cb,
712 .session_connected_callback = mq_send_session_connected_cb,
713 .session_reset_callback = mq_send_session_reset_cb,
714 .add_segment_callback = send_add_segment_callback,
715 .del_segment_callback = send_del_segment_callback,
716};
717
Dave Barach68b0fb02017-02-28 15:15:56 -0500718static void
Florin Corase04c2992017-03-01 08:17:34 -0800719vl_api_session_enable_disable_t_handler (vl_api_session_enable_disable_t * mp)
720{
721 vl_api_session_enable_disable_reply_t *rmp;
722 vlib_main_t *vm = vlib_get_main ();
723 int rv = 0;
724
725 vnet_session_enable_disable (vm, mp->is_enable);
726 REPLY_MACRO (VL_API_SESSION_ENABLE_DISABLE_REPLY);
727}
728
729static void
Florin Coras6cf30ad2017-04-04 23:08:23 -0700730vl_api_application_attach_t_handler (vl_api_application_attach_t * mp)
Dave Barach68b0fb02017-02-28 15:15:56 -0500731{
Florin Coras99368312018-08-02 10:45:44 -0700732 int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700733 vl_api_application_attach_reply_t *rmp;
Florin Corasb384b542018-01-15 01:08:33 -0800734 ssvm_private_t *segp, *evt_q_segment;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700735 vnet_app_attach_args_t _a, *a = &_a;
Florin Corasb384b542018-01-15 01:08:33 -0800736 vl_api_registration_t *reg;
Florin Corascea194d2017-10-02 00:18:51 -0700737 clib_error_t *error = 0;
Florin Coras99368312018-08-02 10:45:44 -0700738 u8 fd_flags = 0;
Dave Barach68b0fb02017-02-28 15:15:56 -0500739
Florin Corasfc804d92018-01-26 01:27:01 -0800740 reg = vl_api_client_index_to_registration (mp->client_index);
741 if (!reg)
742 return;
743
Florin Coras6cf30ad2017-04-04 23:08:23 -0700744 if (session_manager_is_enabled () == 0)
745 {
746 rv = VNET_API_ERROR_FEATURE_DISABLED;
747 goto done;
748 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500749
Florin Corasff6e7692017-12-11 04:59:01 -0800750 STATIC_ASSERT (sizeof (u64) * APP_OPTIONS_N_OPTIONS <=
Florin Coras6cf30ad2017-04-04 23:08:23 -0700751 sizeof (mp->options),
752 "Out of options, fix api message definition");
Dave Barach68b0fb02017-02-28 15:15:56 -0500753
754 memset (a, 0, sizeof (*a));
Dave Barach68b0fb02017-02-28 15:15:56 -0500755 a->api_client_index = mp->client_index;
756 a->options = mp->options;
Florin Coras52207f12018-07-12 14:48:06 -0700757
758 if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS)
759 a->session_cb_vft = &session_mq_cb_vft;
760 else
761 a->session_cb_vft = &session_cb_vft;
Dave Barach68b0fb02017-02-28 15:15:56 -0500762
Florin Corascea194d2017-10-02 00:18:51 -0700763 if (mp->namespace_id_len > 64)
764 {
765 rv = VNET_API_ERROR_INVALID_VALUE;
766 goto done;
767 }
768
769 if (mp->namespace_id_len)
770 {
Dave Wallace8af20542017-10-26 03:29:30 -0400771 vec_validate (a->namespace_id, mp->namespace_id_len - 1);
Florin Corascea194d2017-10-02 00:18:51 -0700772 clib_memcpy (a->namespace_id, mp->namespace_id, mp->namespace_id_len);
773 }
774
775 if ((error = vnet_application_attach (a)))
776 {
777 rv = clib_error_get_code (error);
778 clib_error_report (error);
Florin Coras99368312018-08-02 10:45:44 -0700779 vec_free (a->namespace_id);
780 goto done;
Florin Corascea194d2017-10-02 00:18:51 -0700781 }
782 vec_free (a->namespace_id);
Dave Barach68b0fb02017-02-28 15:15:56 -0500783
Florin Coras99368312018-08-02 10:45:44 -0700784 /* Send event queues segment */
785 if ((evt_q_segment = session_manager_get_evt_q_segment ()))
786 {
787 fd_flags |= SESSION_FD_F_VPP_MQ_SEGMENT;
788 fds[n_fds] = evt_q_segment->fd;
789 n_fds += 1;
790 }
791 /* Send fifo segment fd if needed */
792 if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD)
793 {
794 fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
795 fds[n_fds] = a->segment->fd;
796 n_fds += 1;
797 }
798 if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
799 {
800 fd_flags |= SESSION_FD_F_MQ_EVENTFD;
801 fds[n_fds] = svm_msg_q_get_producer_eventfd (a->app_evt_q);
802 n_fds += 1;
803 }
804
Florin Coras6cf30ad2017-04-04 23:08:23 -0700805done:
Florin Corasa5464812017-04-19 13:00:05 -0700806
Dave Barach68b0fb02017-02-28 15:15:56 -0500807 /* *INDENT-OFF* */
Florin Coras6cf30ad2017-04-04 23:08:23 -0700808 REPLY_MACRO2 (VL_API_APPLICATION_ATTACH_REPLY, ({
Dave Barach68b0fb02017-02-28 15:15:56 -0500809 if (!rv)
810 {
Florin Corasb384b542018-01-15 01:08:33 -0800811 segp = a->segment;
Dave Barach68b0fb02017-02-28 15:15:56 -0500812 rmp->segment_name_length = 0;
Florin Corasb384b542018-01-15 01:08:33 -0800813 rmp->segment_size = segp->ssvm_size;
814 if (vec_len (segp->name))
Dave Barach68b0fb02017-02-28 15:15:56 -0500815 {
Florin Corasb384b542018-01-15 01:08:33 -0800816 memcpy (rmp->segment_name, segp->name, vec_len (segp->name));
817 rmp->segment_name_length = vec_len (segp->name);
Dave Barach68b0fb02017-02-28 15:15:56 -0500818 }
Florin Coras99368312018-08-02 10:45:44 -0700819 rmp->app_event_queue_address = pointer_to_uword (a->app_evt_q);
820 rmp->n_fds = n_fds;
821 rmp->fd_flags = fd_flags;
Dave Barach68b0fb02017-02-28 15:15:56 -0500822 }
823 }));
824 /* *INDENT-ON* */
Florin Corasb384b542018-01-15 01:08:33 -0800825
Florin Coras99368312018-08-02 10:45:44 -0700826 if (n_fds)
827 session_send_fds (reg, fds, n_fds);
Dave Barach68b0fb02017-02-28 15:15:56 -0500828}
829
830static void
Florin Coras6cf30ad2017-04-04 23:08:23 -0700831vl_api_application_detach_t_handler (vl_api_application_detach_t * mp)
832{
833 vl_api_application_detach_reply_t *rmp;
834 int rv = VNET_API_ERROR_INVALID_VALUE_2;
835 vnet_app_detach_args_t _a, *a = &_a;
836 application_t *app;
837
838 if (session_manager_is_enabled () == 0)
839 {
840 rv = VNET_API_ERROR_FEATURE_DISABLED;
841 goto done;
842 }
843
844 app = application_lookup (mp->client_index);
845 if (app)
846 {
Florin Coras15531972018-08-12 23:50:53 -0700847 a->app_index = app->app_index;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700848 rv = vnet_application_detach (a);
849 }
850
851done:
852 REPLY_MACRO (VL_API_APPLICATION_DETACH_REPLY);
853}
854
855static void
856vl_api_bind_uri_t_handler (vl_api_bind_uri_t * mp)
857{
Florin Coras7fb0fe12018-04-09 09:24:52 -0700858 transport_connection_t *tc = 0;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700859 vnet_bind_args_t _a, *a = &_a;
Florin Coras7fb0fe12018-04-09 09:24:52 -0700860 vl_api_bind_uri_reply_t *rmp;
861 stream_session_t *s;
862 application_t *app = 0;
Florin Coras3c2fed52018-07-04 04:15:05 -0700863 svm_msg_q_t *vpp_evt_q;
Florin Coras60116992018-08-27 09:52:18 -0700864 app_worker_t *app_wrk;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700865 int rv;
866
867 if (session_manager_is_enabled () == 0)
868 {
869 rv = VNET_API_ERROR_FEATURE_DISABLED;
870 goto done;
871 }
872
873 app = application_lookup (mp->client_index);
874 if (app)
875 {
876 memset (a, 0, sizeof (*a));
877 a->uri = (char *) mp->uri;
Florin Coras15531972018-08-12 23:50:53 -0700878 a->app_index = app->app_index;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700879 rv = vnet_bind_uri (a);
880 }
881 else
882 {
883 rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
884 }
885
886done:
Florin Coras7fb0fe12018-04-09 09:24:52 -0700887
888 /* *INDENT-OFF* */
889 REPLY_MACRO2 (VL_API_BIND_URI_REPLY, ({
890 if (!rv)
891 {
892 rmp->handle = a->handle;
Florin Coras7fb0fe12018-04-09 09:24:52 -0700893 if (app && application_has_global_scope (app))
894 {
895 s = listen_session_get_from_handle (a->handle);
896 tc = listen_session_get_transport (s);
Florin Coras6c354942018-04-18 00:05:21 -0700897 rmp->lcl_is_ip4 = tc->is_ip4;
898 rmp->lcl_port = tc->lcl_port;
Florin Coras7fb0fe12018-04-09 09:24:52 -0700899 clib_memcpy (rmp->lcl_ip, &tc->lcl_ip, sizeof(tc->lcl_ip));
900 if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL)
901 {
902 rmp->rx_fifo = pointer_to_uword (s->server_rx_fifo);
903 rmp->tx_fifo = pointer_to_uword (s->server_tx_fifo);
904 vpp_evt_q = session_manager_get_vpp_event_queue (0);
905 rmp->vpp_evt_q = pointer_to_uword (vpp_evt_q);
906 }
907 }
908 }
909 }));
910 /* *INDENT-ON* */
Florin Coras60116992018-08-27 09:52:18 -0700911
912 /* If app uses mq for control messages, send an mq message as well */
913 if (app && application_use_mq_for_ctrl (app))
914 {
915 app_wrk = application_get_worker (app, 0);
916 mq_send_session_bound_cb (app_wrk->wrk_index, mp->context, a->handle,
917 rv);
918 }
Florin Coras6cf30ad2017-04-04 23:08:23 -0700919}
920
921static void
Dave Barach68b0fb02017-02-28 15:15:56 -0500922vl_api_unbind_uri_t_handler (vl_api_unbind_uri_t * mp)
923{
924 vl_api_unbind_uri_reply_t *rmp;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700925 application_t *app;
926 vnet_unbind_args_t _a, *a = &_a;
Dave Barach68b0fb02017-02-28 15:15:56 -0500927 int rv;
928
Florin Coras6cf30ad2017-04-04 23:08:23 -0700929 if (session_manager_is_enabled () == 0)
930 {
931 rv = VNET_API_ERROR_FEATURE_DISABLED;
932 goto done;
933 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500934
Florin Coras6cf30ad2017-04-04 23:08:23 -0700935 app = application_lookup (mp->client_index);
936 if (app)
937 {
938 a->uri = (char *) mp->uri;
Florin Coras15531972018-08-12 23:50:53 -0700939 a->app_index = app->app_index;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700940 rv = vnet_unbind_uri (a);
941 }
942 else
943 {
944 rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
945 }
946
947done:
Dave Barach68b0fb02017-02-28 15:15:56 -0500948 REPLY_MACRO (VL_API_UNBIND_URI_REPLY);
949}
950
Florin Corasf03a59a2017-06-09 21:07:32 -0700951static void
Dave Barach68b0fb02017-02-28 15:15:56 -0500952vl_api_connect_uri_t_handler (vl_api_connect_uri_t * mp)
953{
Dave Wallace33e002b2017-09-06 01:20:02 -0400954 vl_api_connect_session_reply_t *rmp;
Dave Barach68b0fb02017-02-28 15:15:56 -0500955 vnet_connect_args_t _a, *a = &_a;
Florin Coras6cf30ad2017-04-04 23:08:23 -0700956 application_t *app;
Florin Corascea194d2017-10-02 00:18:51 -0700957 clib_error_t *error = 0;
958 int rv = 0;
Dave Barach68b0fb02017-02-28 15:15:56 -0500959
Florin Coras6cf30ad2017-04-04 23:08:23 -0700960 if (session_manager_is_enabled () == 0)
961 {
962 rv = VNET_API_ERROR_FEATURE_DISABLED;
963 goto done;
964 }
Florin Corase04c2992017-03-01 08:17:34 -0800965
Florin Coras6cf30ad2017-04-04 23:08:23 -0700966 app = application_lookup (mp->client_index);
967 if (app)
968 {
969 a->uri = (char *) mp->uri;
970 a->api_context = mp->context;
Florin Coras15531972018-08-12 23:50:53 -0700971 a->app_index = app->app_index;
Florin Corascea194d2017-10-02 00:18:51 -0700972 if ((error = vnet_connect_uri (a)))
973 {
974 rv = clib_error_get_code (error);
Florin Coras8f89dd02018-03-05 16:53:07 -0800975 clib_error_report (error);
Florin Corascea194d2017-10-02 00:18:51 -0700976 }
Florin Coras6cf30ad2017-04-04 23:08:23 -0700977 }
978 else
979 {
980 rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
981 }
Florin Corase04c2992017-03-01 08:17:34 -0800982
Florin Coras3cbc04b2017-10-02 00:18:51 -0700983 /*
984 * Don't reply to stream (tcp) connects. The reply will come once
985 * the connection is established. In case of the redirects, the reply
986 * will come from the server app.
987 */
Florin Coras8f89dd02018-03-05 16:53:07 -0800988 if (rv == 0)
Florin Corase04c2992017-03-01 08:17:34 -0800989 return;
990
Florin Coras6cf30ad2017-04-04 23:08:23 -0700991done:
Florin Corase04c2992017-03-01 08:17:34 -0800992 /* *INDENT-OFF* */
Dave Wallace33e002b2017-09-06 01:20:02 -0400993 REPLY_MACRO (VL_API_CONNECT_SESSION_REPLY);
Florin Corase04c2992017-03-01 08:17:34 -0800994 /* *INDENT-ON* */
Dave Barach68b0fb02017-02-28 15:15:56 -0500995}
996
997static void
998vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp)
999{
1000 vl_api_disconnect_session_reply_t *rmp;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001001 vnet_disconnect_args_t _a, *a = &_a;
1002 application_t *app;
1003 int rv = 0;
Dave Barach68b0fb02017-02-28 15:15:56 -05001004
Florin Coras6cf30ad2017-04-04 23:08:23 -07001005 if (session_manager_is_enabled () == 0)
1006 {
1007 rv = VNET_API_ERROR_FEATURE_DISABLED;
1008 goto done;
1009 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001010
Florin Coras6cf30ad2017-04-04 23:08:23 -07001011 app = application_lookup (mp->client_index);
1012 if (app)
1013 {
1014 a->handle = mp->handle;
Florin Coras15531972018-08-12 23:50:53 -07001015 a->app_index = app->app_index;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001016 rv = vnet_disconnect_session (a);
1017 }
1018 else
1019 {
1020 rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1021 }
1022
1023done:
Dave Wallacede5fec92017-11-11 22:41:34 -05001024 REPLY_MACRO2 (VL_API_DISCONNECT_SESSION_REPLY, rmp->handle = mp->handle);
Dave Barach68b0fb02017-02-28 15:15:56 -05001025}
1026
1027static void
1028vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
1029 mp)
1030{
Florin Coras6cf30ad2017-04-04 23:08:23 -07001031 vnet_disconnect_args_t _a, *a = &_a;
1032 application_t *app;
Dave Barach68b0fb02017-02-28 15:15:56 -05001033
1034 /* Client objected to disconnecting the session, log and continue */
1035 if (mp->retval)
1036 {
1037 clib_warning ("client retval %d", mp->retval);
1038 return;
1039 }
1040
1041 /* Disconnect has been confirmed. Confirm close to transport */
Florin Corasf8f516a2018-02-08 15:10:09 -08001042 app = application_lookup (mp->context);
Florin Coras6cf30ad2017-04-04 23:08:23 -07001043 if (app)
1044 {
1045 a->handle = mp->handle;
Florin Coras15531972018-08-12 23:50:53 -07001046 a->app_index = app->app_index;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001047 vnet_disconnect_session (a);
1048 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001049}
1050
1051static void
1052vl_api_reset_session_reply_t_handler (vl_api_reset_session_reply_t * mp)
1053{
Florin Coras15531972018-08-12 23:50:53 -07001054 app_worker_t *app_wrk;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001055 application_t *app;
Dave Barach68b0fb02017-02-28 15:15:56 -05001056 stream_session_t *s;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001057 u32 index, thread_index;
Dave Barach68b0fb02017-02-28 15:15:56 -05001058
Ondrej Fabry6bd197e2018-08-15 08:46:46 +02001059 app = application_lookup (mp->context);
Florin Coras6cf30ad2017-04-04 23:08:23 -07001060 if (!app)
1061 return;
1062
Florin Corascea194d2017-10-02 00:18:51 -07001063 session_parse_handle (mp->handle, &index, &thread_index);
Florin Coras3cbc04b2017-10-02 00:18:51 -07001064 s = session_get_if_valid (index, thread_index);
Florin Coras15531972018-08-12 23:50:53 -07001065 if (!s)
Dave Barach68b0fb02017-02-28 15:15:56 -05001066 {
1067 clib_warning ("Invalid session!");
1068 return;
1069 }
1070
Florin Coras15531972018-08-12 23:50:53 -07001071 app_wrk = app_worker_get (s->app_wrk_index);
1072 if (app_wrk->app_index != app->app_index)
1073 {
1074 clib_warning ("app %u does not own handle 0x%lx", app->app_index,
1075 mp->handle);
1076 return;
1077 }
1078
Dave Barach68b0fb02017-02-28 15:15:56 -05001079 /* Client objected to resetting the session, log and continue */
1080 if (mp->retval)
1081 {
1082 clib_warning ("client retval %d", mp->retval);
1083 return;
1084 }
1085
Dave Barach68b0fb02017-02-28 15:15:56 -05001086 /* This comes as a response to a reset, transport only waiting for
1087 * confirmation to remove connection state, no need to disconnect */
1088 stream_session_cleanup (s);
1089}
1090
1091static void
1092vl_api_accept_session_reply_t_handler (vl_api_accept_session_reply_t * mp)
1093{
Florin Corasf8f516a2018-02-08 15:10:09 -08001094 vnet_disconnect_args_t _a = { 0 }, *a = &_a;
1095 local_session_t *ls;
Dave Barach68b0fb02017-02-28 15:15:56 -05001096 stream_session_t *s;
Dave Barach68b0fb02017-02-28 15:15:56 -05001097
Florin Corasa5464812017-04-19 13:00:05 -07001098 /* Server isn't interested, kill the session */
1099 if (mp->retval)
Dave Barach68b0fb02017-02-28 15:15:56 -05001100 {
Florin Corasa5464812017-04-19 13:00:05 -07001101 a->app_index = mp->context;
1102 a->handle = mp->handle;
1103 vnet_disconnect_session (a);
Florin Corasf8f516a2018-02-08 15:10:09 -08001104 return;
1105 }
1106
1107 if (session_handle_is_local (mp->handle))
1108 {
1109 ls = application_get_local_session_from_handle (mp->handle);
Florin Coras15531972018-08-12 23:50:53 -07001110 if (!ls || ls->app_wrk_index != mp->context)
Florin Corasf8f516a2018-02-08 15:10:09 -08001111 {
1112 clib_warning ("server %u doesn't own local handle %llu",
1113 mp->context, mp->handle);
1114 return;
1115 }
1116 if (application_local_session_connect_notify (ls))
1117 return;
1118 ls->session_state = SESSION_STATE_READY;
Dave Barach68b0fb02017-02-28 15:15:56 -05001119 }
Florin Corasa5464812017-04-19 13:00:05 -07001120 else
1121 {
Florin Corasf8f516a2018-02-08 15:10:09 -08001122 s = session_get_from_handle_if_valid (mp->handle);
Florin Corasa5464812017-04-19 13:00:05 -07001123 if (!s)
1124 {
1125 clib_warning ("session doesn't exist");
1126 return;
1127 }
Florin Coras15531972018-08-12 23:50:53 -07001128 if (s->app_wrk_index != mp->context)
Florin Corasa5464812017-04-19 13:00:05 -07001129 {
1130 clib_warning ("app doesn't own session");
1131 return;
1132 }
Florin Corasa5464812017-04-19 13:00:05 -07001133 s->session_state = SESSION_STATE_READY;
1134 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001135}
1136
1137static void
1138vl_api_map_another_segment_reply_t_handler (vl_api_map_another_segment_reply_t
1139 * mp)
1140{
1141 clib_warning ("not implemented");
1142}
1143
1144static void
1145vl_api_bind_sock_t_handler (vl_api_bind_sock_t * mp)
1146{
1147 vl_api_bind_sock_reply_t *rmp;
1148 vnet_bind_args_t _a, *a = &_a;
Florin Corascea194d2017-10-02 00:18:51 -07001149 int rv = 0;
1150 clib_error_t *error;
Florin Coraseb2945c2017-11-22 10:39:09 -08001151 application_t *app = 0;
Florin Coras60116992018-08-27 09:52:18 -07001152 app_worker_t *app_wrk;
Florin Corasdcf55ce2017-11-16 15:32:50 -08001153 stream_session_t *s;
1154 transport_connection_t *tc = 0;
1155 ip46_address_t *ip46;
Florin Coras3c2fed52018-07-04 04:15:05 -07001156 svm_msg_q_t *vpp_evt_q;
Dave Barach68b0fb02017-02-28 15:15:56 -05001157
Florin Coras6cf30ad2017-04-04 23:08:23 -07001158 if (session_manager_is_enabled () == 0)
1159 {
1160 rv = VNET_API_ERROR_FEATURE_DISABLED;
1161 goto done;
1162 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001163
Florin Coras6cf30ad2017-04-04 23:08:23 -07001164 app = application_lookup (mp->client_index);
Florin Corasdcf55ce2017-11-16 15:32:50 -08001165 if (!app)
Florin Coras6cf30ad2017-04-04 23:08:23 -07001166 {
Florin Corasdcf55ce2017-11-16 15:32:50 -08001167 rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1168 goto done;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001169 }
Florin Corasdcf55ce2017-11-16 15:32:50 -08001170
1171 ip46 = (ip46_address_t *) mp->ip;
1172 memset (a, 0, sizeof (*a));
1173 a->sep.is_ip4 = mp->is_ip4;
1174 a->sep.ip = *ip46;
1175 a->sep.port = mp->port;
1176 a->sep.fib_index = mp->vrf;
1177 a->sep.sw_if_index = ENDPOINT_INVALID_INDEX;
1178 a->sep.transport_proto = mp->proto;
Florin Coras15531972018-08-12 23:50:53 -07001179 a->app_index = app->app_index;
1180 a->wrk_map_index = mp->wrk_index;
Florin Corasdcf55ce2017-11-16 15:32:50 -08001181
1182 if ((error = vnet_bind (a)))
1183 {
1184 rv = clib_error_get_code (error);
1185 clib_error_report (error);
1186 }
Florin Corasdcf55ce2017-11-16 15:32:50 -08001187
Florin Coras6cf30ad2017-04-04 23:08:23 -07001188done:
Florin Corascea194d2017-10-02 00:18:51 -07001189 /* *INDENT-OFF* */
1190 REPLY_MACRO2 (VL_API_BIND_SOCK_REPLY,({
1191 if (!rv)
Florin Corasdcf55ce2017-11-16 15:32:50 -08001192 {
1193 rmp->handle = a->handle;
Florin Coraseb2945c2017-11-22 10:39:09 -08001194 rmp->lcl_port = mp->port;
Keith Burns (alagalah)60ae80f2018-03-15 10:04:20 -07001195 rmp->lcl_is_ip4 = mp->is_ip4;
Dave Wallace97b1a272017-12-18 13:51:59 -05001196 if (app && application_has_global_scope (app))
Florin Coraseb2945c2017-11-22 10:39:09 -08001197 {
1198 s = listen_session_get_from_handle (a->handle);
1199 tc = listen_session_get_transport (s);
Florin Coraseb2945c2017-11-22 10:39:09 -08001200 clib_memcpy (rmp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip));
Florin Coras7fb0fe12018-04-09 09:24:52 -07001201 if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL)
1202 {
1203 rmp->rx_fifo = pointer_to_uword (s->server_rx_fifo);
1204 rmp->tx_fifo = pointer_to_uword (s->server_tx_fifo);
1205 vpp_evt_q = session_manager_get_vpp_event_queue (0);
1206 rmp->vpp_evt_q = pointer_to_uword (vpp_evt_q);
1207 }
Florin Coraseb2945c2017-11-22 10:39:09 -08001208 }
Florin Corasdcf55ce2017-11-16 15:32:50 -08001209 }
Florin Corascea194d2017-10-02 00:18:51 -07001210 }));
1211 /* *INDENT-ON* */
Florin Coras60116992018-08-27 09:52:18 -07001212
1213 /* If app uses mq for control messages, send an mq message as well */
1214 if (app && application_use_mq_for_ctrl (app))
1215 {
1216 app_wrk = application_get_worker (app, mp->wrk_index);
1217 mq_send_session_bound_cb (app_wrk->wrk_index, mp->context, a->handle,
1218 rv);
1219 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001220}
1221
1222static void
1223vl_api_unbind_sock_t_handler (vl_api_unbind_sock_t * mp)
1224{
1225 vl_api_unbind_sock_reply_t *rmp;
1226 vnet_unbind_args_t _a, *a = &_a;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001227 application_t *app;
Florin Corascea194d2017-10-02 00:18:51 -07001228 clib_error_t *error;
1229 int rv = 0;
Dave Barach68b0fb02017-02-28 15:15:56 -05001230
Florin Coras6cf30ad2017-04-04 23:08:23 -07001231 if (session_manager_is_enabled () == 0)
1232 {
1233 rv = VNET_API_ERROR_FEATURE_DISABLED;
1234 goto done;
1235 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001236
Florin Coras6cf30ad2017-04-04 23:08:23 -07001237 app = application_lookup (mp->client_index);
1238 if (app)
1239 {
Florin Coras15531972018-08-12 23:50:53 -07001240 a->app_index = app->app_index;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001241 a->handle = mp->handle;
Florin Corascea194d2017-10-02 00:18:51 -07001242 if ((error = vnet_unbind (a)))
1243 {
1244 rv = clib_error_get_code (error);
1245 clib_error_report (error);
1246 }
Florin Coras6cf30ad2017-04-04 23:08:23 -07001247 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001248
Florin Coras6cf30ad2017-04-04 23:08:23 -07001249done:
Dave Barach68b0fb02017-02-28 15:15:56 -05001250 REPLY_MACRO (VL_API_UNBIND_SOCK_REPLY);
1251}
1252
1253static void
1254vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp)
1255{
Dave Wallace33e002b2017-09-06 01:20:02 -04001256 vl_api_connect_session_reply_t *rmp;
Dave Barach68b0fb02017-02-28 15:15:56 -05001257 vnet_connect_args_t _a, *a = &_a;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001258 application_t *app;
Florin Corascea194d2017-10-02 00:18:51 -07001259 clib_error_t *error = 0;
1260 int rv = 0;
Dave Barach68b0fb02017-02-28 15:15:56 -05001261
Florin Coras6cf30ad2017-04-04 23:08:23 -07001262 if (session_manager_is_enabled () == 0)
1263 {
1264 rv = VNET_API_ERROR_FEATURE_DISABLED;
1265 goto done;
1266 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001267
Florin Coras6cf30ad2017-04-04 23:08:23 -07001268 app = application_lookup (mp->client_index);
1269 if (app)
1270 {
Florin Corase86a8ed2018-01-05 03:20:25 -08001271 svm_queue_t *client_q;
Dave Wallace33e002b2017-09-06 01:20:02 -04001272 ip46_address_t *ip46 = (ip46_address_t *) mp->ip;
Dave Wallaceb2d5ff32017-06-14 12:38:28 -04001273
Florin Coras8f89dd02018-03-05 16:53:07 -08001274 memset (a, 0, sizeof (*a));
Dave Wallaceb2d5ff32017-06-14 12:38:28 -04001275 client_q = vl_api_client_index_to_input_queue (mp->client_index);
1276 mp->client_queue_address = pointer_to_uword (client_q);
Florin Corascea194d2017-10-02 00:18:51 -07001277 a->sep.is_ip4 = mp->is_ip4;
1278 a->sep.ip = *ip46;
1279 a->sep.port = mp->port;
1280 a->sep.transport_proto = mp->proto;
1281 a->sep.fib_index = mp->vrf;
1282 a->sep.sw_if_index = ENDPOINT_INVALID_INDEX;
Florin Coras8f89dd02018-03-05 16:53:07 -08001283 if (mp->hostname_len)
1284 {
Florin Coras15531972018-08-12 23:50:53 -07001285 vec_validate (a->sep_ext.hostname, mp->hostname_len - 1);
1286 clib_memcpy (a->sep_ext.hostname, mp->hostname, mp->hostname_len);
Florin Coras8f89dd02018-03-05 16:53:07 -08001287 }
Florin Coras6cf30ad2017-04-04 23:08:23 -07001288 a->api_context = mp->context;
Florin Coras15531972018-08-12 23:50:53 -07001289 a->app_index = app->app_index;
1290 a->wrk_map_index = mp->wrk_index;
Florin Corascea194d2017-10-02 00:18:51 -07001291 if ((error = vnet_connect (a)))
1292 {
1293 rv = clib_error_get_code (error);
Florin Coras8f89dd02018-03-05 16:53:07 -08001294 clib_error_report (error);
Florin Corascea194d2017-10-02 00:18:51 -07001295 }
Florin Coras15531972018-08-12 23:50:53 -07001296 vec_free (a->sep_ext.hostname);
Florin Coras6cf30ad2017-04-04 23:08:23 -07001297 }
1298 else
1299 {
1300 rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1301 }
Florin Corase04c2992017-03-01 08:17:34 -08001302
Florin Coras8f89dd02018-03-05 16:53:07 -08001303 if (rv == 0)
Florin Corase04c2992017-03-01 08:17:34 -08001304 return;
1305
1306 /* Got some error, relay it */
1307
Florin Coras6cf30ad2017-04-04 23:08:23 -07001308done:
Dave Wallace33e002b2017-09-06 01:20:02 -04001309 REPLY_MACRO (VL_API_CONNECT_SESSION_REPLY);
Dave Barach68b0fb02017-02-28 15:15:56 -05001310}
1311
Florin Corascea194d2017-10-02 00:18:51 -07001312static void
Florin Coras15531972018-08-12 23:50:53 -07001313vl_api_app_worker_add_del_t_handler (vl_api_app_worker_add_del_t * mp)
1314{
1315 int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
1316 vl_api_app_worker_add_del_reply_t *rmp;
1317 vl_api_registration_t *reg;
1318 clib_error_t *error = 0;
1319 application_t *app;
1320 u8 fd_flags = 0;
1321
1322 if (!session_manager_is_enabled ())
1323 {
1324 rv = VNET_API_ERROR_FEATURE_DISABLED;
1325 goto done;
1326 }
1327
1328 reg = vl_api_client_index_to_registration (mp->client_index);
1329 if (!reg)
1330 return;
1331
1332 app = application_lookup (mp->app_api_index);
1333 if (!app)
1334 {
1335 rv = VNET_API_ERROR_INVALID_VALUE;
1336 goto done;
1337 }
1338
1339 vnet_app_worker_add_del_args_t args = {
1340 .app_index = app->app_index,
1341 .wrk_index = clib_net_to_host_u32 (mp->wrk_index),
1342 .is_add = mp->is_add
1343 };
1344 error = vnet_app_worker_add_del (&args);
1345 if (error)
1346 {
1347 rv = clib_error_get_code (error);
1348 clib_error_report (error);
1349 goto done;
1350 }
1351
Florin Corasc3638fe2018-08-24 13:58:49 -07001352 /* Make coverity happy */
1353 ASSERT (args.evt_q && args.segment);
1354
Florin Coras15531972018-08-12 23:50:53 -07001355 /* Send fifo segment fd if needed */
1356 if (ssvm_type (args.segment) == SSVM_SEGMENT_MEMFD)
1357 {
1358 fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
1359 fds[n_fds] = args.segment->fd;
1360 n_fds += 1;
1361 }
1362 if (application_segment_manager_properties (app)->use_mq_eventfd)
1363 {
1364 fd_flags |= SESSION_FD_F_MQ_EVENTFD;
1365 fds[n_fds] = svm_msg_q_get_producer_eventfd (args.evt_q);
1366 n_fds += 1;
1367 }
1368
1369 /* *INDENT-OFF* */
1370done:
1371 REPLY_MACRO2 (VL_API_APP_WORKER_ADD_DEL_REPLY, ({
1372 rmp->is_add = mp->is_add;
1373 if (!rv)
1374 {
1375 rmp->wrk_index = clib_host_to_net_u32 (args.wrk_index);
1376 if (vec_len (args.segment->name))
1377 {
1378 memcpy (rmp->segment_name, args.segment->name,
1379 vec_len (args.segment->name));
1380 rmp->segment_name_length = vec_len (args.segment->name);
1381 }
1382 rmp->app_event_queue_address = pointer_to_uword (args.evt_q);
1383 rmp->n_fds = n_fds;
1384 rmp->fd_flags = fd_flags;
1385 }
1386 }));
1387 /* *INDENT-ON* */
1388
1389 if (n_fds)
1390 session_send_fds (reg, fds, n_fds);
1391}
1392
1393static void
Florin Corascea194d2017-10-02 00:18:51 -07001394vl_api_app_namespace_add_del_t_handler (vl_api_app_namespace_add_del_t * mp)
1395{
1396 vl_api_app_namespace_add_del_reply_t *rmp;
Florin Corascea194d2017-10-02 00:18:51 -07001397 clib_error_t *error = 0;
Florin Coras6e8c6672017-11-10 09:03:54 -08001398 u32 appns_index = 0;
1399 u8 *ns_id = 0;
Florin Corascea194d2017-10-02 00:18:51 -07001400 int rv = 0;
1401 if (!session_manager_is_enabled ())
1402 {
1403 rv = VNET_API_ERROR_FEATURE_DISABLED;
1404 goto done;
1405 }
1406
1407 if (mp->namespace_id_len > ARRAY_LEN (mp->namespace_id))
1408 {
1409 rv = VNET_API_ERROR_INVALID_VALUE;
1410 goto done;
1411 }
1412
1413 vec_validate (ns_id, mp->namespace_id_len - 1);
1414 clib_memcpy (ns_id, mp->namespace_id, mp->namespace_id_len);
1415 vnet_app_namespace_add_del_args_t args = {
1416 .ns_id = ns_id,
Florin Coras9a9adb22017-10-26 08:16:59 -07001417 .secret = clib_net_to_host_u64 (mp->secret),
Florin Corascea194d2017-10-02 00:18:51 -07001418 .sw_if_index = clib_net_to_host_u32 (mp->sw_if_index),
1419 .ip4_fib_id = clib_net_to_host_u32 (mp->ip4_fib_id),
1420 .ip6_fib_id = clib_net_to_host_u32 (mp->ip6_fib_id),
1421 .is_add = 1
1422 };
1423 error = vnet_app_namespace_add_del (&args);
1424 if (error)
1425 {
1426 rv = clib_error_get_code (error);
1427 clib_error_report (error);
1428 }
Florin Coras6e8c6672017-11-10 09:03:54 -08001429 else
1430 {
1431 appns_index = app_namespace_index_from_id (ns_id);
1432 if (appns_index == APP_NAMESPACE_INVALID_INDEX)
1433 {
1434 clib_warning ("app ns lookup failed");
1435 rv = VNET_API_ERROR_UNSPECIFIED;
1436 }
1437 }
Florin Corascea194d2017-10-02 00:18:51 -07001438 vec_free (ns_id);
Florin Coras6e8c6672017-11-10 09:03:54 -08001439
1440 /* *INDENT-OFF* */
Florin Corascea194d2017-10-02 00:18:51 -07001441done:
Florin Coras6e8c6672017-11-10 09:03:54 -08001442 REPLY_MACRO2 (VL_API_APP_NAMESPACE_ADD_DEL_REPLY, ({
1443 if (!rv)
1444 rmp->appns_index = clib_host_to_net_u32 (appns_index);
1445 }));
1446 /* *INDENT-ON* */
Florin Corascea194d2017-10-02 00:18:51 -07001447}
1448
Florin Coras1c710452017-10-17 00:03:13 -07001449static void
1450vl_api_session_rule_add_del_t_handler (vl_api_session_rule_add_del_t * mp)
1451{
1452 vl_api_session_rule_add_del_reply_t *rmp;
1453 session_rule_add_del_args_t args;
1454 session_rule_table_add_del_args_t *table_args = &args.table_args;
1455 clib_error_t *error;
1456 u8 fib_proto;
1457 int rv = 0;
1458
Florin Corasc97a7392017-11-05 23:07:07 -08001459 memset (&args, 0, sizeof (args));
Florin Coras1c710452017-10-17 00:03:13 -07001460 fib_proto = mp->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
1461
1462 table_args->lcl.fp_len = mp->lcl_plen;
1463 table_args->lcl.fp_proto = fib_proto;
1464 table_args->rmt.fp_len = mp->rmt_plen;
1465 table_args->rmt.fp_proto = fib_proto;
Milan Lenco8b9a5d12017-11-24 17:12:33 +01001466 table_args->lcl_port = mp->lcl_port;
1467 table_args->rmt_port = mp->rmt_port;
Florin Coras1c710452017-10-17 00:03:13 -07001468 table_args->action_index = clib_net_to_host_u32 (mp->action_index);
1469 table_args->is_add = mp->is_add;
Florin Corasc97a7392017-11-05 23:07:07 -08001470 mp->tag[sizeof (mp->tag) - 1] = 0;
1471 table_args->tag = format (0, "%s", mp->tag);
Florin Coras1c710452017-10-17 00:03:13 -07001472 args.appns_index = clib_net_to_host_u32 (mp->appns_index);
1473 args.scope = mp->scope;
Florin Coras42324ad2017-11-18 18:45:20 -08001474 args.transport_proto = mp->transport_proto;
Florin Coras1c710452017-10-17 00:03:13 -07001475
1476 memset (&table_args->lcl.fp_addr, 0, sizeof (table_args->lcl.fp_addr));
1477 memset (&table_args->rmt.fp_addr, 0, sizeof (table_args->rmt.fp_addr));
1478 ip_set (&table_args->lcl.fp_addr, mp->lcl_ip, mp->is_ip4);
1479 ip_set (&table_args->rmt.fp_addr, mp->rmt_ip, mp->is_ip4);
1480 error = vnet_session_rule_add_del (&args);
1481 if (error)
1482 {
1483 rv = clib_error_get_code (error);
1484 clib_error_report (error);
1485 }
Florin Corasc97a7392017-11-05 23:07:07 -08001486 vec_free (table_args->tag);
Florin Coras1c710452017-10-17 00:03:13 -07001487 REPLY_MACRO (VL_API_SESSION_RULE_ADD_DEL_REPLY);
1488}
1489
Florin Coras6c36f532017-11-03 18:32:34 -07001490static void
1491send_session_rule_details4 (mma_rule_16_t * rule, u8 is_local,
Florin Corasc97a7392017-11-05 23:07:07 -08001492 u8 transport_proto, u32 appns_index, u8 * tag,
Florin Coras6c4dae22018-01-09 06:39:23 -08001493 vl_api_registration_t * reg, u32 context)
Florin Coras6c36f532017-11-03 18:32:34 -07001494{
1495 vl_api_session_rules_details_t *rmp = 0;
1496 session_mask_or_match_4_t *match =
1497 (session_mask_or_match_4_t *) & rule->match;
1498 session_mask_or_match_4_t *mask =
1499 (session_mask_or_match_4_t *) & rule->mask;
1500
1501 rmp = vl_msg_api_alloc (sizeof (*rmp));
1502 memset (rmp, 0, sizeof (*rmp));
1503 rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
1504 rmp->context = context;
1505
1506 rmp->is_ip4 = 1;
1507 clib_memcpy (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
1508 clib_memcpy (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
1509 rmp->lcl_plen = ip4_mask_to_preflen (&mask->lcl_ip);
1510 rmp->rmt_plen = ip4_mask_to_preflen (&mask->rmt_ip);
Milan Lenco8b9a5d12017-11-24 17:12:33 +01001511 rmp->lcl_port = match->lcl_port;
1512 rmp->rmt_port = match->rmt_port;
Florin Coras6c36f532017-11-03 18:32:34 -07001513 rmp->action_index = clib_host_to_net_u32 (rule->action_index);
1514 rmp->scope =
1515 is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL;
1516 rmp->transport_proto = transport_proto;
1517 rmp->appns_index = clib_host_to_net_u32 (appns_index);
Florin Corasc97a7392017-11-05 23:07:07 -08001518 if (tag)
1519 {
1520 clib_memcpy (rmp->tag, tag, vec_len (tag));
1521 rmp->tag[vec_len (tag)] = 0;
1522 }
Florin Coras6c36f532017-11-03 18:32:34 -07001523
Florin Coras6c4dae22018-01-09 06:39:23 -08001524 vl_api_send_msg (reg, (u8 *) rmp);
Florin Coras6c36f532017-11-03 18:32:34 -07001525}
1526
1527static void
Florin Corasc97a7392017-11-05 23:07:07 -08001528send_session_rule_details6 (mma_rule_40_t * rule, u8 is_local,
1529 u8 transport_proto, u32 appns_index, u8 * tag,
Florin Coras6c4dae22018-01-09 06:39:23 -08001530 vl_api_registration_t * reg, u32 context)
Florin Coras6c36f532017-11-03 18:32:34 -07001531{
1532 vl_api_session_rules_details_t *rmp = 0;
1533 session_mask_or_match_6_t *match =
1534 (session_mask_or_match_6_t *) & rule->match;
1535 session_mask_or_match_6_t *mask =
1536 (session_mask_or_match_6_t *) & rule->mask;
1537
1538 rmp = vl_msg_api_alloc (sizeof (*rmp));
1539 memset (rmp, 0, sizeof (*rmp));
1540 rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
1541 rmp->context = context;
1542
1543 rmp->is_ip4 = 0;
1544 clib_memcpy (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
1545 clib_memcpy (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
1546 rmp->lcl_plen = ip6_mask_to_preflen (&mask->lcl_ip);
1547 rmp->rmt_plen = ip6_mask_to_preflen (&mask->rmt_ip);
Milan Lenco8b9a5d12017-11-24 17:12:33 +01001548 rmp->lcl_port = match->lcl_port;
1549 rmp->rmt_port = match->rmt_port;
Florin Coras6c36f532017-11-03 18:32:34 -07001550 rmp->action_index = clib_host_to_net_u32 (rule->action_index);
Florin Corasc97a7392017-11-05 23:07:07 -08001551 rmp->scope =
1552 is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL;
Florin Coras6c36f532017-11-03 18:32:34 -07001553 rmp->transport_proto = transport_proto;
1554 rmp->appns_index = clib_host_to_net_u32 (appns_index);
Florin Corasc97a7392017-11-05 23:07:07 -08001555 if (tag)
1556 {
1557 clib_memcpy (rmp->tag, tag, vec_len (tag));
1558 rmp->tag[vec_len (tag)] = 0;
1559 }
Florin Coras6c36f532017-11-03 18:32:34 -07001560
Florin Coras6c4dae22018-01-09 06:39:23 -08001561 vl_api_send_msg (reg, (u8 *) rmp);
Florin Coras6c36f532017-11-03 18:32:34 -07001562}
1563
1564static void
1565send_session_rules_table_details (session_rules_table_t * srt, u8 fib_proto,
Florin Corasc97a7392017-11-05 23:07:07 -08001566 u8 tp, u8 is_local, u32 appns_index,
Florin Coras6c4dae22018-01-09 06:39:23 -08001567 vl_api_registration_t * reg, u32 context)
Florin Coras6c36f532017-11-03 18:32:34 -07001568{
1569 mma_rule_16_t *rule16;
1570 mma_rule_40_t *rule40;
1571 mma_rules_table_16_t *srt16;
1572 mma_rules_table_40_t *srt40;
Florin Corasc97a7392017-11-05 23:07:07 -08001573 u32 ri;
Florin Coras6c36f532017-11-03 18:32:34 -07001574
Florin Corasc97a7392017-11-05 23:07:07 -08001575 if (is_local || fib_proto == FIB_PROTOCOL_IP4)
Florin Coras6c36f532017-11-03 18:32:34 -07001576 {
Florin Corasc97a7392017-11-05 23:07:07 -08001577 u8 *tag = 0;
1578 /* *INDENT-OFF* */
1579 srt16 = &srt->session_rules_tables_16;
1580 pool_foreach (rule16, srt16->rules, ({
1581 ri = mma_rules_table_rule_index_16 (srt16, rule16);
1582 tag = session_rules_table_rule_tag (srt, ri, 1);
1583 send_session_rule_details4 (rule16, is_local, tp, appns_index, tag,
Florin Coras6c4dae22018-01-09 06:39:23 -08001584 reg, context);
Florin Corasc97a7392017-11-05 23:07:07 -08001585 }));
1586 /* *INDENT-ON* */
1587 }
1588 if (is_local || fib_proto == FIB_PROTOCOL_IP6)
1589 {
1590 u8 *tag = 0;
1591 /* *INDENT-OFF* */
1592 srt40 = &srt->session_rules_tables_40;
1593 pool_foreach (rule40, srt40->rules, ({
1594 ri = mma_rules_table_rule_index_40 (srt40, rule40);
1595 tag = session_rules_table_rule_tag (srt, ri, 1);
1596 send_session_rule_details6 (rule40, is_local, tp, appns_index, tag,
Florin Coras6c4dae22018-01-09 06:39:23 -08001597 reg, context);
Florin Corasc97a7392017-11-05 23:07:07 -08001598 }));
1599 /* *INDENT-ON* */
Florin Coras6c36f532017-11-03 18:32:34 -07001600 }
1601}
1602
1603static void
1604vl_api_session_rules_dump_t_handler (vl_api_one_map_server_dump_t * mp)
1605{
Florin Coras6c4dae22018-01-09 06:39:23 -08001606 vl_api_registration_t *reg;
Florin Coras6c36f532017-11-03 18:32:34 -07001607 session_table_t *st;
Florin Corasc97a7392017-11-05 23:07:07 -08001608 u8 tp;
Florin Coras6c36f532017-11-03 18:32:34 -07001609
Florin Coras6c4dae22018-01-09 06:39:23 -08001610 reg = vl_api_client_index_to_registration (mp->client_index);
1611 if (!reg)
Florin Coras6c36f532017-11-03 18:32:34 -07001612 return;
1613
1614 /* *INDENT-OFF* */
1615 session_table_foreach (st, ({
Florin Corasc97a7392017-11-05 23:07:07 -08001616 for (tp = 0; tp < TRANSPORT_N_PROTO; tp++)
1617 {
1618 send_session_rules_table_details (&st->session_rules[tp],
1619 st->active_fib_proto, tp,
Florin Coras6c4dae22018-01-09 06:39:23 -08001620 st->is_local, st->appns_index, reg,
Florin Corasc97a7392017-11-05 23:07:07 -08001621 mp->context);
1622 }
Florin Coras6c36f532017-11-03 18:32:34 -07001623 }));
1624 /* *INDENT-ON* */
1625}
1626
Florin Coras371ca502018-02-21 12:07:41 -08001627static void
1628vl_api_application_tls_cert_add_t_handler (vl_api_application_tls_cert_add_t *
1629 mp)
1630{
1631 vl_api_app_namespace_add_del_reply_t *rmp;
1632 vnet_app_add_tls_cert_args_t _a, *a = &_a;
1633 clib_error_t *error;
Florin Corase3e2f072018-03-04 07:24:30 -08001634 application_t *app;
Florin Coras371ca502018-02-21 12:07:41 -08001635 u32 cert_len;
1636 int rv = 0;
1637 if (!session_manager_is_enabled ())
1638 {
1639 rv = VNET_API_ERROR_FEATURE_DISABLED;
1640 goto done;
1641 }
Florin Corase3e2f072018-03-04 07:24:30 -08001642 if (!(app = application_lookup (mp->client_index)))
1643 {
1644 rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1645 goto done;
1646 }
Florin Coras371ca502018-02-21 12:07:41 -08001647 memset (a, 0, sizeof (*a));
Florin Coras15531972018-08-12 23:50:53 -07001648 a->app_index = app->app_index;
Florin Coras371ca502018-02-21 12:07:41 -08001649 cert_len = clib_net_to_host_u16 (mp->cert_len);
Florin Coras5090c572018-03-18 08:22:17 -07001650 if (cert_len > 10000)
1651 {
1652 rv = VNET_API_ERROR_INVALID_VALUE;
1653 goto done;
1654 }
Florin Coras371ca502018-02-21 12:07:41 -08001655 vec_validate (a->cert, cert_len);
1656 clib_memcpy (a->cert, mp->cert, cert_len);
1657 if ((error = vnet_app_add_tls_cert (a)))
1658 {
1659 rv = clib_error_get_code (error);
1660 clib_error_report (error);
1661 }
1662 vec_free (a->cert);
1663done:
1664 REPLY_MACRO (VL_API_APPLICATION_TLS_CERT_ADD_REPLY);
1665}
1666
1667static void
1668vl_api_application_tls_key_add_t_handler (vl_api_application_tls_key_add_t *
1669 mp)
1670{
1671 vl_api_app_namespace_add_del_reply_t *rmp;
1672 vnet_app_add_tls_key_args_t _a, *a = &_a;
1673 clib_error_t *error;
Florin Corase3e2f072018-03-04 07:24:30 -08001674 application_t *app;
Florin Coras371ca502018-02-21 12:07:41 -08001675 u32 key_len;
1676 int rv = 0;
1677 if (!session_manager_is_enabled ())
1678 {
1679 rv = VNET_API_ERROR_FEATURE_DISABLED;
1680 goto done;
1681 }
Florin Corase3e2f072018-03-04 07:24:30 -08001682 if (!(app = application_lookup (mp->client_index)))
1683 {
1684 rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1685 goto done;
1686 }
Florin Coras371ca502018-02-21 12:07:41 -08001687 memset (a, 0, sizeof (*a));
Florin Coras15531972018-08-12 23:50:53 -07001688 a->app_index = app->app_index;
Florin Coras371ca502018-02-21 12:07:41 -08001689 key_len = clib_net_to_host_u16 (mp->key_len);
Florin Coras5090c572018-03-18 08:22:17 -07001690 if (key_len > 10000)
1691 {
1692 rv = VNET_API_ERROR_INVALID_VALUE;
1693 goto done;
1694 }
Florin Coras371ca502018-02-21 12:07:41 -08001695 vec_validate (a->key, key_len);
1696 clib_memcpy (a->key, mp->key, key_len);
1697 if ((error = vnet_app_add_tls_key (a)))
1698 {
1699 rv = clib_error_get_code (error);
1700 clib_error_report (error);
1701 }
1702 vec_free (a->key);
1703done:
1704 REPLY_MACRO (VL_API_APPLICATION_TLS_KEY_ADD_REPLY);
1705}
1706
Florin Coras6cf30ad2017-04-04 23:08:23 -07001707static clib_error_t *
1708application_reaper_cb (u32 client_index)
Dave Barach68b0fb02017-02-28 15:15:56 -05001709{
Florin Coras6cf30ad2017-04-04 23:08:23 -07001710 application_t *app = application_lookup (client_index);
1711 vnet_app_detach_args_t _a, *a = &_a;
1712 if (app)
1713 {
Florin Coras15531972018-08-12 23:50:53 -07001714 a->app_index = app->app_index;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001715 vnet_application_detach (a);
1716 }
1717 return 0;
Dave Barach68b0fb02017-02-28 15:15:56 -05001718}
1719
Florin Coras6cf30ad2017-04-04 23:08:23 -07001720VL_MSG_API_REAPER_FUNCTION (application_reaper_cb);
Dave Barach68b0fb02017-02-28 15:15:56 -05001721
1722#define vl_msg_name_crc_list
1723#include <vnet/vnet_all_api_h.h>
1724#undef vl_msg_name_crc_list
1725
1726static void
1727setup_message_id_table (api_main_t * am)
1728{
1729#define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1730 foreach_vl_msg_name_crc_session;
1731#undef _
1732}
1733
1734/*
1735 * session_api_hookup
1736 * Add uri's API message handlers to the table.
1737 * vlib has alread mapped shared memory and
1738 * added the client registration handlers.
1739 * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
1740 */
1741static clib_error_t *
1742session_api_hookup (vlib_main_t * vm)
1743{
1744 api_main_t *am = &api_main;
1745
1746#define _(N,n) \
1747 vl_msg_api_set_handlers(VL_API_##N, #n, \
1748 vl_api_##n##_t_handler, \
1749 vl_noop_handler, \
1750 vl_api_##n##_t_endian, \
1751 vl_api_##n##_t_print, \
1752 sizeof(vl_api_##n##_t), 1);
1753 foreach_session_api_msg;
1754#undef _
1755
1756 /*
1757 * Messages which bounce off the data-plane to
1758 * an API client. Simply tells the message handling infra not
1759 * to free the message.
1760 *
1761 * Bounced message handlers MUST NOT block the data plane
1762 */
1763 am->message_bounce[VL_API_CONNECT_URI] = 1;
1764 am->message_bounce[VL_API_CONNECT_SOCK] = 1;
1765
1766 /*
1767 * Set up the (msg_name, crc, message-id) table
1768 */
1769 setup_message_id_table (am);
1770
1771 return 0;
1772}
1773
1774VLIB_API_INIT_FUNCTION (session_api_hookup);
Florin Coras6cf30ad2017-04-04 23:08:23 -07001775
Dave Barach68b0fb02017-02-28 15:15:56 -05001776/*
1777 * fd.io coding-style-patch-verification: ON
1778 *
1779 * Local Variables:
1780 * eval: (c-set-style "gnu")
1781 * End:
1782 */