+ seg_index = segment_manager_add_segment (sm, seg_size);
+ if (seg_index < 0)
+ {
+ clib_warning ("failed to add new cut-through segment");
+ return seg_index;
+ }
+ seg = segment_manager_get_segment_w_lock (sm, seg_index);
+ sq = segment_manager_alloc_queue (seg, props);
+ cq = segment_manager_alloc_queue (seg, cprops);
+
+ if (props->use_mq_eventfd)
+ application_local_session_fix_eventds (sq, cq);
+
+ ls->server_evt_q = pointer_to_uword (sq);
+ ls->client_evt_q = pointer_to_uword (cq);
+ rv = segment_manager_try_alloc_fifos (seg, props->rx_fifo_size,
+ props->tx_fifo_size,
+ &ls->server_rx_fifo,
+ &ls->server_tx_fifo);
+ if (rv)
+ {
+ clib_warning ("failed to add fifos in cut-through segment");
+ segment_manager_segment_reader_unlock (sm);
+ goto failed;
+ }
+ ls->server_rx_fifo->ct_session_index = ls->session_index;
+ ls->server_tx_fifo->ct_session_index = ls->session_index;
+ ls->svm_segment_index = seg_index;
+ ls->listener_index = ll->session_index;
+ ls->client_wrk_index = client_wrk->wrk_index;
+ ls->client_opaque = opaque;
+ ls->listener_session_type = ll->session_type;
+ ls->session_state = SESSION_STATE_READY;
+
+ if ((rv = server->cb_fns.add_segment_callback (server->api_client_index,
+ &seg->ssvm)))
+ {
+ clib_warning ("failed to notify server of new segment");
+ segment_manager_segment_reader_unlock (sm);
+ goto failed;
+ }
+ segment_manager_segment_reader_unlock (sm);
+ if ((rv = server->cb_fns.session_accept_callback ((stream_session_t *) ls)))
+ {
+ clib_warning ("failed to send accept cut-through notify to server");
+ goto failed;
+ }
+ if (server->flags & APP_OPTIONS_FLAGS_IS_BUILTIN)
+ application_local_session_connect_notify (ls);
+
+ return 0;
+
+failed:
+ if (!has_transport)
+ segment_manager_del_segment (sm, seg);
+ return rv;
+}
+
+static uword
+application_client_local_connect_key (local_session_t * ls)
+{
+ return ((uword) ls->app_wrk_index << 32 | (uword) ls->session_index);
+}
+
+static void
+application_client_local_connect_key_parse (uword key, u32 * app_wrk_index,
+ u32 * session_index)
+{
+ *app_wrk_index = key >> 32;
+ *session_index = key & 0xFFFFFFFF;
+}
+
+int
+application_local_session_connect_notify (local_session_t * ls)
+{
+ svm_fifo_segment_private_t *seg;
+ app_worker_t *client_wrk, *server_wrk;
+ segment_manager_t *sm;
+ application_t *client;
+ int rv, is_fail = 0;
+ uword client_key;
+
+ client_wrk = app_worker_get (ls->client_wrk_index);
+ server_wrk = app_worker_get (ls->app_wrk_index);
+ client = application_get (client_wrk->app_index);
+
+ sm = application_get_local_segment_manager_w_session (server_wrk, ls);
+ seg = segment_manager_get_segment_w_lock (sm, ls->svm_segment_index);
+ if ((rv = client->cb_fns.add_segment_callback (client->api_client_index,
+ &seg->ssvm)))
+ {
+ clib_warning ("failed to notify client %u of new segment",
+ ls->client_wrk_index);
+ segment_manager_segment_reader_unlock (sm);
+ application_local_session_disconnect (ls->client_wrk_index, ls);
+ is_fail = 1;
+ }
+ else
+ {
+ segment_manager_segment_reader_unlock (sm);
+ }
+
+ client->cb_fns.session_connected_callback (client_wrk->wrk_index,
+ ls->client_opaque,
+ (stream_session_t *) ls,
+ is_fail);
+
+ client_key = application_client_local_connect_key (ls);
+ hash_set (client_wrk->local_connects, client_key, client_key);
+ return 0;
+}
+
+int
+application_local_session_cleanup (app_worker_t * client_wrk,
+ app_worker_t * server_wrk,
+ local_session_t * ls)
+{
+ svm_fifo_segment_private_t *seg;
+ stream_session_t *listener;
+ segment_manager_t *sm;
+ uword client_key;
+ u8 has_transport;
+
+ /* Retrieve listener transport type as it is the one that decides where
+ * the fifos are allocated */
+ has_transport = application_local_session_listener_has_transport (ls);
+ if (!has_transport)
+ sm = application_get_local_segment_manager_w_session (server_wrk, ls);
+ else
+ {
+ listener = listen_session_get (ls->listener_index);
+ sm = app_worker_get_listen_segment_manager (server_wrk, listener);
+ }
+
+ seg = segment_manager_get_segment (sm, ls->svm_segment_index);
+ if (client_wrk)
+ {
+ client_key = application_client_local_connect_key (ls);
+ hash_unset (client_wrk->local_connects, client_key);
+ }
+
+ if (!has_transport)
+ {
+ application_t *server = application_get (server_wrk->app_index);
+ server->cb_fns.del_segment_callback (server->api_client_index,
+ &seg->ssvm);
+ if (client_wrk)
+ {
+ application_t *client = application_get (client_wrk->app_index);
+ client->cb_fns.del_segment_callback (client->api_client_index,
+ &seg->ssvm);
+ }
+ segment_manager_del_segment (sm, seg);
+ }
+
+ application_local_session_free (server_wrk, ls);
+
+ return 0;
+}
+
+int
+application_local_session_disconnect (u32 app_index, local_session_t * ls)
+{
+ app_worker_t *client_wrk, *server_wrk;
+ u8 is_server = 0, is_client = 0;
+ application_t *app;
+
+ app = application_get_if_valid (app_index);
+ if (!app)
+ return 0;
+
+ client_wrk = app_worker_get_if_valid (ls->client_wrk_index);
+ server_wrk = app_worker_get (ls->app_wrk_index);
+
+ if (server_wrk->app_index == app_index)
+ is_server = 1;
+ else if (client_wrk && client_wrk->app_index == app_index)
+ is_client = 1;
+
+ if (!is_server && !is_client)
+ {
+ clib_warning ("app %u is neither client nor server for session 0x%lx",
+ app_index, application_local_session_handle (ls));
+ return VNET_API_ERROR_INVALID_VALUE;
+ }
+
+ if (ls->session_state == SESSION_STATE_CLOSED)
+ return application_local_session_cleanup (client_wrk, server_wrk, ls);
+
+ if (app_index == ls->client_wrk_index)
+ {
+ mq_send_local_session_disconnected_cb (ls->app_wrk_index, ls);
+ }
+ else
+ {
+ if (!client_wrk)
+ {
+ return application_local_session_cleanup (client_wrk, server_wrk,
+ ls);
+ }
+ else if (ls->session_state < SESSION_STATE_READY)
+ {
+ application_t *client = application_get (client_wrk->app_index);
+ client->cb_fns.session_connected_callback (client_wrk->wrk_index,
+ ls->client_opaque,
+ (stream_session_t *) ls,
+ 1 /* is_fail */ );
+ ls->session_state = SESSION_STATE_CLOSED;
+ return application_local_session_cleanup (client_wrk, server_wrk,
+ ls);
+ }
+ else
+ {
+ mq_send_local_session_disconnected_cb (client_wrk->wrk_index, ls);
+ }
+ }
+
+ ls->session_state = SESSION_STATE_CLOSED;
+
+ return 0;
+}
+
+int
+application_local_session_disconnect_w_index (u32 app_wrk_index, u32 ls_index)
+{
+ app_worker_t *app_wrk;
+ local_session_t *ls;
+ app_wrk = app_worker_get (app_wrk_index);
+ ls = application_get_local_session (app_wrk, ls_index);
+ return application_local_session_disconnect (app_wrk_index, ls);
+}
+
+void
+app_worker_local_sessions_free (app_worker_t * app_wrk)
+{
+ u32 index, server_wrk_index, session_index;
+ u64 handle, *handles = 0;
+ app_worker_t *server_wrk;
+ segment_manager_t *sm;
+ local_session_t *ls;
+ int i;
+
+ /*
+ * Local sessions
+ */
+ if (app_wrk->local_sessions)
+ {
+ /* *INDENT-OFF* */
+ pool_foreach (ls, app_wrk->local_sessions, ({
+ application_local_session_disconnect (app_wrk->wrk_index, ls);
+ }));
+ /* *INDENT-ON* */
+ }
+
+ /*
+ * Local connects
+ */
+ vec_reset_length (handles);
+ /* *INDENT-OFF* */
+ hash_foreach (handle, index, app_wrk->local_connects, ({
+ vec_add1 (handles, handle);
+ }));
+ /* *INDENT-ON* */
+
+ for (i = 0; i < vec_len (handles); i++)
+ {
+ application_client_local_connect_key_parse (handles[i],
+ &server_wrk_index,
+ &session_index);
+ server_wrk = app_worker_get_if_valid (server_wrk_index);
+ if (server_wrk)
+ {
+ ls = application_get_local_session (server_wrk, session_index);
+ application_local_session_disconnect (app_wrk->wrk_index, ls);
+ }
+ }
+
+ sm = segment_manager_get (app_wrk->local_segment_manager);
+ sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
+ segment_manager_del (sm);
+}
+
+clib_error_t *
+vnet_app_add_tls_cert (vnet_app_add_tls_cert_args_t * a)
+{
+ application_t *app;
+ app = application_get (a->app_index);
+ if (!app)
+ return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
+ 0, "app %u doesn't exist", a->app_index);
+ app->tls_cert = vec_dup (a->cert);
+ return 0;
+}
+
+clib_error_t *
+vnet_app_add_tls_key (vnet_app_add_tls_key_args_t * a)
+{
+ application_t *app;
+ app = application_get (a->app_index);
+ if (!app)
+ return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
+ 0, "app %u doesn't exist", a->app_index);
+ app->tls_key = vec_dup (a->key);
+ return 0;
+}
+
+u8 *
+format_app_worker_listener (u8 * s, va_list * args)
+{
+ app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
+ u64 handle = va_arg (*args, u64);
+ u32 sm_index = va_arg (*args, u32);
+ int verbose = va_arg (*args, int);
+ stream_session_t *listener;
+ application_t *app;
+ u8 *app_name, *str;
+
+ if (!app_wrk)
+ {
+ if (verbose)
+ s = format (s, "%-40s%-25s%=10s%-15s%-15s%-10s", "Connection", "App",
+ "Wrk", "API Client", "ListenerID", "SegManager");
+ else
+ s = format (s, "%-40s%-25s%=10s", "Connection", "App", "Wrk");
+
+ return s;
+ }
+
+ app = application_get (app_wrk->app_index);
+ app_name = app_get_name_from_reg_index (app);
+ listener = listen_session_get_from_handle (handle);
+ str = format (0, "%U", format_stream_session, listener, verbose);
+
+ if (verbose)
+ {
+ char buf[32];
+ sprintf (buf, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
+ s = format (s, "%-40s%-25s%=10s%-15u%-15u%-10u", str, app_name,
+ buf, app->api_client_index, handle, sm_index);
+ }
+ else
+ s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
+