}
fib_proto = session_endpoint_fib_proto (sep);
- table_index = application_session_table (app, fib_proto);
+ table_index = session_lookup_get_index_for_fib (fib_proto, sep->fib_index);
handle = session_lookup_endpoint_listener (table_index, sep, 1);
if (handle != SESSION_INVALID_HANDLE)
{
{
app_listener_t *app_listener;
transport_connection_t *tc;
+ u32 al_index, table_index;
session_handle_t lh;
session_type_t st;
session_t *ls = 0;
- u32 al_index;
int rv;
app_listener = app_listener_alloc (app);
&& session_endpoint_is_local ((session_endpoint_t *) sep))
{
session_type_t local_st;
- u32 table_index;
local_st = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE,
sep->is_ip4);
* connections */
tc = session_get_transport (ls);
if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP))
- session_lookup_add_connection (tc, lh);
+ {
+ fib_protocol_t fib_proto;
+ fib_proto = session_endpoint_fib_proto ((session_endpoint_t *) sep);
+ table_index = session_lookup_get_index_for_fib (fib_proto,
+ sep->fib_index);
+ ASSERT (table_index != SESSION_TABLE_INVALID_INDEX);
+ session_lookup_add_session_endpoint (table_index,
+ (session_endpoint_t *) sep,
+ lh);
+ }
}
if (!ls)
props->use_mq_eventfd = 1;
if (options[APP_OPTIONS_TLS_ENGINE])
app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
+ if (options[APP_OPTIONS_MAX_FIFO_SIZE])
+ props->max_fifo_size = options[APP_OPTIONS_MAX_FIFO_SIZE];
+ if (options[APP_OPTIONS_HIGH_WATERMARK])
+ props->high_watermark = options[APP_OPTIONS_HIGH_WATERMARK];
+ if (options[APP_OPTIONS_LOW_WATERMARK])
+ props->low_watermark = options[APP_OPTIONS_LOW_WATERMARK];
+ if (options[APP_OPTIONS_PCT_FIRST_ALLOC])
+ props->pct_first_alloc = options[APP_OPTIONS_PCT_FIRST_ALLOC];
props->segment_type = seg_type;
/* Add app to lookup by api_client_index table */
sm = segment_manager_alloc ();
sm->app_wrk_index = app_wrk->wrk_index;
- if ((rv = segment_manager_init (sm, app->sm_properties.segment_size,
- app->sm_properties.prealloc_fifos)))
+ if ((rv = segment_manager_init (sm)))
{
app_worker_free (app_wrk);
return rv;
app = application_get_if_valid (a->app_index);
if (!app)
- return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
+ return SESSION_E_NOAPP;
app_wrk = application_get_worker (app, a->wrk_map_index);
if (!app_wrk)
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_INVALID_APPWRK;
a->sep_ext.app_wrk_index = app_wrk->wrk_index;
session_endpoint_update_for_app (&a->sep_ext, app, 0 /* is_connect */ );
if (!session_endpoint_in_ns (&a->sep))
- return VNET_API_ERROR_INVALID_VALUE_2;
+ return SESSION_E_INVALID_NS;
/*
* Check if we already have an app listener
if (app_listener)
{
if (app_listener->app_index != app->app_index)
- return VNET_API_ERROR_ADDRESS_IN_USE;
- if (app_worker_start_listen (app_wrk, app_listener))
- return -1;
+ return SESSION_E_ALREADY_LISTENING;
+ if ((rv = app_worker_start_listen (app_wrk, app_listener)))
+ return rv;
a->handle = app_listener_handle (app_listener);
return 0;
}
ASSERT (vlib_thread_is_main_w_barrier ());
if (session_endpoint_is_zero (&a->sep))
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_INVALID_RMT_IP;
client = application_get (a->app_index);
session_endpoint_update_for_app (&a->sep_ext, client, 1 /* is_connect */ );
rv = app_worker_connect_session (client_wrk, &a->sep, a->api_context);
if (rv <= 0)
return rv;
+ a->sep_ext.transport_proto = a->sep_ext.original_tp;
}
/*
* Not connecting to a local server, propagate to transport
*/
- if (app_worker_connect_session (client_wrk, &a->sep, a->api_context))
- return VNET_API_ERROR_SESSION_CONNECT;
- return 0;
+ return app_worker_connect_session (client_wrk, &a->sep, a->api_context);
}
int
ASSERT (vlib_thread_is_main_w_barrier ());
if (!(app = application_get_if_valid (a->app_index)))
- return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
+ return SESSION_E_NOAPP;
if (!(al = app_listener_get_w_handle (a->handle)))
- return -1;
+ return SESSION_E_NOLISTEN;
if (al->app_index != app->app_index)
{
clib_warning ("app doesn't own handle %llu!", a->handle);
- return -1;
+ return SESSION_E_OWNER;
}
app_wrk = application_get_worker (app, a->wrk_map_index);
if (!app_wrk)
{
clib_warning ("no app %u worker %u", app->app_index, a->wrk_map_index);
- return -1;
+ return SESSION_E_INVALID_APPWRK;
}
return app_worker_stop_listen (app_wrk, al);
s = session_get_from_handle_if_valid (a->handle);
if (!s)
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_NOSESSION;
+
app_wrk = app_worker_get (s->app_wrk_index);
if (app_wrk->app_index != a->app_index)
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_OWNER;
/* We're peeking into another's thread pool. Make sure */
ASSERT (s->session_index == session_index_from_handle (a->handle));
app_worker_t *old_wrk = app_worker_get (s->app_wrk_index);
app_listener_t *app_listener;
application_t *app;
+ int rv;
if (!old_wrk)
- return -1;
+ return SESSION_E_INVALID_APPWRK;
hash_unset (old_wrk->listeners_table, listen_session_get_handle (s));
if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL
app = application_get (old_wrk->app_index);
if (!app)
- return -1;
+ return SESSION_E_NOAPP;
app_listener = app_listener_get (app, s->al_index);
app_listener->workers = clib_bitmap_set (app_listener->workers,
old_wrk->wrk_map_index, 0);
- if (app_worker_start_listen (app_wrk, app_listener))
- return -1;
+ if ((rv = app_worker_start_listen (app_wrk, app_listener)))
+ return rv;
s->app_wrk_index = app_wrk->wrk_index;