* VPPCOM Utility Functions
*/
+static void
+vcl_send_session_listen (vcl_worker_t * wrk, vcl_session_t * s)
+{
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_listen_msg_t *mp;
+ svm_msg_q_t *mq;
+
+ mq = vcl_worker_ctrl_mq (wrk);
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_LISTEN);
+ mp = (session_listen_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = wrk->my_client_index;
+ mp->context = s->session_index;
+ mp->wrk_index = wrk->vpp_wrk_index;
+ mp->is_ip4 = s->transport.is_ip4;
+ clib_memcpy_fast (&mp->ip, &s->transport.lcl_ip, sizeof (mp->ip));
+ mp->port = s->transport.lcl_port;
+ mp->proto = s->session_type;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
+}
+
+static void
+vcl_send_session_connect (vcl_worker_t * wrk, vcl_session_t * s)
+{
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_connect_msg_t *mp;
+ svm_msg_q_t *mq;
+
+ mq = vcl_worker_ctrl_mq (wrk);
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_CONNECT);
+ mp = (session_connect_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = wrk->my_client_index;
+ mp->context = s->session_index;
+ mp->wrk_index = wrk->vpp_wrk_index;
+ mp->is_ip4 = s->transport.is_ip4;
+ mp->parent_handle = s->parent_handle;
+ clib_memcpy_fast (&mp->ip, &s->transport.rmt_ip, sizeof (mp->ip));
+ mp->port = s->transport.rmt_port;
+ mp->proto = s->session_type;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
+}
+
+void
+vcl_send_session_unlisten (vcl_worker_t * wrk, vcl_session_t * s)
+{
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_unlisten_msg_t *mp;
+ svm_msg_q_t *mq;
+
+ mq = vcl_worker_ctrl_mq (wrk);
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_UNLISTEN);
+ mp = (session_unlisten_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = wrk->my_client_index;
+ mp->wrk_index = wrk->vpp_wrk_index;
+ mp->handle = s->vpp_handle;
+ mp->context = wrk->wrk_index;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
+}
+
+static void
+vcl_send_session_disconnect (vcl_worker_t * wrk, vcl_session_t * s)
+{
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_disconnect_msg_t *mp;
+ svm_msg_q_t *mq;
+
+ /* Send to thread that owns the session */
+ mq = s->vpp_evt_q;
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_DISCONNECT);
+ mp = (session_disconnect_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = wrk->my_client_index;
+ mp->handle = s->vpp_handle;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
+}
+
+static void
+vcl_send_app_detach (vcl_worker_t * wrk)
+{
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_app_detach_msg_t *mp;
+ svm_msg_q_t *mq;
+
+ mq = vcl_worker_ctrl_mq (wrk);
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_APP_DETACH);
+ mp = (session_app_detach_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = wrk->my_client_index;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
+}
static void
vcl_send_session_accepted_reply (svm_msg_q_t * mq, u32 context,
session->transport.lcl_port = listen_session->transport.lcl_port;
session->transport.lcl_ip = listen_session->transport.lcl_ip;
session->session_type = listen_session->session_type;
- session->is_dgram = session->session_type == VPPCOM_PROTO_UDP;
+ session->is_dgram = vcl_proto_is_dgram (session->session_type);
+ session->listener_index = listen_session->session_index;
+ listen_session->n_accepted_sessions++;
VDBG (1, "session %u [0x%llx]: client accept request from %s address %U"
" port %d queue %p!", session->session_index, mp->handle,
session_accepted_msg_t *accepted_msg;
vcl_session_t *session = 0;
vcl_session_msg_t *evt;
- u64 vpp_handle;
session = vcl_session_get_w_handle (wrk, session_handle);
if (!session)
}
clib_fifo_free (session->accept_evts_fifo);
- vpp_handle = session->vpp_handle;
- session->vpp_handle = ~0;
- session->session_state = STATE_DISCONNECT;
+ vcl_send_session_unlisten (wrk, session);
VDBG (1, "session %u [0x%llx]: sending unbind!", session->session_index,
- vpp_handle);
+ session->vpp_handle);
vcl_evt (VCL_EVT_UNBIND, session);
- vppcom_send_unbind_sock (wrk, vpp_handle);
+
+ session->vpp_handle = ~0;
+ session->session_state = STATE_DISCONNECT;
return VPPCOM_OK;
}
{
vcl_worker_t *wrk = vcl_worker_get_current ();
svm_msg_q_t *vpp_evt_q;
- vcl_session_t *session;
+ vcl_session_t *session, *listen_session;
vcl_session_state_t state;
u64 vpp_handle;
{
VDBG (1, "session %u [0x%llx]: sending disconnect...",
session->session_index, vpp_handle);
- vppcom_send_disconnect_session (vpp_handle);
+ vcl_send_session_disconnect (wrk, session);
+ }
+
+ if (session->listener_index != VCL_INVALID_SESSION_INDEX)
+ {
+ listen_session = vcl_session_get (wrk, session->listener_index);
+ listen_session->n_accepted_sessions--;
}
return VPPCOM_OK;
vcl_set_worker_index (~0);
vcl_elog_stop (vcm);
if (vec_len (vcm->workers) == 1)
- vl_client_disconnect_from_vlib ();
+ vppcom_disconnect_from_vpp ();
else
vl_client_send_disconnect (1 /* vpp should cleanup */ );
}
if (pool_elts (vcm->workers) == 1)
{
- vppcom_app_send_detach ();
+ vcl_send_app_detach (vcl_worker_get_current ());
orig_app_timeout = vcm->cfg.app_timeout;
vcm->cfg.app_timeout = 2.0;
rv = vcl_wait_for_app_state_change (STATE_APP_ENABLED);
session->session_type = proto;
session->session_state = STATE_START;
session->vpp_handle = ~0;
- session->is_dgram = proto == VPPCOM_PROTO_UDP;
+ session->is_dgram = vcl_proto_is_dgram (proto);
if (is_nonblocking)
VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_NONBLOCK);
vppcom_retval_str (rv));
return rv;
}
- else if (state & STATE_OPEN)
+ else if ((state & STATE_OPEN)
+ || (vcl_session_is_connectable_listener (wrk, session)))
{
rv = vppcom_session_disconnect (sh);
if (PREDICT_FALSE (rv < 0))
return VPPCOM_OK;
}
- VDBG (0, "session %u [0x%llx]: sending vpp listen request...",
- listen_sh, listen_vpp_handle);
+ VDBG (0, "session %u: sending vpp listen request...", listen_sh);
/*
* Send listen request to vpp and wait for reply
*/
- vppcom_send_bind_sock (listen_session);
+ vcl_send_session_listen (wrk, listen_session);
rv = vppcom_wait_for_session_state_change (listen_session->session_index,
STATE_LISTEN,
vcm->cfg.session_timeout);
* Send listen request to vpp and wait for reply
*/
vppcom_send_application_tls_cert_add (session, cert, cert_len);
-
+ vcm->app_state = STATE_APP_ADDING_TLS_DATA;
+ vcl_wait_for_app_state_change (STATE_APP_READY);
return VPPCOM_OK;
}
if (key_len == 0 || key_len == ~0)
return VPPCOM_EBADFD;
- /*
- * Send listen request to vpp and wait for reply
- */
vppcom_send_application_tls_key_add (session, key, key_len);
-
+ vcm->app_state = STATE_APP_ADDING_TLS_DATA;
+ vcl_wait_for_app_state_change (STATE_APP_READY);
return VPPCOM_OK;
-
-
}
static int
return VPPCOM_EBADFD;
}
- if (ls->session_state != STATE_LISTEN)
+ if ((ls->session_state != STATE_LISTEN)
+ && (!vcl_session_is_connectable_listener (wrk, ls)))
{
- VDBG (0, "ERROR: session [0x%llx]: not in listen state! state 0x%x"
- " (%s)", ls->vpp_handle, ls->session_index, ls->session_state,
+ VDBG (0,
+ "ERROR: session [0x%llx]: not in listen state! state 0x%x"
+ " (%s)", ls->vpp_handle, ls->session_state,
vppcom_session_state_str (ls->session_state));
return VPPCOM_EBADFD;
}
return VPPCOM_OK;
}
+int
+vppcom_unformat_proto (uint8_t * proto, char *proto_str)
+{
+ if (!strcmp (proto_str, "TCP"))
+ *proto = VPPCOM_PROTO_TCP;
+ else if (!strcmp (proto_str, "tcp"))
+ *proto = VPPCOM_PROTO_TCP;
+ else if (!strcmp (proto_str, "UDP"))
+ *proto = VPPCOM_PROTO_UDP;
+ else if (!strcmp (proto_str, "udp"))
+ *proto = VPPCOM_PROTO_UDP;
+ else if (!strcmp (proto_str, "UDPC"))
+ *proto = VPPCOM_PROTO_UDPC;
+ else if (!strcmp (proto_str, "udpc"))
+ *proto = VPPCOM_PROTO_UDPC;
+ else if (!strcmp (proto_str, "SCTP"))
+ *proto = VPPCOM_PROTO_SCTP;
+ else if (!strcmp (proto_str, "sctp"))
+ *proto = VPPCOM_PROTO_SCTP;
+ else if (!strcmp (proto_str, "TLS"))
+ *proto = VPPCOM_PROTO_TLS;
+ else if (!strcmp (proto_str, "tls"))
+ *proto = VPPCOM_PROTO_TLS;
+ else if (!strcmp (proto_str, "QUIC"))
+ *proto = VPPCOM_PROTO_QUIC;
+ else if (!strcmp (proto_str, "quic"))
+ *proto = VPPCOM_PROTO_QUIC;
+ else
+ return 1;
+ return 0;
+}
+
int
vppcom_session_accept (uint32_t listen_session_handle, vppcom_endpt_t * ep,
uint32_t flags)
VDBG (0, "session handle %u [0x%llx]: session already "
"connected to %s %U port %d proto %s, state 0x%x (%s)",
session_handle, session->vpp_handle,
- session->transport.is_ip4 ? "IPv4" : "IPv6",
- format_ip46_address,
+ session->transport.is_ip4 ? "IPv4" : "IPv6", format_ip46_address,
&session->transport.rmt_ip, session->transport.is_ip4 ?
IP46_TYPE_IP4 : IP46_TYPE_IP6,
clib_net_to_host_u16 (session->transport.rmt_port),
clib_memcpy_fast (&session->transport.rmt_ip.ip6, server_ep->ip,
sizeof (ip6_address_t));
session->transport.rmt_port = server_ep->port;
+ session->parent_handle = VCL_INVALID_SESSION_HANDLE;
- VDBG (0, "session handle %u [0x%llx]: connecting to server %s %U "
- "port %d proto %s", session_handle, session->vpp_handle,
+ VDBG (0, "session handle %u: connecting to server %s %U "
+ "port %d proto %s", session_handle,
session->transport.is_ip4 ? "IPv4" : "IPv6",
format_ip46_address,
&session->transport.rmt_ip, session->transport.is_ip4 ?
clib_net_to_host_u16 (session->transport.rmt_port),
vppcom_proto_str (session->session_type));
+ vcl_send_session_connect (wrk, session);
+
+ if (VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK))
+ return VPPCOM_EINPROGRESS;
+
+ /*
+ * Wait for reply from vpp if blocking
+ */
+ rv = vppcom_wait_for_session_state_change (session_index, STATE_CONNECT,
+ vcm->cfg.session_timeout);
+
+ session = vcl_session_get (wrk, session_index);
+ VDBG (0, "session %u [0x%llx]: connect %s!", session->session_index,
+ session->vpp_handle, rv ? "failed" : "succeeded");
+
+ return rv;
+}
+
+int
+vppcom_session_stream_connect (uint32_t session_handle,
+ uint32_t parent_session_handle)
+{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
+ vcl_session_t *session, *parent_session;
+ u32 session_index, parent_session_index;
+ int rv;
+
+ session = vcl_session_get_w_handle (wrk, session_handle);
+ if (!session)
+ return VPPCOM_EBADFD;
+ parent_session = vcl_session_get_w_handle (wrk, parent_session_handle);
+ if (!parent_session)
+ return VPPCOM_EBADFD;
+
+ session_index = session->session_index;
+ parent_session_index = parent_session->session_index;
+ if (PREDICT_FALSE (session->is_vep))
+ {
+ VDBG (0, "ERROR: cannot connect epoll session %u!",
+ session->session_index);
+ return VPPCOM_EBADFD;
+ }
+
+ if (PREDICT_FALSE (session->session_state & CLIENT_STATE_OPEN))
+ {
+ VDBG (0, "session handle %u [0x%llx]: session already "
+ "connected to session %u [0x%llx] proto %s, state 0x%x (%s)",
+ session_handle, session->vpp_handle,
+ parent_session_handle, parent_session->vpp_handle,
+ vppcom_proto_str (session->session_type), session->session_state,
+ vppcom_session_state_str (session->session_state));
+ return VPPCOM_OK;
+ }
+
+ /* Connect to quic session specifics */
+ session->transport.is_ip4 = parent_session->transport.is_ip4;
+ session->transport.rmt_ip.ip4.as_u32 = (uint32_t) 1;
+ session->transport.rmt_port = 0;
+ session->parent_handle = parent_session->vpp_handle;
+
+ VDBG (0, "session handle %u: connecting to session %u [0x%llx]",
+ session_handle, parent_session_handle, parent_session->vpp_handle);
+
/*
* Send connect request and wait for reply from vpp
*/
- vppcom_send_connect_sock (session);
+ vcl_send_session_connect (wrk, session);
rv = vppcom_wait_for_session_state_change (session_index, STATE_CONNECT,
vcm->cfg.session_timeout);
+ session->listener_index = parent_session_index;
+ parent_session = vcl_session_get_w_handle (wrk, parent_session_handle);
+ if (parent_session)
+ parent_session->n_accepted_sessions++;
+
session = vcl_session_get (wrk, session_index);
VDBG (0, "session %u [0x%llx]: connect %s!", session->session_index,
session->vpp_handle, rv ? "failed" : "succeeded");
break;
case SESSION_CTRL_EVT_CONNECTED:
connected_msg = (session_connected_msg_t *) e->data;
- vcl_session_connected_handler (wrk, connected_msg);
+ sid = vcl_session_connected_handler (wrk, connected_msg);
+ if (sid == VCL_INVALID_SESSION_INDEX)
+ break;
+ if (sid < n_bits && write_map)
+ {
+ clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
+ *bits_set += 1;
+ }
break;
case SESSION_CTRL_EVT_DISCONNECTED:
disconnected_msg = (session_disconnected_msg_t *) e->data;
}
static inline void
-vep_verify_epoll_chain (vcl_worker_t * wrk, u32 vep_idx)
+vep_verify_epoll_chain (vcl_worker_t * wrk, u32 vep_handle)
{
vcl_session_t *session;
vppcom_epoll_t *vep;
- u32 sid = vep_idx;
+ u32 sh = vep_handle;
if (VPPCOM_DEBUG <= 2)
return;
- session = vcl_session_get (wrk, vep_idx);
+ session = vcl_session_get_w_handle (wrk, vep_handle);
if (PREDICT_FALSE (!session))
{
- VDBG (0, "ERROR: Invalid vep_idx (%u)!", vep_idx);
+ VDBG (0, "ERROR: Invalid vep_sh (%u)!", vep_handle);
goto done;
}
if (PREDICT_FALSE (!session->is_vep))
{
- VDBG (0, "ERROR: vep_idx (%u) is not a vep!", vep_idx);
+ VDBG (0, "ERROR: vep_sh (%u) is not a vep!", vep_handle);
goto done;
}
vep = &session->vep;
- VDBG (0, "vep_idx (%u): Dumping epoll chain\n"
+ VDBG (0, "vep_sh (%u): Dumping epoll chain\n"
"{\n"
" is_vep = %u\n"
" is_vep_session = %u\n"
- " next_sid = 0x%x (%u)\n"
- "}\n", vep_idx, session->is_vep, session->is_vep_session,
+ " next_sh = 0x%x (%u)\n"
+ "}\n", vep_handle, session->is_vep, session->is_vep_session,
vep->next_sh, vep->next_sh);
- for (sid = vep->next_sh; sid != ~0; sid = vep->next_sh)
+ for (sh = vep->next_sh; sh != ~0; sh = vep->next_sh)
{
- session = vcl_session_get (wrk, sid);
+ session = vcl_session_get_w_handle (wrk, sh);
if (PREDICT_FALSE (!session))
{
- VDBG (0, "ERROR: Invalid sid (%u)!", sid);
+ VDBG (0, "ERROR: Invalid sh (%u)!", sh);
goto done;
}
if (PREDICT_FALSE (session->is_vep))
{
- VDBG (0, "ERROR: sid (%u) is a vep!", vep_idx);
+ VDBG (0, "ERROR: sh (%u) is a vep!", vep_handle);
}
else if (PREDICT_FALSE (!session->is_vep_session))
{
- VDBG (0, "ERROR: session (%u) is not a vep session!", sid);
+ VDBG (0, "ERROR: sh (%u) is not a vep session handle!", sh);
goto done;
}
vep = &session->vep;
- if (PREDICT_FALSE (vep->vep_sh != vep_idx))
- VDBG (0, "ERROR: session (%u) vep_idx (%u) != vep_idx (%u)!",
- sid, session->vep.vep_sh, vep_idx);
+ if (PREDICT_FALSE (vep->vep_sh != vep_handle))
+ VDBG (0, "ERROR: session (%u) vep_sh (%u) != vep_sh (%u)!",
+ sh, session->vep.vep_sh, vep_handle);
if (session->is_vep_session)
{
- VDBG (0, "vep_idx[%u]: sid 0x%x (%u)\n"
+ VDBG (0, "vep_sh[%u]: sh 0x%x (%u)\n"
"{\n"
- " next_sid = 0x%x (%u)\n"
- " prev_sid = 0x%x (%u)\n"
- " vep_idx = 0x%x (%u)\n"
+ " next_sh = 0x%x (%u)\n"
+ " prev_sh = 0x%x (%u)\n"
+ " vep_sh = 0x%x (%u)\n"
" ev.events = 0x%x\n"
" ev.data.u64 = 0x%llx\n"
" et_mask = 0x%x\n"
"}\n",
- vep_idx, sid, sid, vep->next_sh, vep->next_sh, vep->prev_sh,
+ vep_handle, sh, sh, vep->next_sh, vep->next_sh, vep->prev_sh,
vep->prev_sh, vep->vep_sh, vep->vep_sh, vep->ev.events,
vep->ev.data.u64, vep->et_mask);
}
}
done:
- VDBG (0, "vep_idx (%u): Dump complete!\n", vep_idx);
+ VDBG (0, "vep_sh (%u): Dump complete!\n", vep_handle);
}
int
return wrk->mqs_epfd;
}
+int
+vppcom_session_is_connectable_listener (uint32_t session_handle)
+{
+ vcl_session_t *session;
+ vcl_worker_t *wrk = vcl_worker_get_current ();
+ session = vcl_session_get_w_handle (wrk, session_handle);
+ if (!session)
+ return VPPCOM_EBADFD;
+ return vcl_session_is_connectable_listener (wrk, session);
+}
+
+int
+vppcom_session_listener (uint32_t session_handle)
+{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
+ vcl_session_t *listen_session, *session;
+ session = vcl_session_get_w_handle (wrk, session_handle);
+ if (!session)
+ return VPPCOM_EBADFD;
+ if (session->listener_index == VCL_INVALID_SESSION_INDEX)
+ return VPPCOM_EBADFD;
+ listen_session = vcl_session_get_w_handle (wrk, session->listener_index);
+ if (!listen_session)
+ return VPPCOM_EBADFD;
+ return vcl_session_handle (listen_session);
+}
+
+int
+vppcom_session_n_accepted (uint32_t session_handle)
+{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
+ vcl_session_t *session = vcl_session_get_w_handle (wrk, session_handle);
+ if (!session)
+ return VPPCOM_EBADFD;
+ return session->n_accepted_sessions;
+}
+
/*
* fd.io coding-style-patch-verification: ON
*