FD.io VPP  v19.08.2-294-g37e99c22d
Vector Packet Processing
session_api.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015-2019 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>
23 #include <vnet/session/session.h>
24 
25 #include <vnet/vnet_msg_enum.h>
26 
27 #define vl_typedefs /* define message structures */
28 #include <vnet/vnet_all_api_h.h>
29 #undef vl_typedefs
30 
31 #define vl_endianfun /* define message structures */
32 #include <vnet/vnet_all_api_h.h>
33 #undef vl_endianfun
34 
35 /* instantiate all the print functions we know about */
36 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
37 #define vl_printfun
38 #include <vnet/vnet_all_api_h.h>
39 #undef vl_printfun
40 
42 
43 #define foreach_session_api_msg \
44 _(MAP_ANOTHER_SEGMENT_REPLY, map_another_segment_reply) \
45 _(APPLICATION_ATTACH, application_attach) \
46 _(APP_ATTACH, app_attach) \
47 _(APPLICATION_DETACH, application_detach) \
48 _(BIND_URI, bind_uri) \
49 _(UNBIND_URI, unbind_uri) \
50 _(CONNECT_URI, connect_uri) \
51 _(DISCONNECT_SESSION, disconnect_session) \
52 _(DISCONNECT_SESSION_REPLY, disconnect_session_reply) \
53 _(BIND_SOCK, bind_sock) \
54 _(UNBIND_SOCK, unbind_sock) \
55 _(CONNECT_SOCK, connect_sock) \
56 _(SESSION_ENABLE_DISABLE, session_enable_disable) \
57 _(APP_NAMESPACE_ADD_DEL, app_namespace_add_del) \
58 _(SESSION_RULE_ADD_DEL, session_rule_add_del) \
59 _(SESSION_RULES_DUMP, session_rules_dump) \
60 _(APPLICATION_TLS_CERT_ADD, application_tls_cert_add) \
61 _(APPLICATION_TLS_KEY_ADD, application_tls_key_add) \
62 _(APP_WORKER_ADD_DEL, app_worker_add_del) \
63 
64 static int
65 session_send_fds (vl_api_registration_t * reg, int fds[], int n_fds)
66 {
67  clib_error_t *error;
69  {
70  clib_warning ("can't send memfd fd");
71  return -1;
72  }
73  error = vl_api_send_fd_msg (reg, fds, n_fds);
74  if (error)
75  {
76  clib_error_report (error);
77  return -1;
78  }
79  return 0;
80 }
81 
82 static int
83 send_add_segment_callback (u32 api_client_index, u64 segment_handle)
84 {
85  int fds[SESSION_N_FD_TYPE], n_fds = 0;
88  fifo_segment_t *fs;
89  ssvm_private_t *sp;
90  u8 fd_flags = 0;
91 
92  reg = vl_mem_api_client_index_to_registration (api_client_index);
93  if (!reg)
94  {
95  clib_warning ("no api registration for client: %u", api_client_index);
96  return -1;
97  }
98 
99  fs = segment_manager_get_segment_w_handle (segment_handle);
100  sp = &fs->ssvm;
101  if (ssvm_type (sp) == SSVM_SEGMENT_MEMFD)
102  {
104  {
105  clib_warning ("can't send memfd fd");
106  return -1;
107  }
108 
109  fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
110  fds[n_fds] = sp->fd;
111  n_fds += 1;
112  }
113 
114  mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
115  clib_memset (mp, 0, sizeof (*mp));
116  mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MAP_ANOTHER_SEGMENT);
117  mp->segment_size = sp->ssvm_size;
118  mp->fd_flags = fd_flags;
119  mp->segment_handle = clib_host_to_net_u64 (segment_handle);
120  strncpy ((char *) mp->segment_name, (char *) sp->name,
121  sizeof (mp->segment_name) - 1);
122 
123  vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
124 
125  if (n_fds)
126  return session_send_fds (reg, fds, n_fds);
127 
128  return 0;
129 }
130 
131 static int
132 send_del_segment_callback (u32 api_client_index, u64 segment_handle)
133 {
136 
137  reg = vl_mem_api_client_index_to_registration (api_client_index);
138  if (!reg)
139  {
140  clib_warning ("no registration: %u", api_client_index);
141  return -1;
142  }
143 
144  mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
145  clib_memset (mp, 0, sizeof (*mp));
146  mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_UNMAP_SEGMENT);
147  mp->segment_handle = clib_host_to_net_u64 (segment_handle);
148  vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
149 
150  return 0;
151 }
152 
153 static int
155 {
156  int rv;
157  u8 try = 0;
158  while (try < 100)
159  {
162  SVM_Q_NOWAIT, msg);
163  if (!rv)
164  return 0;
165  try++;
166  usleep (1);
167  }
168  clib_warning ("failed to alloc msg");
169  return -1;
170 }
171 
172 static int
174 {
175  app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
176  svm_msg_q_msg_t _msg, *msg = &_msg;
177  svm_msg_q_t *vpp_queue, *app_mq;
180  session_event_t *evt;
181  application_t *app;
182 
183  app = application_get (app_wrk->app_index);
184  app_mq = app_wrk->event_queue;
185  if (mq_try_lock_and_alloc_msg (app_mq, msg))
186  return -1;
187 
188  evt = svm_msg_q_msg_data (app_mq, msg);
189  clib_memset (evt, 0, sizeof (*evt));
190  evt->event_type = SESSION_CTRL_EVT_ACCEPTED;
191  mp = (session_accepted_msg_t *) evt->data;
192  clib_memset (mp, 0, sizeof (*mp));
193  mp->context = app->app_index;
197 
198  if (session_has_transport (s))
199  {
202  if (application_is_proxy (app))
203  {
204  listener =
207  if (listener)
209  }
211  mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
212  mp->handle = session_handle (s);
213 
214  session_get_endpoint (s, &mp->rmt, 0 /* is_lcl */ );
215  }
216  else
217  {
218  ct_connection_t *ct;
219 
223  mp->rmt.is_ip4 = session_type_is_ip4 (listener->session_type);
224  mp->rmt.port = ct->c_rmt_port;
225  mp->handle = session_handle (s);
226  vpp_queue = session_main_get_vpp_event_queue (0);
227  mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
228  }
229  svm_msg_q_add_and_unlock (app_mq, msg);
230 
231  return 0;
232 }
233 
234 static inline void
236  session_evt_type_t evt_type)
237 {
238  svm_msg_q_msg_t _msg, *msg = &_msg;
240  svm_msg_q_t *app_mq;
241  session_event_t *evt;
242 
243  app_mq = app_wrk->event_queue;
244  if (mq_try_lock_and_alloc_msg (app_mq, msg))
245  return;
246  evt = svm_msg_q_msg_data (app_mq, msg);
247  clib_memset (evt, 0, sizeof (*evt));
248  evt->event_type = evt_type;
249  mp = (session_disconnected_msg_t *) evt->data;
250  mp->handle = sh;
251  mp->context = app_wrk->api_client_index;
252  svm_msg_q_add_and_unlock (app_mq, msg);
253 }
254 
255 static inline void
257  svm_fifo_t * f, session_evt_type_t evt_type)
258 {
259  app_worker_t *app_wrk;
260  application_t *app;
261  int i;
262 
263  app = application_get (app_index);
264  if (!app)
265  return;
266 
267  for (i = 0; i < f->n_subscribers; i++)
268  {
269  if (!(app_wrk = application_get_worker (app, f->subscribers[i])))
270  continue;
272  }
273 }
274 
275 static void
277 {
278  app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
280 
283 
287 }
288 
289 static void
291 {
292  app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
294 
296 
300 }
301 
302 int
303 mq_send_session_connected_cb (u32 app_wrk_index, u32 api_context,
304  session_t * s, u8 is_fail)
305 {
306  svm_msg_q_msg_t _msg, *msg = &_msg;
308  svm_msg_q_t *vpp_mq, *app_mq;
310  app_worker_t *app_wrk;
311  session_event_t *evt;
312 
313  app_wrk = app_worker_get (app_wrk_index);
314  app_mq = app_wrk->event_queue;
315  if (!app_mq)
316  {
317  clib_warning ("app %u with api index: %u not attached",
318  app_wrk->app_index, app_wrk->api_client_index);
319  return -1;
320  }
321 
322  if (mq_try_lock_and_alloc_msg (app_mq, msg))
323  return -1;
324 
325  evt = svm_msg_q_msg_data (app_mq, msg);
326  clib_memset (evt, 0, sizeof (*evt));
327  evt->event_type = SESSION_CTRL_EVT_CONNECTED;
328  mp = (session_connected_msg_t *) evt->data;
329  clib_memset (mp, 0, sizeof (*mp));
330  mp->context = api_context;
331 
332  if (is_fail)
333  goto done;
334 
335  if (session_has_transport (s))
336  {
337  tc = session_get_transport (s);
338  if (!tc)
339  {
340  is_fail = 1;
341  goto done;
342  }
343 
345  mp->handle = session_handle (s);
347 
348  session_get_endpoint (s, &mp->lcl, 1 /* is_lcl */ );
349 
353  }
354  else
355  {
356  ct_connection_t *cct;
357  session_t *ss;
358 
360  mp->handle = session_handle (s);
361  mp->lcl.port = cct->c_lcl_port;
362  mp->lcl.is_ip4 = cct->c_is_ip4;
368  ss = ct_session_get_peer (s);
369  mp->ct_rx_fifo = pointer_to_uword (ss->tx_fifo);
370  mp->ct_tx_fifo = pointer_to_uword (ss->rx_fifo);
372  }
373 
374 done:
375  mp->retval = is_fail ?
376  clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT) : 0;
377 
378  svm_msg_q_add_and_unlock (app_mq, msg);
379  return 0;
380 }
381 
382 int
383 mq_send_session_bound_cb (u32 app_wrk_index, u32 api_context,
384  session_handle_t handle, int rv)
385 {
386  svm_msg_q_msg_t _msg, *msg = &_msg;
387  svm_msg_q_t *app_mq, *vpp_evt_q;
390  app_worker_t *app_wrk;
391  session_event_t *evt;
392  app_listener_t *al;
393  session_t *ls = 0;
394  app_wrk = app_worker_get (app_wrk_index);
395  app_mq = app_wrk->event_queue;
396  if (!app_mq)
397  {
398  clib_warning ("app %u with api index: %u not attached",
399  app_wrk->app_index, app_wrk->api_client_index);
400  return -1;
401  }
402 
403  if (mq_try_lock_and_alloc_msg (app_mq, msg))
404  return -1;
405 
406  evt = svm_msg_q_msg_data (app_mq, msg);
407  clib_memset (evt, 0, sizeof (*evt));
408  evt->event_type = SESSION_CTRL_EVT_BOUND;
409  mp = (session_bound_msg_t *) evt->data;
410  mp->context = api_context;
411 
412  if (rv)
413  goto done;
414 
415  mp->handle = handle;
416  al = app_listener_get_w_handle (handle);
418  ls = app_listener_get_session (al);
419  else
421 
422  session_get_endpoint (ls, &tep, 1 /* is_lcl */ );
423  mp->lcl_port = tep.port;
424  mp->lcl_is_ip4 = tep.is_ip4;
425  clib_memcpy_fast (mp->lcl_ip, &tep.ip, sizeof (tep.ip));
426 
427  vpp_evt_q = session_main_get_vpp_event_queue (0);
428  mp->vpp_evt_q = pointer_to_uword (vpp_evt_q);
429 
431  {
432  mp->rx_fifo = pointer_to_uword (ls->rx_fifo);
433  mp->tx_fifo = pointer_to_uword (ls->tx_fifo);
434  }
435 
436 done:
437  mp->retval = rv;
438  svm_msg_q_add_and_unlock (app_mq, msg);
439  return 0;
440 }
441 
442 void
444  u32 context, int rv)
445 {
446  svm_msg_q_msg_t _msg, *msg = &_msg;
448  svm_msg_q_t *app_mq;
449  session_event_t *evt;
450 
451  app_mq = app_wrk->event_queue;
452  if (mq_try_lock_and_alloc_msg (app_mq, msg))
453  return;
454 
455  evt = svm_msg_q_msg_data (app_mq, msg);
456  clib_memset (evt, 0, sizeof (*evt));
457  evt->event_type = SESSION_CTRL_EVT_UNLISTEN_REPLY;
458  ump = (session_unlisten_reply_msg_t *) evt->data;
459  ump->context = context;
460  ump->handle = sh;
461  ump->retval = rv;
462  svm_msg_q_add_and_unlock (app_mq, msg);
463 }
464 
465 static void
467 {
468  clib_warning ("not supported");
469 }
470 
472  .session_accept_callback = mq_send_session_accepted_cb,
473  .session_disconnect_callback = mq_send_session_disconnected_cb,
474  .session_connected_callback = mq_send_session_connected_cb,
475  .session_reset_callback = mq_send_session_reset_cb,
476  .session_migrate_callback = mq_send_session_migrate_cb,
477  .add_segment_callback = send_add_segment_callback,
478  .del_segment_callback = send_del_segment_callback,
479 };
480 
481 static void
483 {
484  vl_api_session_enable_disable_reply_t *rmp;
486  int rv = 0;
487 
489  REPLY_MACRO (VL_API_SESSION_ENABLE_DISABLE_REPLY);
490 }
491 
492 /* ### WILL BE DEPRECATED POST 20.01 ### */
493 static void
495 {
496  int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
498  ssvm_private_t *segp, *evt_q_segment;
499  vnet_app_attach_args_t _a, *a = &_a;
501  u8 fd_flags = 0;
502 
504  if (!reg)
505  return;
506 
507  if (session_main_is_enabled () == 0)
508  {
509  rv = VNET_API_ERROR_FEATURE_DISABLED;
510  goto done;
511  }
512 
514  sizeof (mp->options),
515  "Out of options, fix api message definition");
516 
517  clib_memset (a, 0, sizeof (*a));
518  a->api_client_index = mp->client_index;
519  a->options = mp->options;
520  a->session_cb_vft = &session_mq_cb_vft;
521  if (mp->namespace_id_len > 64)
522  {
523  rv = VNET_API_ERROR_INVALID_VALUE;
524  goto done;
525  }
526 
527  if (mp->namespace_id_len)
528  {
529  vec_validate (a->namespace_id, mp->namespace_id_len - 1);
530  clib_memcpy_fast (a->namespace_id, mp->namespace_id,
531  mp->namespace_id_len);
532  }
533 
534  if ((rv = vnet_application_attach (a)))
535  {
536  clib_warning ("attach returned: %d", rv);
537  vec_free (a->namespace_id);
538  goto done;
539  }
540  vec_free (a->namespace_id);
541 
542  /* Send event queues segment */
543  if ((evt_q_segment = session_main_get_evt_q_segment ()))
544  {
545  fd_flags |= SESSION_FD_F_VPP_MQ_SEGMENT;
546  fds[n_fds] = evt_q_segment->fd;
547  n_fds += 1;
548  }
549  /* Send fifo segment fd if needed */
550  if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD)
551  {
552  fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
553  fds[n_fds] = a->segment->fd;
554  n_fds += 1;
555  }
556  if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
557  {
558  fd_flags |= SESSION_FD_F_MQ_EVENTFD;
559  fds[n_fds] = svm_msg_q_get_producer_eventfd (a->app_evt_q);
560  n_fds += 1;
561  }
562 
563 done:
564 
565  /* *INDENT-OFF* */
566  REPLY_MACRO2 (VL_API_APPLICATION_ATTACH_REPLY, ({
567  if (!rv)
568  {
569  segp = a->segment;
570  rmp->app_index = clib_host_to_net_u32 (a->app_index);
571  rmp->segment_name_length = 0;
572  rmp->segment_size = segp->ssvm_size;
573  if (vec_len (segp->name))
574  {
575  memcpy (rmp->segment_name, segp->name, vec_len (segp->name));
576  rmp->segment_name_length = vec_len (segp->name);
577  }
578  rmp->app_event_queue_address = pointer_to_uword (a->app_evt_q);
579  rmp->n_fds = n_fds;
580  rmp->fd_flags = fd_flags;
581  rmp->segment_handle = clib_host_to_net_u64 (a->segment_handle);
582  }
583  }));
584  /* *INDENT-ON* */
585 
586  if (n_fds)
587  session_send_fds (reg, fds, n_fds);
588 }
589 
590 static void
592 {
593  int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
595  ssvm_private_t *segp, *evt_q_segment;
596  vnet_app_attach_args_t _a, *a = &_a;
597  u8 fd_flags = 0, ctrl_thread;
599  svm_msg_q_t *ctrl_mq;
600 
602  if (!reg)
603  return;
604 
605  if (session_main_is_enabled () == 0)
606  {
607  rv = VNET_API_ERROR_FEATURE_DISABLED;
608  goto done;
609  }
610 
612  sizeof (mp->options),
613  "Out of options, fix api message definition");
614 
615  clib_memset (a, 0, sizeof (*a));
616  a->api_client_index = mp->client_index;
617  a->options = mp->options;
618  a->session_cb_vft = &session_mq_cb_vft;
619  if (mp->namespace_id_len > 64)
620  {
621  rv = VNET_API_ERROR_INVALID_VALUE;
622  goto done;
623  }
624 
625  if (mp->namespace_id_len)
626  {
627  vec_validate (a->namespace_id, mp->namespace_id_len - 1);
628  clib_memcpy_fast (a->namespace_id, mp->namespace_id,
629  mp->namespace_id_len);
630  }
631 
632  if ((rv = vnet_application_attach (a)))
633  {
634  clib_warning ("attach returned: %d", rv);
635  vec_free (a->namespace_id);
636  goto done;
637  }
638  vec_free (a->namespace_id);
639 
640  /* Send event queues segment */
641  if ((evt_q_segment = session_main_get_evt_q_segment ()))
642  {
643  fd_flags |= SESSION_FD_F_VPP_MQ_SEGMENT;
644  fds[n_fds] = evt_q_segment->fd;
645  n_fds += 1;
646  }
647  /* Send fifo segment fd if needed */
648  if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD)
649  {
650  fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
651  fds[n_fds] = a->segment->fd;
652  n_fds += 1;
653  }
654  if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
655  {
656  fd_flags |= SESSION_FD_F_MQ_EVENTFD;
657  fds[n_fds] = svm_msg_q_get_producer_eventfd (a->app_evt_q);
658  n_fds += 1;
659  }
660 
661 done:
662  /* *INDENT-OFF* */
663  REPLY_MACRO2 (VL_API_APP_ATTACH_REPLY, ({
664  if (!rv)
665  {
666  ctrl_thread = vlib_num_workers ()? 1 : 0;
667  ctrl_mq = session_main_get_vpp_event_queue (ctrl_thread);
668  segp = a->segment;
669  rmp->app_index = clib_host_to_net_u32 (a->app_index);
670  rmp->app_mq = pointer_to_uword (a->app_evt_q);
671  rmp->vpp_ctrl_mq = pointer_to_uword (ctrl_mq);
672  rmp->vpp_ctrl_mq_thread = ctrl_thread;
673  rmp->n_fds = n_fds;
674  rmp->fd_flags = fd_flags;
675  if (vec_len (segp->name))
676  {
677  memcpy (rmp->segment_name, segp->name, vec_len (segp->name));
678  rmp->segment_name_length = vec_len (segp->name);
679  }
680  rmp->segment_size = segp->ssvm_size;
681  rmp->segment_handle = clib_host_to_net_u64 (a->segment_handle);
682  }
683  }));
684  /* *INDENT-ON* */
685 
686  if (n_fds)
687  session_send_fds (reg, fds, n_fds);
688 }
689 
690 /* ### WILL BE DEPRECATED POST 20.01 ### */
691 static void
693 {
694  vl_api_application_detach_reply_t *rmp;
695  int rv = VNET_API_ERROR_INVALID_VALUE_2;
696  vnet_app_detach_args_t _a, *a = &_a;
697  application_t *app;
698 
699  if (session_main_is_enabled () == 0)
700  {
701  rv = VNET_API_ERROR_FEATURE_DISABLED;
702  goto done;
703  }
704 
705  app = application_lookup (mp->client_index);
706  if (app)
707  {
708  a->app_index = app->app_index;
709  a->api_client_index = mp->client_index;
710  rv = vnet_application_detach (a);
711  }
712 
713 done:
714  REPLY_MACRO (VL_API_APPLICATION_DETACH_REPLY);
715 }
716 
717 /* ### WILL BE DEPRECATED POST 20.01 ### */
718 static void
720 {
721  vl_api_bind_uri_reply_t *rmp;
722  vnet_listen_args_t _a, *a = &_a;
723  application_t *app = 0;
724  app_worker_t *app_wrk;
725  int rv;
726 
727  if (session_main_is_enabled () == 0)
728  {
729  rv = VNET_API_ERROR_FEATURE_DISABLED;
730  goto done;
731  }
732 
733  app = application_lookup (mp->client_index);
734  if (app)
735  {
736  clib_memset (a, 0, sizeof (*a));
737  a->uri = (char *) mp->uri;
738  a->app_index = app->app_index;
739  rv = vnet_bind_uri (a);
740  }
741  else
742  {
743  rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
744  }
745 
746 done:
747 
748  REPLY_MACRO (VL_API_BIND_URI_REPLY);
749 
750  if (app)
751  {
752  app_wrk = application_get_worker (app, 0);
753  mq_send_session_bound_cb (app_wrk->wrk_index, mp->context, a->handle,
754  rv);
755  }
756 }
757 
758 /* ### WILL BE DEPRECATED POST 20.01 ### */
759 static void
761 {
762  vl_api_unbind_uri_reply_t *rmp;
763  application_t *app;
764  vnet_unlisten_args_t _a, *a = &_a;
765  int rv;
766 
767  if (session_main_is_enabled () == 0)
768  {
769  rv = VNET_API_ERROR_FEATURE_DISABLED;
770  goto done;
771  }
772 
773  app = application_lookup (mp->client_index);
774  if (app)
775  {
776  a->uri = (char *) mp->uri;
777  a->app_index = app->app_index;
778  a->wrk_map_index = 0;
779  rv = vnet_unbind_uri (a);
780  }
781  else
782  {
783  rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
784  }
785 
786 done:
787  REPLY_MACRO (VL_API_UNBIND_URI_REPLY);
788 }
789 
790 /* ### WILL BE DEPRECATED POST 20.01 ### */
791 static void
793 {
794  vl_api_connect_uri_reply_t *rmp;
795  vnet_connect_args_t _a, *a = &_a;
796  application_t *app;
797  int rv = 0;
798 
799  if (session_main_is_enabled () == 0)
800  {
801  rv = VNET_API_ERROR_FEATURE_DISABLED;
802  goto done;
803  }
804 
805  app = application_lookup (mp->client_index);
806  if (app)
807  {
808  clib_memset (a, 0, sizeof (*a));
809  a->uri = (char *) mp->uri;
810  a->api_context = mp->context;
811  a->app_index = app->app_index;
812  if ((rv = vnet_connect_uri (a)))
813  clib_warning ("connect_uri returned: %d", rv);
814  }
815  else
816  {
817  rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
818  }
819 
820  /*
821  * Don't reply to stream (tcp) connects. The reply will come once
822  * the connection is established. In case of the redirects, the reply
823  * will come from the server app.
824  */
825  if (rv == 0)
826  return;
827 
828 done:
829  REPLY_MACRO (VL_API_CONNECT_URI_REPLY);
830 }
831 
832 /* ### WILL BE DEPRECATED POST 20.01 ### */
833 static void
835 {
837  vnet_disconnect_args_t _a, *a = &_a;
838  application_t *app;
839  int rv = 0;
840 
841  if (session_main_is_enabled () == 0)
842  {
843  rv = VNET_API_ERROR_FEATURE_DISABLED;
844  goto done;
845  }
846 
847  app = application_lookup (mp->client_index);
848  if (app)
849  {
850  a->handle = mp->handle;
851  a->app_index = app->app_index;
852  rv = vnet_disconnect_session (a);
853  }
854  else
855  {
856  rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
857  }
858 
859 done:
860  REPLY_MACRO2 (VL_API_DISCONNECT_SESSION_REPLY, rmp->handle = mp->handle);
861 }
862 
863 /* ### WILL BE DEPRECATED POST 20.01 ### */
864 static void
866  mp)
867 {
868  vnet_disconnect_args_t _a, *a = &_a;
869  application_t *app;
870 
871  /* Client objected to disconnecting the session, log and continue */
872  if (mp->retval)
873  {
874  clib_warning ("client retval %d", mp->retval);
875  return;
876  }
877 
878  /* Disconnect has been confirmed. Confirm close to transport */
879  app = application_lookup (mp->context);
880  if (app)
881  {
882  a->handle = mp->handle;
883  a->app_index = app->app_index;
885  }
886 }
887 
888 static void
889 vl_api_map_another_segment_reply_t_handler (vl_api_map_another_segment_reply_t
890  * mp)
891 {
892  clib_warning ("not implemented");
893 }
894 
895 /* ### WILL BE DEPRECATED POST 20.01 ### */
896 static void
898 {
899  vnet_listen_args_t _a, *a = &_a;
900  vl_api_bind_sock_reply_t *rmp;
901  application_t *app = 0;
902  app_worker_t *app_wrk;
903  ip46_address_t *ip46;
904  int rv = 0;
905 
906  if (session_main_is_enabled () == 0)
907  {
908  rv = VNET_API_ERROR_FEATURE_DISABLED;
909  goto done;
910  }
911 
912  app = application_lookup (mp->client_index);
913  if (!app)
914  {
915  rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
916  goto done;
917  }
918 
919  ip46 = (ip46_address_t *) mp->ip;
920  clib_memset (a, 0, sizeof (*a));
921  a->sep.is_ip4 = mp->is_ip4;
922  a->sep.ip = *ip46;
923  a->sep.port = mp->port;
924  a->sep.fib_index = mp->vrf;
925  a->sep.sw_if_index = ENDPOINT_INVALID_INDEX;
926  a->sep.transport_proto = mp->proto;
927  a->app_index = app->app_index;
928  a->wrk_map_index = mp->wrk_index;
929 
930  if ((rv = vnet_listen (a)))
931  clib_warning ("listen returned: %d", rv);
932 
933 done:
934  /* Actual reply sent only over mq */
935  REPLY_MACRO (VL_API_BIND_SOCK_REPLY);
936 
937  if (app)
938  {
939  app_wrk = application_get_worker (app, mp->wrk_index);
940  mq_send_session_bound_cb (app_wrk->wrk_index, mp->context, a->handle,
941  rv);
942  }
943 }
944 
945 /* ### WILL BE DEPRECATED POST 20.01 ### */
946 static void
948 {
949  vl_api_unbind_sock_reply_t *rmp;
950  vnet_unlisten_args_t _a, *a = &_a;
951  app_worker_t *app_wrk;
952  application_t *app = 0;
953  int rv = 0;
954 
955  if (session_main_is_enabled () == 0)
956  {
957  rv = VNET_API_ERROR_FEATURE_DISABLED;
958  goto done;
959  }
960 
961  app = application_lookup (mp->client_index);
962  if (app)
963  {
964  a->app_index = app->app_index;
965  a->handle = mp->handle;
966  a->wrk_map_index = mp->wrk_index;
967  if ((rv = vnet_unlisten (a)))
968  clib_warning ("unlisten returned: %d", rv);
969  }
970  else
971  {
972  rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
973  }
974 
975 done:
976  REPLY_MACRO (VL_API_UNBIND_SOCK_REPLY);
977 
978  if (!app)
979  return;
980 
981  app_wrk = application_get_worker (app, a->wrk_map_index);
982  if (!app_wrk)
983  return;
984 
985  mq_send_unlisten_reply (app_wrk, mp->handle, mp->context, rv);
986 }
987 
988 /* ### WILL BE DEPRECATED POST 20.01 ### */
989 static void
991 {
992  vl_api_connect_sock_reply_t *rmp;
993  vnet_connect_args_t _a, *a = &_a;
994  application_t *app = 0;
995  int rv = 0;
996 
997  if (session_main_is_enabled () == 0)
998  {
999  rv = VNET_API_ERROR_FEATURE_DISABLED;
1000  goto done;
1001  }
1002 
1003  app = application_lookup (mp->client_index);
1004  if (app)
1005  {
1006  svm_queue_t *client_q;
1007  ip46_address_t *ip46 = (ip46_address_t *) mp->ip;
1008 
1009  clib_memset (a, 0, sizeof (*a));
1011  mp->client_queue_address = pointer_to_uword (client_q);
1012  a->sep.is_ip4 = mp->is_ip4;
1013  a->sep.ip = *ip46;
1014  a->sep.port = mp->port;
1015  a->sep.transport_proto = mp->proto;
1016  a->sep.peer.fib_index = mp->vrf;
1017  a->sep.peer.sw_if_index = ENDPOINT_INVALID_INDEX;
1018  a->sep_ext.parent_handle = mp->parent_handle;
1019  if (mp->hostname_len)
1020  {
1021  vec_validate (a->sep_ext.hostname, mp->hostname_len - 1);
1022  clib_memcpy_fast (a->sep_ext.hostname, mp->hostname,
1023  mp->hostname_len);
1024  }
1025  a->api_context = mp->context;
1026  a->app_index = app->app_index;
1027  a->wrk_map_index = mp->wrk_index;
1028  if ((rv = vnet_connect (a)))
1029  clib_warning ("connect returned: %U", format_vnet_api_errno, rv);
1030  vec_free (a->sep_ext.hostname);
1031  }
1032  else
1033  {
1034  rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1035  }
1036 
1037  if (rv == 0)
1038  return;
1039 
1040  /* Got some error, relay it */
1041 
1042 done:
1043  REPLY_MACRO (VL_API_CONNECT_SOCK_REPLY);
1044 
1045  if (app)
1046  {
1047  app_worker_t *app_wrk = application_get_worker (app, mp->wrk_index);
1048  mq_send_session_connected_cb (app_wrk->wrk_index, mp->context, 0, 1);
1049  }
1050 }
1051 
1052 static void
1054 {
1055  int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0;
1057  vl_api_registration_t *reg;
1058  application_t *app;
1059  u8 fd_flags = 0;
1060 
1061  if (!session_main_is_enabled ())
1062  {
1063  rv = VNET_API_ERROR_FEATURE_DISABLED;
1064  goto done;
1065  }
1066 
1068  if (!reg)
1069  return;
1070 
1071  app = application_get_if_valid (clib_net_to_host_u32 (mp->app_index));
1072  if (!app)
1073  {
1074  rv = VNET_API_ERROR_INVALID_VALUE;
1075  goto done;
1076  }
1077 
1079  .app_index = app->app_index,
1080  .wrk_map_index = clib_net_to_host_u32 (mp->wrk_index),
1081  .api_client_index = mp->client_index,
1082  .is_add = mp->is_add
1083  };
1084  rv = vnet_app_worker_add_del (&args);
1085  if (rv)
1086  {
1087  clib_warning ("app worker add/del returned: %d", rv);
1088  goto done;
1089  }
1090 
1091  if (!mp->is_add)
1092  goto done;
1093 
1094  /* Send fifo segment fd if needed */
1095  if (ssvm_type (args.segment) == SSVM_SEGMENT_MEMFD)
1096  {
1097  fd_flags |= SESSION_FD_F_MEMFD_SEGMENT;
1098  fds[n_fds] = args.segment->fd;
1099  n_fds += 1;
1100  }
1101  if (application_segment_manager_properties (app)->use_mq_eventfd)
1102  {
1103  fd_flags |= SESSION_FD_F_MQ_EVENTFD;
1104  fds[n_fds] = svm_msg_q_get_producer_eventfd (args.evt_q);
1105  n_fds += 1;
1106  }
1107 
1108  /* *INDENT-OFF* */
1109 done:
1110  REPLY_MACRO2 (VL_API_APP_WORKER_ADD_DEL_REPLY, ({
1111  rmp->is_add = mp->is_add;
1112  rmp->wrk_index = clib_host_to_net_u32 (args.wrk_map_index);
1113  rmp->segment_handle = clib_host_to_net_u64 (args.segment_handle);
1114  if (!rv && mp->is_add)
1115  {
1116  if (vec_len (args.segment->name))
1117  {
1118  memcpy (rmp->segment_name, args.segment->name,
1119  vec_len (args.segment->name));
1120  rmp->segment_name_length = vec_len (args.segment->name);
1121  }
1122  rmp->app_event_queue_address = pointer_to_uword (args.evt_q);
1123  rmp->n_fds = n_fds;
1124  rmp->fd_flags = fd_flags;
1125  }
1126  }));
1127  /* *INDENT-ON* */
1128 
1129  if (n_fds)
1130  session_send_fds (reg, fds, n_fds);
1131 }
1132 
1133 static void
1135 {
1137  u32 appns_index = 0;
1138  u8 *ns_id = 0;
1139  int rv = 0;
1140  if (!session_main_is_enabled ())
1141  {
1142  rv = VNET_API_ERROR_FEATURE_DISABLED;
1143  goto done;
1144  }
1145 
1146  if (mp->namespace_id_len > ARRAY_LEN (mp->namespace_id))
1147  {
1148  rv = VNET_API_ERROR_INVALID_VALUE;
1149  goto done;
1150  }
1151 
1152  vec_validate (ns_id, mp->namespace_id_len - 1);
1155  .ns_id = ns_id,
1156  .secret = clib_net_to_host_u64 (mp->secret),
1157  .sw_if_index = clib_net_to_host_u32 (mp->sw_if_index),
1158  .ip4_fib_id = clib_net_to_host_u32 (mp->ip4_fib_id),
1159  .ip6_fib_id = clib_net_to_host_u32 (mp->ip6_fib_id),
1160  .is_add = 1
1161  };
1162  rv = vnet_app_namespace_add_del (&args);
1163  if (!rv)
1164  {
1165  appns_index = app_namespace_index_from_id (ns_id);
1166  if (appns_index == APP_NAMESPACE_INVALID_INDEX)
1167  {
1168  clib_warning ("app ns lookup failed");
1169  rv = VNET_API_ERROR_UNSPECIFIED;
1170  }
1171  }
1172  vec_free (ns_id);
1173 
1174  /* *INDENT-OFF* */
1175 done:
1176  REPLY_MACRO2 (VL_API_APP_NAMESPACE_ADD_DEL_REPLY, ({
1177  if (!rv)
1178  rmp->appns_index = clib_host_to_net_u32 (appns_index);
1179  }));
1180  /* *INDENT-ON* */
1181 }
1182 
1183 static void
1185 {
1186  vl_api_session_rule_add_del_reply_t *rmp;
1188  session_rule_table_add_del_args_t *table_args = &args.table_args;
1189  u8 fib_proto;
1190  int rv = 0;
1191 
1192  clib_memset (&args, 0, sizeof (args));
1193  fib_proto = mp->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
1194 
1195  table_args->lcl.fp_len = mp->lcl_plen;
1196  table_args->lcl.fp_proto = fib_proto;
1197  table_args->rmt.fp_len = mp->rmt_plen;
1198  table_args->rmt.fp_proto = fib_proto;
1199  table_args->lcl_port = mp->lcl_port;
1200  table_args->rmt_port = mp->rmt_port;
1201  table_args->action_index = clib_net_to_host_u32 (mp->action_index);
1202  table_args->is_add = mp->is_add;
1203  mp->tag[sizeof (mp->tag) - 1] = 0;
1204  table_args->tag = format (0, "%s", mp->tag);
1205  args.appns_index = clib_net_to_host_u32 (mp->appns_index);
1206  args.scope = mp->scope;
1207  args.transport_proto = mp->transport_proto;
1208 
1209  clib_memset (&table_args->lcl.fp_addr, 0, sizeof (table_args->lcl.fp_addr));
1210  clib_memset (&table_args->rmt.fp_addr, 0, sizeof (table_args->rmt.fp_addr));
1211  ip_set (&table_args->lcl.fp_addr, mp->lcl_ip, mp->is_ip4);
1212  ip_set (&table_args->rmt.fp_addr, mp->rmt_ip, mp->is_ip4);
1213  rv = vnet_session_rule_add_del (&args);
1214  if (rv)
1215  clib_warning ("rule add del returned: %d", rv);
1216  vec_free (table_args->tag);
1217  REPLY_MACRO (VL_API_SESSION_RULE_ADD_DEL_REPLY);
1218 }
1219 
1220 static void
1221 send_session_rule_details4 (mma_rule_16_t * rule, u8 is_local,
1222  u8 transport_proto, u32 appns_index, u8 * tag,
1224 {
1226  session_mask_or_match_4_t *match =
1227  (session_mask_or_match_4_t *) & rule->match;
1228  session_mask_or_match_4_t *mask =
1229  (session_mask_or_match_4_t *) & rule->mask;
1230 
1231  rmp = vl_msg_api_alloc (sizeof (*rmp));
1232  clib_memset (rmp, 0, sizeof (*rmp));
1233  rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
1234  rmp->context = context;
1235 
1236  rmp->is_ip4 = 1;
1237  clib_memcpy_fast (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
1238  clib_memcpy_fast (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
1239  rmp->lcl_plen = ip4_mask_to_preflen (&mask->lcl_ip);
1240  rmp->rmt_plen = ip4_mask_to_preflen (&mask->rmt_ip);
1241  rmp->lcl_port = match->lcl_port;
1242  rmp->rmt_port = match->rmt_port;
1243  rmp->action_index = clib_host_to_net_u32 (rule->action_index);
1244  rmp->scope =
1246  rmp->transport_proto = transport_proto;
1247  rmp->appns_index = clib_host_to_net_u32 (appns_index);
1248  if (tag)
1249  {
1250  clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
1251  rmp->tag[vec_len (tag)] = 0;
1252  }
1253 
1254  vl_api_send_msg (reg, (u8 *) rmp);
1255 }
1256 
1257 static void
1258 send_session_rule_details6 (mma_rule_40_t * rule, u8 is_local,
1259  u8 transport_proto, u32 appns_index, u8 * tag,
1261 {
1263  session_mask_or_match_6_t *match =
1264  (session_mask_or_match_6_t *) & rule->match;
1265  session_mask_or_match_6_t *mask =
1266  (session_mask_or_match_6_t *) & rule->mask;
1267 
1268  rmp = vl_msg_api_alloc (sizeof (*rmp));
1269  clib_memset (rmp, 0, sizeof (*rmp));
1270  rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
1271  rmp->context = context;
1272 
1273  rmp->is_ip4 = 0;
1274  clib_memcpy_fast (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
1275  clib_memcpy_fast (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
1276  rmp->lcl_plen = ip6_mask_to_preflen (&mask->lcl_ip);
1277  rmp->rmt_plen = ip6_mask_to_preflen (&mask->rmt_ip);
1278  rmp->lcl_port = match->lcl_port;
1279  rmp->rmt_port = match->rmt_port;
1280  rmp->action_index = clib_host_to_net_u32 (rule->action_index);
1281  rmp->scope =
1283  rmp->transport_proto = transport_proto;
1284  rmp->appns_index = clib_host_to_net_u32 (appns_index);
1285  if (tag)
1286  {
1287  clib_memcpy_fast (rmp->tag, tag, vec_len (tag));
1288  rmp->tag[vec_len (tag)] = 0;
1289  }
1290 
1291  vl_api_send_msg (reg, (u8 *) rmp);
1292 }
1293 
1294 static void
1296  u8 tp, u8 is_local, u32 appns_index,
1298 {
1299  mma_rule_16_t *rule16;
1300  mma_rule_40_t *rule40;
1301  mma_rules_table_16_t *srt16;
1302  mma_rules_table_40_t *srt40;
1303  u32 ri;
1304 
1305  if (is_local || fib_proto == FIB_PROTOCOL_IP4)
1306  {
1307  u8 *tag = 0;
1308  /* *INDENT-OFF* */
1309  srt16 = &srt->session_rules_tables_16;
1310  pool_foreach (rule16, srt16->rules, ({
1311  ri = mma_rules_table_rule_index_16 (srt16, rule16);
1312  tag = session_rules_table_rule_tag (srt, ri, 1);
1313  send_session_rule_details4 (rule16, is_local, tp, appns_index, tag,
1314  reg, context);
1315  }));
1316  /* *INDENT-ON* */
1317  }
1318  if (is_local || fib_proto == FIB_PROTOCOL_IP6)
1319  {
1320  u8 *tag = 0;
1321  /* *INDENT-OFF* */
1322  srt40 = &srt->session_rules_tables_40;
1323  pool_foreach (rule40, srt40->rules, ({
1324  ri = mma_rules_table_rule_index_40 (srt40, rule40);
1325  tag = session_rules_table_rule_tag (srt, ri, 1);
1326  send_session_rule_details6 (rule40, is_local, tp, appns_index, tag,
1327  reg, context);
1328  }));
1329  /* *INDENT-ON* */
1330  }
1331 }
1332 
1333 static void
1335 {
1336  vl_api_registration_t *reg;
1337  session_table_t *st;
1338  u8 tp;
1339 
1341  if (!reg)
1342  return;
1343 
1344  /* *INDENT-OFF* */
1345  session_table_foreach (st, ({
1346  for (tp = 0; tp < TRANSPORT_N_PROTO; tp++)
1347  {
1348  send_session_rules_table_details (&st->session_rules[tp],
1349  st->active_fib_proto, tp,
1350  st->is_local, st->appns_index, reg,
1351  mp->context);
1352  }
1353  }));
1354  /* *INDENT-ON* */
1355 }
1356 
1357 static void
1359  mp)
1360 {
1362  vnet_app_add_tls_cert_args_t _a, *a = &_a;
1363  clib_error_t *error;
1364  application_t *app;
1365  u32 cert_len;
1366  int rv = 0;
1367  if (!session_main_is_enabled ())
1368  {
1369  rv = VNET_API_ERROR_FEATURE_DISABLED;
1370  goto done;
1371  }
1372  if (!(app = application_lookup (mp->client_index)))
1373  {
1374  rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1375  goto done;
1376  }
1377  clib_memset (a, 0, sizeof (*a));
1378  a->app_index = app->app_index;
1379  cert_len = clib_net_to_host_u16 (mp->cert_len);
1380  if (cert_len > 10000)
1381  {
1382  rv = VNET_API_ERROR_INVALID_VALUE;
1383  goto done;
1384  }
1385  vec_validate (a->cert, cert_len);
1386  clib_memcpy_fast (a->cert, mp->cert, cert_len);
1387  if ((error = vnet_app_add_tls_cert (a)))
1388  {
1389  rv = clib_error_get_code (error);
1390  clib_error_report (error);
1391  }
1392  vec_free (a->cert);
1393 done:
1394  REPLY_MACRO (VL_API_APPLICATION_TLS_CERT_ADD_REPLY);
1395 }
1396 
1397 static void
1399  mp)
1400 {
1402  vnet_app_add_tls_key_args_t _a, *a = &_a;
1403  clib_error_t *error;
1404  application_t *app;
1405  u32 key_len;
1406  int rv = 0;
1407  if (!session_main_is_enabled ())
1408  {
1409  rv = VNET_API_ERROR_FEATURE_DISABLED;
1410  goto done;
1411  }
1412  if (!(app = application_lookup (mp->client_index)))
1413  {
1414  rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1415  goto done;
1416  }
1417  clib_memset (a, 0, sizeof (*a));
1418  a->app_index = app->app_index;
1419  key_len = clib_net_to_host_u16 (mp->key_len);
1420  if (key_len > 10000)
1421  {
1422  rv = VNET_API_ERROR_INVALID_VALUE;
1423  goto done;
1424  }
1425  vec_validate (a->key, key_len);
1426  clib_memcpy_fast (a->key, mp->key, key_len);
1427  if ((error = vnet_app_add_tls_key (a)))
1428  {
1429  rv = clib_error_get_code (error);
1430  clib_error_report (error);
1431  }
1432  vec_free (a->key);
1433 done:
1434  REPLY_MACRO (VL_API_APPLICATION_TLS_KEY_ADD_REPLY);
1435 }
1436 
1437 static clib_error_t *
1439 {
1440  application_t *app = application_lookup (client_index);
1441  vnet_app_detach_args_t _a, *a = &_a;
1442  if (app)
1443  {
1444  a->app_index = app->app_index;
1445  a->api_client_index = client_index;
1447  }
1448  return 0;
1449 }
1450 
1452 
1453 #define vl_msg_name_crc_list
1454 #include <vnet/vnet_all_api_h.h>
1455 #undef vl_msg_name_crc_list
1456 
1457 static void
1459 {
1460 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1461  foreach_vl_msg_name_crc_session;
1462 #undef _
1463 }
1464 
1465 /*
1466  * session_api_hookup
1467  * Add uri's API message handlers to the table.
1468  * vlib has already mapped shared memory and
1469  * added the client registration handlers.
1470  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
1471  */
1472 static clib_error_t *
1474 {
1475  api_main_t *am = &api_main;
1476 
1477 #define _(N,n) \
1478  vl_msg_api_set_handlers(VL_API_##N, #n, \
1479  vl_api_##n##_t_handler, \
1480  vl_noop_handler, \
1481  vl_api_##n##_t_endian, \
1482  vl_api_##n##_t_print, \
1483  sizeof(vl_api_##n##_t), 1);
1485 #undef _
1486 
1487  /*
1488  * Messages which bounce off the data-plane to
1489  * an API client. Simply tells the message handling infra not
1490  * to free the message.
1491  *
1492  * Bounced message handlers MUST NOT block the data plane
1493  */
1494  am->message_bounce[VL_API_CONNECT_URI] = 1;
1495  am->message_bounce[VL_API_CONNECT_SOCK] = 1;
1496 
1497  /*
1498  * Set up the (msg_name, crc, message-id) table
1499  */
1501 
1502  return 0;
1503 }
1504 
1506 
1507 /*
1508  * fd.io coding-style-patch-verification: ON
1509  *
1510  * Local Variables:
1511  * eval: (c-set-style "gnu")
1512  * End:
1513  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
static void vl_api_disconnect_session_reply_t_handler(vl_api_disconnect_session_reply_t *mp)
Definition: session_api.c:865
u64 ssvm_size
Definition: ssvm.h:85
struct _vnet_app_worker_add_del_args vnet_app_worker_add_del_args_t
#define ENDPOINT_INVALID_INDEX
#define APP_NAMESPACE_INVALID_INDEX
static clib_error_t * session_api_hookup(vlib_main_t *vm)
Definition: session_api.c:1473
void * svm_msg_q_msg_data(svm_msg_q_t *mq, svm_msg_q_msg_t *msg)
Get data for message in queue.
session_type_t session_type
Type built from transport and network protocol types.
static int send_del_segment_callback(u32 api_client_index, u64 segment_handle)
Definition: session_api.c:132
void mq_send_unlisten_reply(app_worker_t *app_wrk, session_handle_t sh, u32 context, int rv)
Definition: session_api.c:443
static void mq_notify_close_subscribers(u32 app_index, session_handle_t sh, svm_fifo_t *f, session_evt_type_t evt_type)
Definition: session_api.c:256
transport_endpoint_t rmt
a
Definition: bitmap.h:538
VL_MSG_API_REAPER_FUNCTION(application_reaper_cb)
svm_fifo_t * tx_fifo
struct _session_rules_table_t session_rules_table_t
struct _vnet_connect_args vnet_connect_args_t
Application add TLS key.
Definition: session.api:131
struct _vnet_unlisten_args_t vnet_unlisten_args_t
static void vl_api_app_namespace_add_del_t_handler(vl_api_app_namespace_add_del_t *mp)
Definition: session_api.c:1134
int vnet_app_namespace_add_del(vnet_app_namespace_add_del_args_t *a)
unsigned long u64
Definition: types.h:89
static svm_msg_q_t * session_main_get_vpp_event_queue(u32 thread_index)
Definition: session.h:607
void ip_set(ip46_address_t *dst, void *src, u8 is_ip4)
Definition: ip.c:93
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
static void mq_send_session_close_evt(app_worker_t *app_wrk, session_handle_t sh, session_evt_type_t evt_type)
Definition: session_api.c:235
#define REPLY_MACRO2(t, body)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
transport_connection_t * session_get_transport(session_t *s)
Definition: session.c:1468
add/del session rule
Definition: session.api:462
svm_fifo_t * rx_fifo
Pointers to rx/tx buffers.
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:35
u8 * message_bounce
Don&#39;t automatically free message buffer vetor.
Definition: api_common.h:223
fifo_segment_t * segment_manager_get_segment_w_handle(u64 segment_handle)
Session rules details.
Definition: session.api:506
static session_t * listen_session_get_from_handle(session_handle_t handle)
Definition: session.h:546
static void vl_api_map_another_segment_reply_t_handler(vl_api_map_another_segment_reply_t *mp)
Definition: session_api.c:889
Bind to an ip:port pair for a given transport protocol WILL BE DEPRECATED POST 20.01
Definition: session.api:268
static int svm_msg_q_get_producer_eventfd(svm_msg_q_t *mq)
session_evt_type_t
static transport_proto_t session_get_transport_proto(session_t *s)
struct _vnet_app_namespace_add_del_args vnet_app_namespace_add_del_args_t
application_t * application_lookup(u32 api_client_index)
Definition: application.c:386
int i
Request for map server summary status.
Definition: one.api:883
static void vl_api_unbind_sock_t_handler(vl_api_unbind_sock_t *mp)
Definition: session_api.c:947
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
int vnet_unlisten(vnet_unlisten_args_t *a)
Definition: application.c:1039
#define foreach_session_api_msg
Definition: session_api.c:43
struct _vnet_application_add_tls_cert_args_t vnet_app_add_tls_cert_args_t
void * vl_msg_api_alloc(int nbytes)
clib_error_t * vnet_app_add_tls_cert(vnet_app_add_tls_cert_args_t *a)
Definition: application.c:1306
unsigned char u8
Definition: types.h:56
app_worker_t * application_get_worker(application_t *app, u32 wrk_map_index)
Definition: application.c:644
application_t * application_get_if_valid(u32 app_index)
Definition: application.c:426
struct _vnet_bind_args_t vnet_listen_args_t
segment_manager_props_t * application_segment_manager_properties(application_t *app)
Definition: application.c:1293
static session_handle_t session_handle(session_t *s)
struct _svm_fifo svm_fifo_t
void session_get_endpoint(session_t *s, transport_endpoint_t *tep, u8 is_lcl)
Definition: session.c:1479
int svm_msg_q_lock_and_alloc_msg_w_ring(svm_msg_q_t *mq, u32 ring_index, u8 noblock, svm_msg_q_msg_t *msg)
Lock message queue and allocate message buffer on ring.
Reply for app worker add/del.
Definition: session.api:380
int application_is_proxy(application_t *app)
Definition: application.c:1123
static void vl_api_connect_uri_t_handler(vl_api_connect_uri_t *mp)
Definition: session_api.c:792
static void mq_send_session_reset_cb(session_t *s)
Definition: session_api.c:290
static void vl_api_session_enable_disable_t_handler(vl_api_session_enable_disable_t *mp)
Definition: session_api.c:482
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:493
struct _vnet_disconnect_args_t vnet_disconnect_args_t
Application attach reply.
Definition: session.api:96
u32 session_index
global listening session index
Definition: application.h:80
vl_api_registration_t * vl_mem_api_client_index_to_registration(u32 handle)
Definition: memory_api.c:797
add/del application namespace
Definition: session.api:420
static void vl_api_application_tls_cert_add_t_handler(vl_api_application_tls_cert_add_t *mp)
Definition: session_api.c:1358
unsigned int u32
Definition: types.h:88
static void send_session_rule_details4(mma_rule_16_t *rule, u8 is_local, u8 transport_proto, u32 appns_index, u8 *tag, vl_api_registration_t *reg, u32 context)
Definition: session_api.c:1221
u32 app_namespace_index_from_id(const u8 *ns_id)
void vl_msg_api_send_shmem(svm_queue_t *q, u8 *elem)
struct _vnet_app_attach_args_t vnet_app_attach_args_t
static void vl_api_app_worker_add_del_t_handler(vl_api_app_worker_add_del_t *mp)
Definition: session_api.c:1053
vpp->client unmap shared memory segment
Definition: session.api:174
static void vl_api_session_rules_dump_t_handler(vl_api_one_map_server_dump_t *mp)
Definition: session_api.c:1334
clib_error_t * vnet_app_add_tls_key(vnet_app_add_tls_key_args_t *a)
Definition: application.c:1318
Unbind WILL BE DEPRECATED POST 20.01 ###s
Definition: session.api:287
session_t * app_listener_get_local_session(app_listener_t *al)
Definition: application.c:281
#define VL_API_INVALID_FI
Definition: api_common.h:77
svm_queue_t * vl_input_queue
shared memory only: pointer to client input queue
Definition: api_common.h:61
session_t * app_listener_get_session(app_listener_t *al)
Definition: application.c:272
struct _session_rule_add_del_args session_rule_add_del_args_t
client->vpp, attach application to session layer WILL BE DEPRECATED POST 20.01
Definition: session.api:28
u8 hostname[hostname_len]
Definition: session.api:325
static void vl_api_disconnect_session_t_handler(vl_api_disconnect_session_t *mp)
Definition: session_api.c:834
static int session_send_fds(vl_api_registration_t *reg, int fds[], int n_fds)
Definition: session_api.c:65
int vnet_session_rule_add_del(session_rule_add_del_args_t *args)
#define REPLY_MACRO(t)
static clib_error_t * application_reaper_cb(u32 client_index)
Definition: session_api.c:1438
Unbind a given URI WILL BE DEPRECATED POST 20.01
Definition: session.api:204
u32 wrk_index
Worker index in global worker pool.
Definition: application.h:37
#define SESSION_INVALID_INDEX
Definition: session_types.h:22
static u8 * format_vnet_api_errno(u8 *s, va_list *args)
Definition: api_errno.h:164
u64 session_segment_handle(session_t *s)
Definition: session.c:1410
clib_error_t * vnet_session_enable_disable(vlib_main_t *vm, u8 is_en)
Definition: session.c:1613
session_handle_t app_listen_session_handle(session_t *ls)
Get app listener handle for listening session.
Definition: application.c:78
static u64 listen_session_get_handle(session_t *s)
Definition: session.h:538
u32 ip6_mask_to_preflen(ip6_address_t *mask)
Definition: ip.c:274
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:203
int vnet_application_attach(vnet_app_attach_args_t *a)
Attach application to vpp.
Definition: application.c:809
static int mq_try_lock_and_alloc_msg(svm_msg_q_t *app_mq, svm_msg_q_msg_t *msg)
Definition: session_api.c:154
An API client registration, only in vpp/vlib.
Definition: api_common.h:46
ssvm_private_t ssvm
ssvm segment data
Definition: fifo_segment.h:52
session_handle_t listener_handle
Parent listener session index if the result of an accept.
vlib_main_t * vm
Definition: buffer.c:323
session_t * app_worker_first_listener(app_worker_t *app, u8 fib_proto, u8 transport_proto)
svm_queue_t * vl_api_client_index_to_input_queue(u32 index)
Definition: memory_api.c:826
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
#define clib_warning(format, args...)
Definition: error.h:59
struct _stream_session_cb_vft session_cb_vft_t
struct _transport_connection transport_connection_t
static void mq_send_session_disconnected_cb(session_t *s)
Definition: session_api.c:276
u32 ip4_mask_to_preflen(ip4_address_t *mask)
Definition: ip.c:212
static void send_session_rules_table_details(session_rules_table_t *srt, u8 fib_proto, u8 tp, u8 is_local, u32 appns_index, vl_api_registration_t *reg, u32 context)
Definition: session_api.c:1295
#define ARRAY_LEN(x)
Definition: clib.h:63
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:57
Application attach reply WILL BE DEPRECATED POST 20.01
Definition: session.api:52
static clib_error_t * vl_api_send_fd_msg(vl_api_registration_t *reg, int fds[], int n_fds)
Definition: api.h:85
static u32 vl_api_registration_file_index(vl_api_registration_t *reg)
Definition: api.h:65
application_t * application_get(u32 app_index)
Definition: application.c:418
int vnet_unbind_uri(vnet_unlisten_args_t *a)
static void send_session_rule_details6(mma_rule_40_t *rule, u8 is_local, u8 transport_proto, u32 appns_index, u8 *tag, vl_api_registration_t *reg, u32 context)
Definition: session_api.c:1258
int fd
memfd segments
Definition: ssvm.h:93
app_listener_t * app_listener_get_w_handle(session_handle_t handle)
Get app listener for listener session handle.
Definition: application.c:88
void svm_msg_q_add_and_unlock(svm_msg_q_t *mq, svm_msg_q_msg_t *msg)
Producer enqueue one message to queue with mutex held.
enable/disable session layer
Definition: session.api:400
static void vl_api_connect_sock_t_handler(vl_api_connect_sock_t *mp)
Definition: session_api.c:990
session_t * ct_session_get_peer(session_t *s)
Reply for app namespace add/del.
Definition: session.api:436
client->vpp, attach application to session layer WILL BE DEPRECATED POST 20.01
Definition: session.api:144
int vnet_listen(vnet_listen_args_t *a)
Definition: application.c:947
static fib_protocol_t session_get_fib_proto(session_t *s)
static void mq_send_session_migrate_cb(session_t *s, session_handle_t new_sh)
Definition: session_api.c:466
int vnet_application_detach(vnet_app_detach_args_t *a)
Detach application from vpp.
Definition: application.c:869
struct _vnet_application_add_tls_key_args_t vnet_app_add_tls_key_args_t
static void vl_api_bind_sock_t_handler(vl_api_bind_sock_t *mp)
Definition: session_api.c:897
vpp->client, please map an additional shared memory segment
Definition: session.api:159
#define clib_error_report(e)
Definition: error.h:113
static int mq_send_session_accepted_cb(session_t *s)
Definition: session_api.c:173
static void vl_api_app_attach_t_handler(vl_api_app_attach_t *mp)
Definition: session_api.c:591
struct _vnet_app_detach_args_t vnet_app_detach_args_t
static uword pointer_to_uword(const void *p)
Definition: types.h:131
int vnet_connect(vnet_connect_args_t *a)
Definition: application.c:1001
Connect to a remote peer WILL BE DEPRECATED POST 20.01
Definition: session.api:312
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u8 * name
Definition: ssvm.h:87
u8 thread_index
Index of the thread that allocated the session.
static void vl_api_application_attach_t_handler(vl_api_application_attach_t *mp)
Definition: session_api.c:494
static void setup_message_id_table(api_main_t *am)
Definition: session_api.c:1458
u32 app_index
App index in app pool.
Definition: application.h:89
static u8 session_type_is_ip4(session_type_t st)
bidirectional disconnect API WILL BE DEPRECATED POST 20.01
Definition: session.api:236
static session_cb_vft_t session_mq_cb_vft
Definition: session_api.c:471
add/del application worker
Definition: session.api:359
app_worker_t * app_worker_get(u32 wrk_index)
u64 session_handle_t
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Bind to a given URI WILL BE DEPRECATED POST 20.01
Definition: session.api:189
#define STATIC_ASSERT(truth,...)
static void vl_api_application_tls_key_add_t_handler(vl_api_application_tls_key_add_t *mp)
Definition: session_api.c:1398
int vnet_bind_uri(vnet_listen_args_t *a)
ssvm_private_t * session_main_get_evt_q_segment(void)
Definition: session.c:1401
connectionless service
#define clib_error_get_code(err)
Definition: error.h:77
int vnet_disconnect_session(vnet_disconnect_args_t *a)
Definition: application.c:1070
VLIB_API_INIT_FUNCTION(session_api_hookup)
struct _session_lookup_table session_table_t
int vnet_app_worker_add_del(vnet_app_worker_add_del_args_t *a)
Definition: application.c:717
struct _svm_queue svm_queue_t
void * vl_mem_api_alloc_as_if_client_w_reg(vl_api_registration_t *reg, int nbytes)
static void vl_api_application_detach_t_handler(vl_api_application_detach_t *mp)
Definition: session_api.c:692
static u8 session_has_transport(session_t *s)
struct _session_rules_table_add_del_args session_rule_table_add_del_args_t
u32 app_index
Index of owning app.
Definition: application.h:43
static u8 svm_fifo_n_subscribers(svm_fifo_t *f)
Definition: svm_fifo.h:680
#define session_table_foreach(VAR, BODY)
Definition: session_table.h:75
Application add TLS certificate.
Definition: session.api:117
static u32 vlib_num_workers()
Definition: threads.h:372
static int send_add_segment_callback(u32 api_client_index, u64 segment_handle)
Definition: session_api.c:83
transport_endpoint_t lcl
u32 app_wrk_index
Index of the app worker that owns the session.
Connect to a given URI WILL BE DEPRECATED POST 20.01
Definition: session.api:221
static void vl_api_session_rule_add_del_t_handler(vl_api_session_rule_add_del_t *mp)
Definition: session_api.c:1184
bidirectional disconnect reply API WILL BE DEPRECATED POST 20.01
Definition: session.api:250
u32 api_client_index
API index for the worker.
Definition: application.h:63
int mq_send_session_bound_cb(u32 app_wrk_index, u32 api_context, session_handle_t handle, int rv)
Definition: session_api.c:383
int vnet_connect_uri(vnet_connect_args_t *a)
svm_msg_q_t * event_queue
Application listens for events on this svm queue.
Definition: application.h:46
u32 context
Definition: gre.api:45
static transport_service_type_t session_transport_service_type(session_t *s)
api_main_t api_main
Definition: api_shared.c:35
Application attach to session layer.
Definition: session.api:72
static void vl_api_bind_uri_t_handler(vl_api_bind_uri_t *mp)
Definition: session_api.c:719
int mq_send_session_connected_cb(u32 app_wrk_index, u32 api_context, session_t *s, u8 is_fail)
Definition: session_api.c:303
non-blocking call - works with both condvar and eventfd signaling
Definition: queue.h:44
static u8 session_main_is_enabled()
Definition: session.h:613
static void vl_api_unbind_uri_t_handler(vl_api_unbind_uri_t *mp)
Definition: session_api.c:760
ssvm_segment_type_t ssvm_type(const ssvm_private_t *ssvm)
Definition: ssvm.c:443