/*
*------------------------------------------------------------------
- * socksvr_vlib.c
+ * socket_api.c
*
* Copyright (c) 2009 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
socket_main_t socket_main;
+#define SOCK_API_REG_HANDLE_BIT (1<<31)
+
+static u32
+sock_api_registration_handle (vl_api_registration_t * regp)
+{
+ ASSERT (regp->vl_api_registration_pool_index < SOCK_API_REG_HANDLE_BIT);
+ return regp->vl_api_registration_pool_index | SOCK_API_REG_HANDLE_BIT;
+}
+
+static u32
+socket_api_registration_handle_to_index (u32 reg_index)
+{
+ return (reg_index & ~SOCK_API_REG_HANDLE_BIT);
+}
+
+u8
+vl_socket_api_registration_handle_is_valid (u32 reg_handle)
+{
+ return ((reg_handle & SOCK_API_REG_HANDLE_BIT) != 0);
+}
+
void
vl_sock_api_dump_clients (vlib_main_t * vm, api_main_t * am)
{
/* *INDENT-ON* */
}
+vl_api_registration_t *
+vl_socket_api_client_handle_to_registration (u32 handle)
+{
+ socket_main_t *sm = &socket_main;
+ u32 index = socket_api_registration_handle_to_index (handle);
+ if (pool_is_free_index (sm->registration_pool, index))
+ {
+#if DEBUG > 2
+ clib_warning ("Invalid index %d\n", index);
+#endif
+ return 0;
+ }
+ return pool_elt_at_index (sm->registration_pool, index);
+}
+
void
vl_socket_api_send (vl_api_registration_t * rp, u8 * elem)
{
api_main_t *am = &api_main;
msgbuf_t *mb = (msgbuf_t *) (elem - offsetof (msgbuf_t, data));
vl_api_registration_t *sock_rp;
+ clib_file_main_t *fm = &file_main;
+ clib_error_t *error;
clib_file_t *cf;
cf = vl_api_registration_file (rp);
ASSERT (sock_rp);
/* Add the msgbuf_t to the output vector */
- vl_socket_add_pending_output_no_flush (cf, sock_rp, (u8 *) mb,
- sizeof (*mb));
- /* Send the message */
- vl_socket_add_pending_output (cf, sock_rp, elem, ntohl (mb->data_len));
+ vec_add (sock_rp->output_vector, (u8 *) mb, sizeof (*mb));
+
+ /* Try to send the message and save any error like
+ * we do in the input epoll loop */
+ vec_add (sock_rp->output_vector, elem, ntohl (mb->data_len));
+ error = clib_file_write (cf);
+ unix_save_error (&unix_main, error);
+
+ /* If we didn't finish sending everything, wait for tx space */
+ if (vec_len (sock_rp->output_vector) > 0
+ && !(cf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE))
+ {
+ cf->flags |= UNIX_FILE_DATA_AVAILABLE_TO_WRITE;
+ fm->file_update (cf, UNIX_FILE_UPDATE_MODIFY);
+ }
#if CLIB_DEBUG > 1
output_length = sizeof (*mb) + ntohl (mb->data_len);
socket_main.current_rp = 0;
}
+/*
+ * Read function for API socket.
+ *
+ * Read data from socket, invoke SOCKET_READ_EVENT
+ * for each fully read API message, return 0.
+ * Store incomplete data for next invocation to continue.
+ *
+ * On severe read error, the file is closed.
+ *
+ * As reading is single threaded,
+ * socket_main.input_buffer is used temporarily.
+ * Even its length is modified, but always restored before return.
+ *
+ * Incomplete data is copied into a vector,
+ * pointer saved in registration's unprocessed_input.
+ */
clib_error_t *
vl_socket_read_ready (clib_file_t * uf)
{
clib_file_main_t *fm = &file_main;
vlib_main_t *vm = vlib_get_main ();
vl_api_registration_t *rp;
+ /* n is the size of data read to input_buffer */
int n;
+ /* msg_buffer vector can point to input_buffer or unprocessed_input */
i8 *msg_buffer = 0;
+ /* data_for_process is a vector containing one full message, incl msgbuf_t */
u8 *data_for_process;
- u32 msg_len;
+ /* msgbuf_len is the size of one message, including sizeof (msgbuf_t) */
+ u32 msgbuf_len;
u32 save_input_buffer_length = vec_len (socket_main.input_buffer);
vl_socket_args_for_process_t *a;
- msgbuf_t *mbp;
- int mbp_set = 0;
rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
+ /* Ignore unprocessed_input for now, n describes input_buffer for now. */
n = read (uf->file_descriptor, socket_main.input_buffer,
vec_len (socket_main.input_buffer));
- if (n <= 0 && errno != EAGAIN)
+ if (n <= 0)
{
- clib_file_del (fm, uf);
-
- if (!pool_is_free (socket_main.registration_pool, rp))
+ if (errno != EAGAIN)
{
- u32 index = rp - socket_main.registration_pool;
- vl_socket_free_registration_index (index);
- }
- else
- {
- clib_warning ("client index %d already free?",
- rp->vl_api_registration_pool_index);
+ /* Severe error, close the file. */
+ clib_file_del (fm, uf);
+
+ if (!pool_is_free (socket_main.registration_pool, rp))
+ {
+ u32 index = rp - socket_main.registration_pool;
+ vl_socket_free_registration_index (index);
+ }
+ else
+ {
+ clib_warning ("client index %d already free?",
+ rp->vl_api_registration_pool_index);
+ }
}
+ /* EAGAIN means we do not close the file, but no data to process anyway. */
return 0;
}
+ /* Fake smaller length teporarily, so input_buffer can be used as msg_buffer. */
_vec_len (socket_main.input_buffer) = n;
/*
* boundaries. In the case of a long message (>4K bytes)
* we have to do (at least) 2 reads, etc.
*/
+ /* Determine msg_buffer. */
+ if (vec_len (rp->unprocessed_input))
+ {
+ vec_append (rp->unprocessed_input, socket_main.input_buffer);
+ msg_buffer = rp->unprocessed_input;
+ }
+ else
+ {
+ msg_buffer = socket_main.input_buffer;
+ }
+ /* Loop to process any full messages. */
+ ASSERT (vec_len (msg_buffer) > 0);
do
{
- if (vec_len (rp->unprocessed_input))
- {
- vec_append (rp->unprocessed_input, socket_main.input_buffer);
- msg_buffer = rp->unprocessed_input;
- }
- else
- {
- msg_buffer = socket_main.input_buffer;
- mbp_set = 0;
- }
-
- if (mbp_set == 0)
- {
- /* Any chance that we have a complete message? */
- if (vec_len (msg_buffer) <= sizeof (msgbuf_t))
- goto save_and_split;
-
- mbp = (msgbuf_t *) msg_buffer;
- msg_len = ntohl (mbp->data_len);
- mbp_set = 1;
- }
-
- /* We don't have the entire message yet. */
- if (mbp_set == 0
- || (msg_len + sizeof (msgbuf_t)) > vec_len (msg_buffer))
+ /* Here, we are not sure how big a chunk of message we have left. */
+ /* Do we at least know how big the full message will be? */
+ if (vec_len (msg_buffer) <= sizeof (msgbuf_t))
+ /* No, so fragment is not a full message. */
+ goto save_and_split;
+
+ /* Now we know how big the full message will be. */
+ msgbuf_len =
+ ntohl (((msgbuf_t *) msg_buffer)->data_len) + sizeof (msgbuf_t);
+
+ /* But do we have a full message? */
+ if (msgbuf_len > vec_len (msg_buffer))
{
save_and_split:
- /* if we were using the input buffer save the fragment */
+ /* We don't have the entire message yet. */
+ /* If msg_buffer is unprocessed_input, nothing needs to be done. */
if (msg_buffer == socket_main.input_buffer)
+ /* But if we were using the input buffer, save the fragment. */
{
ASSERT (vec_len (rp->unprocessed_input) == 0);
vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1);
- clib_memcpy (rp->unprocessed_input, msg_buffer,
- vec_len (msg_buffer));
+ clib_memcpy_fast (rp->unprocessed_input, msg_buffer,
+ vec_len (msg_buffer));
_vec_len (rp->unprocessed_input) = vec_len (msg_buffer);
}
+ /* No more full messages, restore original input_buffer length. */
_vec_len (socket_main.input_buffer) = save_input_buffer_length;
return 0;
}
+ /*
+ * We have at least one full message.
+ * But msg_buffer can contain more data, so copy one message data
+ * so we can overwrite its length to what single message has.
+ */
data_for_process = (u8 *) vec_dup (msg_buffer);
- _vec_len (data_for_process) = (msg_len + sizeof (msgbuf_t));
+ _vec_len (data_for_process) = msgbuf_len;
+ /* Everything is ready to signal the SOCKET_READ_EVENT. */
pool_get (socket_main.process_args, a);
a->clib_file = uf;
a->regp = rp;
vlib_process_signal_event (vm, vl_api_clnt_node.index,
SOCKET_READ_EVENT,
a - socket_main.process_args);
- if (n > (msg_len + sizeof (*mbp)))
- vec_delete (msg_buffer, msg_len + sizeof (*mbp), 0);
+ if (vec_len (msg_buffer) > msgbuf_len)
+ /* There are some fragments left. Shrink the msg_buffer to simplify logic. */
+ vec_delete (msg_buffer, msgbuf_len, 0);
else
+ /* We are done with msg_buffer. */
_vec_len (msg_buffer) = 0;
- n -= msg_len + sizeof (msgbuf_t);
- msg_len = 0;
- mbp_set = 0;
}
- while (n > 0);
+ while (vec_len (msg_buffer) > 0);
+ /* Restore input_buffer, it could have been msg_buffer. */
_vec_len (socket_main.input_buffer) = save_input_buffer_length;
-
return 0;
}
-void
-vl_socket_add_pending_output (clib_file_t * uf,
- vl_api_registration_t * rp,
- u8 * buffer, uword buffer_bytes)
-{
- clib_file_main_t *fm = &file_main;
-
- vec_add (rp->output_vector, buffer, buffer_bytes);
- if (vec_len (rp->output_vector) > 0)
- {
- int skip_update = 0 != (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE);
- uf->flags |= UNIX_FILE_DATA_AVAILABLE_TO_WRITE;
- if (!skip_update)
- fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY);
- }
-}
-
-void
-vl_socket_add_pending_output_no_flush (clib_file_t * uf,
- vl_api_registration_t * rp,
- u8 * buffer, uword buffer_bytes)
-{
- vec_add (rp->output_vector, buffer, buffer_bytes);
-}
-
-static void
-socket_del_pending_output (clib_file_t * uf,
- vl_api_registration_t * rp, uword n_bytes)
-{
- clib_file_main_t *fm = &file_main;
-
- vec_delete (rp->output_vector, n_bytes, 0);
- if (vec_len (rp->output_vector) <= 0)
- {
- int skip_update = 0 == (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE);
- uf->flags &= ~UNIX_FILE_DATA_AVAILABLE_TO_WRITE;
- if (!skip_update)
- fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY);
- }
-}
-
clib_error_t *
vl_socket_write_ready (clib_file_t * uf)
{
rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
/* Flush output vector. */
- n = write (uf->file_descriptor,
- rp->output_vector, vec_len (rp->output_vector));
- if (n < 0)
+ size_t total_bytes = vec_len (rp->output_vector);
+ size_t bytes_to_send, remaining_bytes = total_bytes;
+ void *p = rp->output_vector;
+ while (remaining_bytes > 0)
{
+ bytes_to_send = remaining_bytes > 4096 ? 4096 : remaining_bytes;
+ n = write (uf->file_descriptor, p, bytes_to_send);
+ if (n < 0)
+ {
+ if (errno == EAGAIN)
+ {
+ break;
+ }
#if DEBUG > 2
- clib_warning ("write error, close the file...\n");
+ clib_warning ("write error, close the file...\n");
#endif
- clib_file_del (fm, uf);
-
- vl_socket_free_registration_index (rp - socket_main.registration_pool);
- return 0;
+ clib_file_del (fm, uf);
+ vl_socket_free_registration_index (rp -
+ socket_main.registration_pool);
+ return 0;
+ }
+ remaining_bytes -= bytes_to_send;
+ p += bytes_to_send;
}
- else if (n > 0)
- socket_del_pending_output (uf, rp, n);
+ vec_delete (rp->output_vector, total_bytes - remaining_bytes, 0);
+ if (vec_len (rp->output_vector) <= 0
+ && (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE))
+ {
+ uf->flags &= ~UNIX_FILE_DATA_AVAILABLE_TO_WRITE;
+ fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY);
+ }
return 0;
}
clib_file_t template = { 0 };
pool_get (socket_main.registration_pool, rp);
- memset (rp, 0, sizeof (*rp));
+ clib_memset (rp, 0, sizeof (*rp));
template.read_function = vl_socket_read_ready;
template.write_function = vl_socket_write_ready;
{
vl_api_registration_t *regp;
vl_api_sockclnt_create_reply_t *rp;
+ api_main_t *am = &api_main;
+ hash_pair_t *hp;
int rv = 0;
+ u32 nmsg = hash_elts (am->msg_index_by_name_and_crc);
+ u32 i = 0;
regp = socket_main.current_rp;
regp->name = format (0, "%s%c", mp->name, 0);
- rp = vl_msg_api_alloc (sizeof (*rp));
+ u32 size = sizeof (*rp) + (nmsg * sizeof (vl_api_message_table_entry_t));
+ rp = vl_msg_api_alloc_zero (size);
rp->_vl_msg_id = htons (VL_API_SOCKCLNT_CREATE_REPLY);
- rp->handle = (uword) regp;
- rp->index = (uword) regp->vl_api_registration_pool_index;
+ rp->index = htonl (sock_api_registration_handle (regp));
rp->context = mp->context;
rp->response = htonl (rv);
-
+ rp->count = htons (nmsg);
+
+ /* *INDENT-OFF* */
+ hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
+ ({
+ rp->message_table[i].index = htons(hp->value[0]);
+ strncpy_s((char *)rp->message_table[i].name, 64 /* bytes of space at dst */,
+ (char *)hp->key, 64-1 /* chars to copy, without zero byte. */);
+ i++;
+ }));
+ /* *INDENT-ON* */
vl_api_send_msg (regp, (u8 *) rp);
}
vl_api_registration_t *regp;
vl_api_sockclnt_delete_reply_t *rp;
- if (!pool_is_free_index (socket_main.registration_pool, mp->index))
- {
- regp = pool_elt_at_index (socket_main.registration_pool, mp->index);
+ regp = vl_api_client_index_to_registration (mp->client_index);
+ if (!regp)
+ return;
- rp = vl_msg_api_alloc (sizeof (*rp));
- rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY);
- rp->handle = mp->handle;
- rp->response = htonl (1);
+ u32 reg_index = socket_api_registration_handle_to_index (ntohl (mp->index));
+ rp = vl_msg_api_alloc (sizeof (*rp));
+ rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY);
+ rp->context = mp->context;
+ if (!pool_is_free_index (socket_main.registration_pool, reg_index))
+ {
+ rp->response = htonl (1);
vl_api_send_msg (regp, (u8 *) rp);
vl_api_registration_del_file (regp);
- vl_socket_free_registration_index (mp->index);
+ vl_socket_free_registration_index (reg_index);
}
else
{
- clib_warning ("unknown client ID %d", mp->index);
+ clib_warning ("unknown client ID %d", reg_index);
+ rp->response = htonl (-1);
+ vl_api_send_msg (regp, (u8 *) rp);
}
}
clib_error_t *
-vl_sock_api_send_fd_msg (int socket_fd, int fd_to_share)
+vl_sock_api_send_fd_msg (int socket_fd, int fds[], int n_fds)
{
struct msghdr mh = { 0 };
struct iovec iov[1];
- char ctl[CMSG_SPACE (sizeof (int))];
- char *msg = "memfd";
+ char ctl[CMSG_SPACE (sizeof (int) * n_fds)];
+ struct cmsghdr *cmsg;
+ char *msg = "fdmsg";
int rv;
iov[0].iov_base = msg;
mh.msg_iov = iov;
mh.msg_iovlen = 1;
- struct cmsghdr *cmsg;
- memset (&ctl, 0, sizeof (ctl));
+ clib_memset (&ctl, 0, sizeof (ctl));
mh.msg_control = ctl;
mh.msg_controllen = sizeof (ctl);
cmsg = CMSG_FIRSTHDR (&mh);
- cmsg->cmsg_len = CMSG_LEN (sizeof (int));
+ cmsg->cmsg_len = CMSG_LEN (sizeof (int) * n_fds);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
- memcpy (CMSG_DATA (cmsg), &fd_to_share, sizeof (int));
+ clib_memcpy_fast (CMSG_DATA (cmsg), fds, sizeof (int) * n_fds);
rv = sendmsg (socket_fd, &mh, 0);
if (rv < 0)
clib_file_t *cf;
vl_api_shm_elem_config_t *config = 0;
vl_shmem_hdr_t *shmem_hdr;
- int rv;
+ int rv, tries = 1000;
regp = vl_api_client_index_to_registration (mp->client_index);
if (regp == 0)
* Set up a memfd segment of the requested size wherein the
* shmem data structures will be initialized
*/
- memset (memfd, 0, sizeof (*memfd));
+ clib_memset (memfd, 0, sizeof (*memfd));
memfd->ssvm_size = mp->requested_size;
memfd->requested_va = 0ULL;
memfd->i_am_master = 1;
/*
* Create a plausible svm_region in the memfd backed segment
*/
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->baseva = memfd->sh->ssvm_va + MMAP_PAGESIZE;
a->size = memfd->ssvm_size - MMAP_PAGESIZE;
/* $$$$ might want a different config parameter */
rmp->context = mp->context;
rmp->retval = htonl (rv);
- vl_api_send_msg (regp, (u8 *) rmp);
+ /*
+ * Note: The reply message needs to make it out the back door
+ * before we send the magic fd message. That's taken care of by
+ * the send function.
+ */
+ vl_socket_api_send (regp, (u8 *) rmp);
if (rv != 0)
return;
- /*
- * We need the reply message to make it out the back door
- * before we send the magic fd message so force a flush
- */
+ /* Send the magic "here's your sign (aka fd)" socket message */
cf = vl_api_registration_file (regp);
- cf->write_function (cf);
- /* Send the magic "here's your sign (aka fd)" socket message */
- vl_sock_api_send_fd_msg (cf->file_descriptor, memfd->fd);
+ /* Wait for reply to be consumed before sending the fd */
+ while (tries-- > 0)
+ {
+ int bytes;
+ rv = ioctl (cf->file_descriptor, TIOCOUTQ, &bytes);
+ if (rv < 0)
+ {
+ clib_unix_warning ("ioctl returned");
+ break;
+ }
+ if (bytes == 0)
+ break;
+ usleep (1e3);
+ }
+
+ vl_sock_api_send_fd_msg (cf->file_descriptor, &memfd->fd, 1);
}
#define foreach_vlib_api_msg \
-_(SOCKCLNT_CREATE, sockclnt_create) \
-_(SOCKCLNT_DELETE, sockclnt_delete) \
-_(SOCK_INIT_SHM, sock_init_shm)
+ _(SOCKCLNT_CREATE, sockclnt_create, 1) \
+ _(SOCKCLNT_DELETE, sockclnt_delete, 1) \
+ _(SOCK_INIT_SHM, sock_init_shm, 1)
clib_error_t *
vl_sock_api_init (vlib_main_t * vm)
if (sm->socket_name == 0)
return 0;
-#define _(N,n) \
+#define _(N,n,t) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
vl_api_##n##_t_handler, \
vl_noop_handler, \
vl_api_##n##_t_endian, \
vl_api_##n##_t_print, \
- sizeof(vl_api_##n##_t), 1);
+ sizeof(vl_api_##n##_t), t);
foreach_vlib_api_msg;
#undef _
vec_resize (sm->input_buffer, 4096);
sock->config = (char *) sm->socket_name;
-
- /* mkdir of file socket, only under /run */
- if (strncmp (sock->config, "/run", 4) == 0)
- {
- u8 *tmp = format (0, "%s", sock->config);
- int i = vec_len (tmp);
- while (i && tmp[--i] != '/')
- ;
-
- tmp[i] = 0;
-
- if (i)
- vlib_unix_recursive_mkdir ((char *) tmp);
- vec_free (tmp);
- }
-
- sock->flags = CLIB_SOCKET_F_IS_SERVER | CLIB_SOCKET_F_SEQPACKET |
- CLIB_SOCKET_F_ALLOW_GROUP_WRITE;
+ sock->flags = CLIB_SOCKET_F_IS_SERVER | CLIB_SOCKET_F_ALLOW_GROUP_WRITE;
error = clib_socket_init (sock);
if (error)
return error;
pool_get (sm->registration_pool, rp);
- memset (rp, 0, sizeof (*rp));
+ clib_memset (rp, 0, sizeof (*rp));
rp->registration_type = REGISTRATION_TYPE_SOCKET_LISTEN;
{
if (unformat (input, "socket-name %s", &sm->socket_name))
;
+ /* DEPRECATE: default keyword is ignored */
else if (unformat (input, "default"))
- {
- sm->socket_name = format (0, "%s%c", API_SOCKET_FILE, 0);
- }
+ ;
else
{
return clib_error_return (0, "unknown input '%U'",
format_unformat_error, input);
}
}
+
+ if (!vec_len (sm->socket_name))
+ sm->socket_name = format (0, "%s/%s", vlib_unix_get_runtime_dir (),
+ API_SOCKET_FILENAME);
+ vec_terminate_c_string (sm->socket_name);
+
return 0;
}
VLIB_CONFIG_FUNCTION (socksvr_config, "socksvr");
-clib_error_t *
-vlibsocket_init (vlib_main_t * vm)
+void
+vlibsocket_reference ()
{
- return 0;
}
-VLIB_INIT_FUNCTION (vlibsocket_init);
-
/*
* fd.io coding-style-patch-verification: ON
*
Code Review / vpp.git / blobdiff