-static inline int
-app_send_io_evt_rx (application_t * app, stream_session_t * s, u8 lock)
-{
- session_event_t *evt;
- svm_msg_q_msg_t msg;
- svm_msg_q_t *mq;
-
- if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY))
- {
- /* Session is closed so app will never clean up. Flush rx fifo */
- if (s->session_state == SESSION_STATE_CLOSED)
- svm_fifo_dequeue_drop_all (s->server_rx_fifo);
- return 0;
- }
-
- if (app->cb_fns.builtin_app_rx_callback)
- return app->cb_fns.builtin_app_rx_callback (s);
-
- if (svm_fifo_has_event (s->server_rx_fifo)
- || svm_fifo_is_empty (s->server_rx_fifo))
- return 0;
-
- mq = app->event_queue;
- if (lock)
- svm_msg_q_lock (mq);
-
- if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
- {
- clib_warning ("evt q rings full");
- if (lock)
- svm_msg_q_unlock (mq);
- return -1;
- }
-
- msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
- ASSERT (!svm_msg_q_msg_is_invalid (&msg));
-
- evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
- evt->fifo = s->server_rx_fifo;
- evt->event_type = FIFO_EVENT_APP_RX;
-
- if (app_enqueue_evt (mq, &msg, lock))
- return -1;
- svm_fifo_set_event (s->server_rx_fifo);
- return 0;
-}
-
-static inline int
-app_send_io_evt_tx (application_t * app, stream_session_t * s, u8 lock)
-{
- svm_msg_q_t *mq;
- session_event_t *evt;
- svm_msg_q_msg_t msg;
-
- if (application_is_builtin (app))
- return 0;
-
- mq = app->event_queue;
- if (lock)
- svm_msg_q_lock (mq);
-
- if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
- {
- clib_warning ("evt q rings full");
- if (lock)
- svm_msg_q_unlock (mq);
- return -1;
- }
-
- msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
- ASSERT (!svm_msg_q_msg_is_invalid (&msg));
-
- evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
- evt->event_type = FIFO_EVENT_APP_TX;
- evt->fifo = s->server_tx_fifo;
-
- return app_enqueue_evt (mq, &msg, lock);
-}
-
-/* *INDENT-OFF* */
-typedef int (app_send_evt_handler_fn) (application_t *app,
- stream_session_t *s,
- u8 lock);
-static app_send_evt_handler_fn * const app_send_evt_handler_fns[2] = {
- app_send_io_evt_rx,
- app_send_io_evt_tx,
-};
-/* *INDENT-ON* */
-
-/**
- * Send event to application
- *
- * Logic from queue perspective is non-blocking. That is, if there's
- * not enough space to enqueue a message, we return. However, if the lock
- * flag is set, we do wait for queue mutex.
- */
-int
-application_send_event (application_t * app, stream_session_t * s,
- u8 evt_type)
-{
- ASSERT (app && evt_type <= FIFO_EVENT_APP_TX);
- return app_send_evt_handler_fns[evt_type] (app, s, 0 /* lock */ );
-}
-
-int
-application_lock_and_send_event (application_t * app, stream_session_t * s,
- u8 evt_type)
-{
- return app_send_evt_handler_fns[evt_type] (app, s, 1 /* lock */ );
-}
-
-local_session_t *
-application_alloc_local_session (application_t * app)
-{
- local_session_t *s;
- pool_get (app->local_sessions, s);
- memset (s, 0, sizeof (*s));
- s->app_index = app->index;
- s->session_index = s - app->local_sessions;
- s->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
- return s;
-}
-
-void
-application_free_local_session (application_t * app, local_session_t * s)
-{
- pool_put (app->local_sessions, s);
- if (CLIB_DEBUG)
- memset (s, 0xfc, sizeof (*s));
-}
-
-local_session_t *
-application_get_local_session (application_t * app, u32 session_index)
-{
- return pool_elt_at_index (app->local_sessions, session_index);
-}
-
-local_session_t *
-application_get_local_session_from_handle (session_handle_t handle)
-{
- application_t *server;
- u32 session_index, server_index;
- local_session_parse_handle (handle, &server_index, &session_index);
- server = application_get (server_index);
- return application_get_local_session (server, session_index);
-}
-
-always_inline void
-application_local_listener_session_endpoint (local_session_t * ll,
- session_endpoint_t * sep)
-{
- sep->transport_proto =
- session_type_transport_proto (ll->listener_session_type);
- sep->port = ll->port;
- sep->is_ip4 = ll->listener_session_type & 1;
-}
-
-int
-application_start_local_listen (application_t * server,
- session_endpoint_t * sep,
- session_handle_t * handle)
-{
- session_handle_t lh;
- local_session_t *ll;
- u32 table_index;
-
- table_index = application_local_session_table (server);
-
- /* An exact sep match, as opposed to session_lookup_local_listener */
- lh = session_lookup_endpoint_listener (table_index, sep, 1);
- if (lh != SESSION_INVALID_HANDLE)
- return VNET_API_ERROR_ADDRESS_IN_USE;
-
- pool_get (server->local_listen_sessions, ll);
- memset (ll, 0, sizeof (*ll));
- ll->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
- ll->app_index = server->index;
- ll->session_index = ll - server->local_listen_sessions;
- ll->port = sep->port;
- /* Store the original session type for the unbind */
- ll->listener_session_type =
- session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4);
- ll->transport_listener_index = ~0;
-
- *handle = application_local_session_handle (ll);
- session_lookup_add_session_endpoint (table_index, sep, *handle);
-
- return 0;
-}
-
-/**
- * Clean up local session table. If we have a listener session use it to
- * find the port and proto. If not, the handle must be a local table handle
- * so parse it.
- */
-int
-application_stop_local_listen (application_t * server, session_handle_t lh)
-{
- session_endpoint_t sep = SESSION_ENDPOINT_NULL;
- u32 table_index, ll_index, server_index;
- stream_session_t *sl = 0;
- local_session_t *ll, *ls;
-
- table_index = application_local_session_table (server);
-
- /* We have both local and global table binds. Figure from global what
- * the sep we should be cleaning up is.
- */
- if (!session_handle_is_local (lh))
- {
- sl = listen_session_get_from_handle (lh);
- if (!sl || listen_session_get_local_session_endpoint (sl, &sep))
- {
- clib_warning ("broken listener");
- return -1;
- }
- lh = session_lookup_endpoint_listener (table_index, &sep, 0);
- if (lh == SESSION_INVALID_HANDLE)
- return -1;
- }
-
- local_session_parse_handle (lh, &server_index, &ll_index);
- ASSERT (server->index == server_index);
- if (!(ll = application_get_local_listen_session (server, ll_index)))
- {
- clib_warning ("no local listener");
- return -1;
- }
- application_local_listener_session_endpoint (ll, &sep);
- session_lookup_del_session_endpoint (table_index, &sep);
-
- /* *INDENT-OFF* */
- pool_foreach (ls, server->local_sessions, ({
- if (ls->listener_index == ll->session_index)
- application_local_session_disconnect (server->index, ls);
- }));
- /* *INDENT-ON* */
- pool_put_index (server->local_listen_sessions, ll->session_index);
-
- return 0;
-}
-
-int
-application_local_session_connect (u32 table_index, application_t * client,
- application_t * server,
- local_session_t * ll, u32 opaque)
-{
- u32 seg_size, evt_q_sz, evt_q_elts, margin = 16 << 10;
- segment_manager_properties_t *props, *cprops;
- u32 round_rx_fifo_sz, round_tx_fifo_sz;
- int rv, has_transport, seg_index;
- svm_fifo_segment_private_t *seg;
- segment_manager_t *sm;
- local_session_t *ls;
- svm_msg_q_t *sq, *cq;
-
- ls = application_alloc_local_session (server);
-
- props = application_segment_manager_properties (server);
- cprops = application_segment_manager_properties (client);
- evt_q_elts = props->evt_q_size + cprops->evt_q_size;
- evt_q_sz = segment_manager_evt_q_expected_size (evt_q_elts);
- round_rx_fifo_sz = 1 << max_log2 (props->rx_fifo_size);
- round_tx_fifo_sz = 1 << max_log2 (props->tx_fifo_size);
- seg_size = round_rx_fifo_sz + round_tx_fifo_sz + evt_q_sz + margin;
-
- has_transport = session_has_transport ((stream_session_t *) ll);
- if (!has_transport)
- {
- /* Local sessions don't have backing transport */
- ls->port = ll->port;
- sm = application_get_local_segment_manager (server);
- }
- else
- {
- stream_session_t *sl = (stream_session_t *) ll;
- transport_connection_t *tc;
- tc = listen_session_get_transport (sl);
- ls->port = tc->lcl_port;
- sm = application_get_listen_segment_manager (server, sl);
- }
-
- 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->evt_q_size);
- cq = segment_manager_alloc_queue (seg, cprops->evt_q_size);
- 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->master_session_index = ls->session_index;
- ls->server_tx_fifo->master_session_index = ls->session_index;
- ls->server_rx_fifo->master_thread_index = ~0;
- ls->server_tx_fifo->master_thread_index = ~0;
- ls->svm_segment_index = seg_index;
- ls->listener_index = ll->session_index;
- ls->client_index = client->index;
- ls->client_opaque = opaque;
- ls->listener_session_type = ll->session_type;
-
- 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_index << 32 | (uword) ls->session_index);
-}
-
-static void
-application_client_local_connect_key_parse (uword key, u32 * app_index,
- u32 * session_index)
-{
- *app_index = key >> 32;
- *session_index = key & 0xFFFFFFFF;
-}
-
-int
-application_local_session_connect_notify (local_session_t * ls)
-{
- svm_fifo_segment_private_t *seg;
- application_t *client, *server;
- segment_manager_t *sm;
- int rv, is_fail = 0;
- uword client_key;
-
- client = application_get (ls->client_index);
- server = application_get (ls->app_index);
- sm = application_get_local_segment_manager_w_session (server, 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_index);
- segment_manager_segment_reader_unlock (sm);
- application_local_session_disconnect (ls->client_index, ls);
- is_fail = 1;
- }
- else
- {
- segment_manager_segment_reader_unlock (sm);
- }
-
- client->cb_fns.session_connected_callback (client->index, ls->client_opaque,
- (stream_session_t *) ls,
- is_fail);
-
- client_key = application_client_local_connect_key (ls);
- hash_set (client->local_connects, client_key, client_key);
- return 0;
-}
-
-int
-application_local_session_cleanup (application_t * client,
- application_t * server,
- local_session_t * ls)
-{
- svm_fifo_segment_private_t *seg;
- segment_manager_t *sm;
- uword client_key;
- u8 has_transport;
-
- has_transport = session_has_transport ((stream_session_t *) ls);
- client_key = application_client_local_connect_key (ls);
- if (!has_transport)
- sm = application_get_local_segment_manager_w_session (server, ls);
- else
- sm = application_get_listen_segment_manager (server,
- (stream_session_t *) ls);
-
- seg = segment_manager_get_segment (sm, ls->svm_segment_index);
- if (client)
- hash_unset (client->local_connects, client_key);
-
- if (!has_transport)
- {
- server->cb_fns.del_segment_callback (server->api_client_index,
- &seg->ssvm);
- if (client)
- client->cb_fns.del_segment_callback (client->api_client_index,
- &seg->ssvm);
- segment_manager_del_segment (sm, seg);
- }
-
- application_free_local_session (server, ls);
-
- return 0;
-}
-
-int
-application_local_session_disconnect (u32 app_index, local_session_t * ls)
-{
- application_t *client, *server;
-
- client = application_get_if_valid (ls->client_index);
- server = application_get (ls->app_index);
-
- if (ls->session_state == SESSION_STATE_CLOSED)
- return application_local_session_cleanup (client, server, ls);
-
- if (app_index == ls->client_index)
- {
- send_local_session_disconnect_callback (ls->app_index, ls);
- }
- else
- {
- if (!client)
- {
- return application_local_session_cleanup (client, server, ls);
- }
- else if (ls->session_state < SESSION_STATE_READY)
- {
- client->cb_fns.session_connected_callback (client->index,
- ls->client_opaque,
- (stream_session_t *) ls,
- 1 /* is_fail */ );
- ls->session_state = SESSION_STATE_CLOSED;
- return application_local_session_cleanup (client, server, ls);
- }
- else
- {
- send_local_session_disconnect_callback (client->index, ls);
- }
- }
-
- ls->session_state = SESSION_STATE_CLOSED;
-
- return 0;
-}
-
-int
-application_local_session_disconnect_w_index (u32 app_index, u32 ls_index)
-{
- application_t *app;
- local_session_t *ls;
- app = application_get (app_index);
- ls = application_get_local_session (app, ls_index);
- return application_local_session_disconnect (app_index, ls);
-}
-
-void
-application_local_sessions_del (application_t * app)
-{
- u32 index, server_index, session_index, table_index;
- segment_manager_t *sm;
- u64 handle, *handles = 0;
- local_session_t *ls, *ll;
- application_t *server;
- session_endpoint_t sep;
- int i;
-
- /*
- * Local listens. Don't bother with local sessions, we clean them lower
- */
- table_index = application_local_session_table (app);
- /* *INDENT-OFF* */
- pool_foreach (ll, app->local_listen_sessions, ({
- application_local_listener_session_endpoint (ll, &sep);
- session_lookup_del_session_endpoint (table_index, &sep);
- }));
- /* *INDENT-ON* */
-
- /*
- * Local sessions
- */
- if (app->local_sessions)
- {
- /* *INDENT-OFF* */
- pool_foreach (ls, app->local_sessions, ({
- application_local_session_disconnect (app->index, ls);
- }));
- /* *INDENT-ON* */
- }
-
- /*
- * Local connects
- */
- vec_reset_length (handles);
- /* *INDENT-OFF* */
- hash_foreach (handle, index, app->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_index,
- &session_index);
- server = application_get_if_valid (server_index);
- if (server)
- {
- ls = application_get_local_session (server, session_index);
- application_local_session_disconnect (app->index, ls);
- }
- }
-
- sm = segment_manager_get (app->local_segment_manager);
- sm->app_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)