+ VCL_SESSION_UNLOCK ();
+ return rv;
+}
+
+int
+vppcom_session_recvfrom (uint32_t session_index, void *buffer,
+ uint32_t buflen, int flags, vppcom_endpt_t * ep)
+{
+ int rv = VPPCOM_OK;
+ session_t *session = 0;
+
+ if (ep)
+ {
+ VCL_SESSION_LOCK ();
+ rv = vppcom_session_at_index (session_index, &session);
+ if (PREDICT_FALSE (rv))
+ {
+ VCL_SESSION_UNLOCK ();
+ VDBG (0, "VCL<%d>: invalid session, sid (%u) has been closed!",
+ getpid (), session_index);
+ rv = VPPCOM_EBADFD;
+ VCL_SESSION_UNLOCK ();
+ goto done;
+ }
+ ep->is_ip4 = session->peer_addr.is_ip4;
+ ep->port = session->peer_port;
+ if (session->peer_addr.is_ip4)
+ clib_memcpy (ep->ip, &session->peer_addr.ip46.ip4,
+ sizeof (ip4_address_t));
+ else
+ clib_memcpy (ep->ip, &session->peer_addr.ip46.ip6,
+ sizeof (ip6_address_t));
+ VCL_SESSION_UNLOCK ();
+ }
+
+ if (flags == 0)
+ rv = vppcom_session_read (session_index, buffer, buflen);
+ else if (flags & MSG_PEEK)
+ rv = vppcom_session_peek (session_index, buffer, buflen);
+ else
+ {
+ clib_warning ("VCL<%d>: Unsupport flags for recvfrom %d",
+ getpid (), flags);
+ rv = VPPCOM_EAFNOSUPPORT;
+ }
+
+done:
+ return rv;
+}
+
+int
+vppcom_session_sendto (uint32_t session_index, void *buffer,
+ uint32_t buflen, int flags, vppcom_endpt_t * ep)
+{
+ if (!buffer)
+ return VPPCOM_EINVAL;
+
+ if (ep)
+ {
+ // TBD
+ return VPPCOM_EINVAL;
+ }
+
+ if (flags)
+ {
+ // TBD check the flags and do the right thing
+ VDBG (2, "VCL<%d>: handling flags 0x%u (%d) not implemented yet.",
+ getpid (), flags, flags);
+ }
+
+ return (vppcom_session_write (session_index, buffer, buflen));
+}
+
+int
+vppcom_poll (vcl_poll_t * vp, uint32_t n_sids, double wait_for_time)
+{
+ f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
+ u32 i, keep_trying = 1;
+ int rv, num_ev = 0;
+
+ VDBG (3, "VCL<%d>: vp %p, nsids %u, wait_for_time %f",
+ getpid (), vp, n_sids, wait_for_time);
+
+ if (!vp)
+ return VPPCOM_EFAULT;
+
+ do
+ {
+ session_t *session;
+
+ for (i = 0; i < n_sids; i++)
+ {
+ ASSERT (vp[i].revents);
+
+ VCL_SESSION_LOCK_AND_GET (vp[i].sid, &session);
+ VCL_SESSION_UNLOCK ();
+
+ if (*vp[i].revents)
+ *vp[i].revents = 0;
+
+ if (POLLIN & vp[i].events)
+ {
+ VCL_SESSION_LOCK_AND_GET (vp[i].sid, &session);
+ rv = vppcom_session_read_ready (session, vp[i].sid);
+ VCL_SESSION_UNLOCK ();
+ if (rv > 0)
+ {
+ *vp[i].revents |= POLLIN;
+ num_ev++;
+ }
+ else if (rv < 0)
+ {
+ switch (rv)
+ {
+ case VPPCOM_ECONNRESET:
+ *vp[i].revents = POLLHUP;
+ break;
+
+ default:
+ *vp[i].revents = POLLERR;
+ break;
+ }
+ num_ev++;
+ }
+ }
+
+ if (POLLOUT & vp[i].events)
+ {
+ VCL_SESSION_LOCK_AND_GET (vp[i].sid, &session);
+ rv = vppcom_session_write_ready (session, vp[i].sid);
+ VCL_SESSION_UNLOCK ();
+ if (rv > 0)
+ {
+ *vp[i].revents |= POLLOUT;
+ num_ev++;
+ }
+ else if (rv < 0)
+ {
+ switch (rv)
+ {
+ case VPPCOM_ECONNRESET:
+ *vp[i].revents = POLLHUP;
+ break;
+
+ default:
+ *vp[i].revents = POLLERR;
+ break;
+ }
+ num_ev++;
+ }
+ }
+
+ if (0) // Note "done:" label used by VCL_SESSION_LOCK_AND_GET()
+ {
+ done:
+ *vp[i].revents = POLLNVAL;
+ num_ev++;
+ }
+ }
+ if (wait_for_time != -1)
+ keep_trying = (clib_time_now (&vcm->clib_time) <= timeout) ? 1 : 0;
+ }
+ while ((num_ev == 0) && keep_trying);
+
+ if (VPPCOM_DEBUG > 3)
+ {
+ clib_warning ("VCL<%d>: returning %d", getpid (), num_ev);
+ for (i = 0; i < n_sids; i++)
+ {
+ clib_warning ("VCL<%d>: vp[%d].sid %d (0x%x), .events 0x%x, "
+ ".revents 0x%x", getpid (), i, vp[i].sid, vp[i].sid,
+ vp[i].events, *vp[i].revents);
+ }
+ }
+ return num_ev;
+}
+
+/*
+ * VPPCOM Event Functions
+ */
+
+void *
+vppcom_session_io_thread_fn (void *arg)
+{
+ vppcom_session_io_thread_t *evt = (vppcom_session_io_thread_t *) arg;
+ u32 *session_indexes = 0, *session_index;
+ int i, rv;
+ u32 bytes = 0;
+ session_t *session;
+
+ while (1)
+ {
+ vec_reset_length (session_indexes);
+ VCE_IO_SESSIONS_LOCK ();
+ pool_foreach (session_index, evt->active_session_indexes, (
+ {
+ vec_add1
+ (session_indexes,
+ *session_index);
+ }
+ ));
+ VCE_IO_SESSIONS_UNLOCK ();
+ if (session_indexes)
+ {
+ for (i = 0; i < vec_len (session_indexes); ++i)
+ {
+ VCL_SESSION_LOCK_AND_GET (session_indexes[i], &session);
+ bytes = svm_fifo_max_dequeue (session->rx_fifo);
+ VCL_SESSION_UNLOCK ();
+
+ if (bytes)
+ {
+ vppcom_ioevent_t *eio;
+ vce_event_t *ev;
+ u32 ev_idx;
+
+ VCL_EVENTS_LOCK ();
+
+ pool_get (vcm->event_thread.vce_events, ev);
+ ev_idx = (u32) (ev - vcm->event_thread.vce_events);
+ eio = vce_get_event_data (ev, sizeof (*eio));
+ ev->evk.eid = VCL_EVENT_IOEVENT_RX_FIFO;
+ ev->evk.session_index = session_indexes[i];
+ eio->bytes = bytes;
+ eio->session_index = session_indexes[i];
+
+ VCL_EVENTS_UNLOCK ();
+
+ rv = vce_generate_event (&vcm->event_thread, ev_idx);
+ }
+ }
+ }
+ struct timespec ts;
+ ts.tv_sec = 0;
+ ts.tv_nsec = 1000000; /* 1 millisecond */
+ nanosleep (&ts, NULL);
+ }
+done:
+ VCL_SESSION_UNLOCK ();
+ return NULL;
+}
+
+int
+vppcom_start_io_event_thread (vppcom_session_io_thread_t * evt,
+ u8 max_sessions)
+{
+ pthread_cond_init (&(evt->vce_io_cond), NULL);
+ pthread_mutex_init (&(evt->vce_io_lock), NULL);
+
+ clib_spinlock_init (&(evt->io_sessions_lockp));
+
+ return pthread_create (&(evt->thread), NULL /* attr */ ,
+ vppcom_session_io_thread_fn, evt);
+}
+
+void
+vce_registered_ioevent_handler_fn (void *arg)
+{
+ vce_event_handler_reg_t *reg = (vce_event_handler_reg_t *) arg;
+ vppcom_ioevent_t *eio;
+ vce_event_t *ev;
+ u32 ioevt_ndx = (u64) (reg->handler_fn_args);
+ vppcom_session_ioevent_t *ioevent, ioevent_;
+
+ VCL_EVENTS_LOCK ();
+ ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx);
+ eio = vce_get_event_data (ev, sizeof (*eio));
+ VCL_EVENTS_UNLOCK ();
+
+ VCL_IO_SESSIONS_LOCK ();
+ ioevent = pool_elt_at_index (vcm->session_io_thread.ioevents, ioevt_ndx);
+ ioevent_ = *ioevent;
+ VCL_IO_SESSIONS_UNLOCK ();
+ (ioevent_.user_cb) (eio, ioevent_.user_cb_data);
+ vce_clear_event (&vcm->event_thread, reg->ev_idx);
+ return;
+
+ /*TODO - Unregister check in close for this listener */
+
+}
+
+void
+vce_registered_listener_connect_handler_fn (void *arg)
+{
+ vce_event_handler_reg_t *reg = (vce_event_handler_reg_t *) arg;
+ vce_event_connect_request_t *ecr;
+ vce_event_t *ev;
+ vppcom_endpt_t ep;
+
+ session_t *new_session;
+ int rv;
+
+ vppcom_session_listener_t *session_listener =
+ (vppcom_session_listener_t *) reg->handler_fn_args;
+
+ VCL_EVENTS_LOCK ();
+ ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx);
+ ecr = vce_get_event_data (ev, sizeof (*ecr));
+ VCL_EVENTS_UNLOCK ();
+ VCL_SESSION_LOCK_AND_GET (ecr->accepted_session_index, &new_session);
+
+ ep.is_ip4 = new_session->peer_addr.is_ip4;
+ ep.port = new_session->peer_port;
+ if (new_session->peer_addr.is_ip4)
+ clib_memcpy (&ep.ip, &new_session->peer_addr.ip46.ip4,
+ sizeof (ip4_address_t));
+ else
+ clib_memcpy (&ep.ip, &new_session->peer_addr.ip46.ip6,
+ sizeof (ip6_address_t));
+
+ vppcom_send_accept_session_reply (new_session->vpp_handle,
+ new_session->client_context,
+ 0 /* retval OK */ );
+ VCL_SESSION_UNLOCK ();
+
+ (session_listener->user_cb) (ecr->accepted_session_index, &ep,
+ session_listener->user_cb_data);
+
+ if (vcm->session_io_thread.io_sessions_lockp)
+ {
+ /* Throw this new accepted session index into the rx poll thread pool */
+ VCL_IO_SESSIONS_LOCK ();
+ u32 *active_session_index;
+ pool_get (vcm->session_io_thread.active_session_indexes,
+ active_session_index);
+ *active_session_index = ecr->accepted_session_index;
+ VCL_IO_SESSIONS_UNLOCK ();
+ }
+
+ /*TODO - Unregister check in close for this listener */
+ return;
+
+done:
+ ASSERT (0); // If we can't get a lock or accepted session fails, lets blow up.
+}
+
+/**
+ * @brief vce_poll_wait_connect_request_handler_fn
+ * - used by vppcom_epoll_xxxx() for listener sessions
+ * - when a vl_api_accept_session_t_handler() generates an event
+ * this callback is alerted and sets the fields that vppcom_epoll_wait()
+ * expects to see.
+ *
+ * @param arg - void* to be cast to vce_event_handler_reg_t*
+ */
+void
+vce_poll_wait_connect_request_handler_fn (void *arg)
+{
+ vce_event_handler_reg_t *reg = (vce_event_handler_reg_t *) arg;
+ vce_event_t *ev;
+ /* Retrieve the VCL_EVENT_CONNECT_REQ_ACCEPTED event */
+ ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx);
+ vce_event_connect_request_t *ecr = vce_get_event_data (ev, sizeof (*ecr));
+
+ /* Add the accepted_session_index to the FIFO */
+ VCL_ACCEPT_FIFO_LOCK ();
+ clib_fifo_add1 (vcm->client_session_index_fifo,
+ ecr->accepted_session_index);
+ VCL_ACCEPT_FIFO_UNLOCK ();
+
+ /* Recycling the event. */
+ VCL_EVENTS_LOCK ();
+ ev->recycle = 1;
+ clib_fifo_add1 (vcm->event_thread.event_index_fifo, reg->ev_idx);
+ VCL_EVENTS_UNLOCK ();
+}
+
+int
+vppcom_session_register_ioevent_cb (uint32_t session_index,
+ vppcom_session_ioevent_cb cb,
+ uint8_t rx, void *ptr)
+{
+ int rv = VPPCOM_OK;
+ vce_event_key_t evk;
+ vppcom_session_ioevent_t *ioevent;
+
+ if (!vcm->session_io_thread.io_sessions_lockp)
+ rv = vppcom_start_io_event_thread (&vcm->session_io_thread, 100 /* DAW_TODO: ??? hard-coded value */
+ );
+
+ if (rv == VPPCOM_OK)
+ {
+ void *io_evt_ndx;
+
+ /* Register handler for ioevent on session_index */
+ VCL_IO_SESSIONS_LOCK ();
+ pool_get (vcm->session_io_thread.ioevents, ioevent);
+ io_evt_ndx = (void *) (ioevent - vcm->session_io_thread.ioevents);
+ ioevent->user_cb = cb;
+ ioevent->user_cb_data = ptr;
+ VCL_IO_SESSIONS_UNLOCK ();
+
+ evk.session_index = session_index;
+ evk.eid = rx ? VCL_EVENT_IOEVENT_RX_FIFO : VCL_EVENT_IOEVENT_TX_FIFO;
+
+ (void) vce_register_handler (&vcm->event_thread, &evk,
+ vce_registered_ioevent_handler_fn,
+ io_evt_ndx);
+ }
+ return rv;
+}
+
+int
+vppcom_session_register_listener (uint32_t session_index,
+ vppcom_session_listener_cb cb,
+ vppcom_session_listener_errcb
+ errcb, uint8_t flags, int q_len, void *ptr)
+{
+ int rv = VPPCOM_OK;
+ vce_event_key_t evk;
+ vppcom_session_listener_t *listener_args;
+
+ if (!vcm->session_io_thread.io_sessions_lockp)
+ rv = vppcom_start_io_event_thread (&vcm->session_io_thread, 100 /* DAW_TODO: ??? hard-coded value */
+ );
+ if (rv)
+ {
+ goto done;
+ }
+ rv = vppcom_session_listen (session_index, q_len);
+ if (rv)
+ {
+ goto done;
+ }
+
+ /* Register handler for connect_request event on listen_session_index */
+ listener_args = clib_mem_alloc (sizeof (vppcom_session_listener_t)); // DAW_TODO: Use a pool instead of thrashing the memory allocator!
+ listener_args->user_cb = cb;
+ listener_args->user_cb_data = ptr;
+ listener_args->user_errcb = errcb;
+
+ evk.session_index = session_index;
+ evk.eid = VCL_EVENT_CONNECT_REQ_ACCEPTED;
+ (void) vce_register_handler (&vcm->event_thread, &evk,
+ vce_registered_listener_connect_handler_fn,
+ listener_args);
+
+done: