Hi, On Fri, Nov 13, 2015 at 04:26:16PM +0100, Francois Gouget wrote: > This will simplify selectively disabling the server-side code. Thanks for splitting the PATCH. If nobody complains I'll be pushing the vdagent patches shortly. PS: Now it seems to be correctly threaded in patchwork, thanks! https://patchwork.freedesktop.org/series/745/ Cheers, Victor Toso > Signed-off-by: Francois Gouget <fgouget@xxxxxxxxxxxxxxx> > --- > src/udscs.c | 478 ++++++++++++++++++++++++++++++------------------------------ > src/udscs.h | 128 +++++++++------- > 2 files changed, 314 insertions(+), 292 deletions(-) > > I separated the reordering from the addition of the #ifdefs as suggested > by Victor Toso: > http://lists.freedesktop.org/archives/spice-devel/2015-November/023457.html > > diff --git a/src/udscs.c b/src/udscs.c > index 288aca2..732db33 100644 > --- a/src/udscs.c > +++ b/src/udscs.c > @@ -66,86 +66,6 @@ struct udscs_connection { > struct udscs_connection *prev; > }; > > -struct udscs_server { > - int fd; > - const char * const *type_to_string; > - int no_types; > - int debug; > - struct udscs_connection connections_head; > - udscs_connect_callback connect_callback; > - udscs_read_callback read_callback; > - udscs_disconnect_callback disconnect_callback; > -}; > - > -static void udscs_do_write(struct udscs_connection **connp); > -static void udscs_do_read(struct udscs_connection **connp); > - > - > -struct udscs_server *udscs_create_server(const char *socketname, > - udscs_connect_callback connect_callback, > - udscs_read_callback read_callback, > - udscs_disconnect_callback disconnect_callback, > - const char * const type_to_string[], int no_types, int debug) > -{ > - int c; > - struct sockaddr_un address; > - struct udscs_server *server; > - > - server = calloc(1, sizeof(*server)); > - if (!server) > - return NULL; > - > - server->type_to_string = type_to_string; > - server->no_types = no_types; > - server->debug = debug; > - > - server->fd = socket(PF_UNIX, SOCK_STREAM, 0); > - if (server->fd == -1) { > - syslog(LOG_ERR, "creating unix domain socket: %m"); > - free(server); > - return NULL; > - } > - > - address.sun_family = AF_UNIX; > - snprintf(address.sun_path, sizeof(address.sun_path), "%s", socketname); > - c = bind(server->fd, (struct sockaddr *)&address, sizeof(address)); > - if (c != 0) { > - syslog(LOG_ERR, "bind %s: %m", socketname); > - free(server); > - return NULL; > - } > - > - c = listen(server->fd, 5); > - if (c != 0) { > - syslog(LOG_ERR, "listen: %m"); > - free(server); > - return NULL; > - } > - > - server->connect_callback = connect_callback; > - server->read_callback = read_callback; > - server->disconnect_callback = disconnect_callback; > - > - return server; > -} > - > -void udscs_destroy_server(struct udscs_server *server) > -{ > - struct udscs_connection *conn, *next_conn; > - > - if (!server) > - return; > - > - conn = server->connections_head.next; > - while (conn) { > - next_conn = conn->next; > - udscs_destroy_connection(&conn); > - conn = next_conn; > - } > - close(server->fd); > - free(server); > -} > - > struct udscs_connection *udscs_connect(const char *socketname, > udscs_read_callback read_callback, > udscs_disconnect_callback disconnect_callback, > @@ -225,131 +145,17 @@ void udscs_destroy_connection(struct udscs_connection **connp) > *connp = NULL; > } > > -struct ucred udscs_get_peer_cred(struct udscs_connection *conn) > -{ > - return conn->peer_cred; > -} > - > -int udscs_server_fill_fds(struct udscs_server *server, fd_set *readfds, > - fd_set *writefds) > +void udscs_set_user_data(struct udscs_connection *conn, void *data) > { > - struct udscs_connection *conn; > - int nfds = server->fd + 1; > - > - if (!server) > - return -1; > - > - FD_SET(server->fd, readfds); > - > - conn = server->connections_head.next; > - while (conn) { > - int conn_nfds = udscs_client_fill_fds(conn, readfds, writefds); > - if (conn_nfds > nfds) > - nfds = conn_nfds; > - > - conn = conn->next; > - } > - > - return nfds; > + conn->user_data = data; > } > > -int udscs_client_fill_fds(struct udscs_connection *conn, fd_set *readfds, > - fd_set *writefds) > +void *udscs_get_user_data(struct udscs_connection *conn) > { > if (!conn) > - return -1; > - > - FD_SET(conn->fd, readfds); > - if (conn->write_buf) > - FD_SET(conn->fd, writefds); > - > - return conn->fd + 1; > -} > - > -static void udscs_server_accept(struct udscs_server *server) { > - struct udscs_connection *new_conn, *conn; > - struct sockaddr_un address; > - socklen_t length = sizeof(address); > - int r, fd; > - > - fd = accept(server->fd, (struct sockaddr *)&address, &length); > - if (fd == -1) { > - if (errno == EINTR) > - return; > - syslog(LOG_ERR, "accept: %m"); > - return; > - } > - > - new_conn = calloc(1, sizeof(*conn)); > - if (!new_conn) { > - syslog(LOG_ERR, "out of memory, disconnecting new client"); > - close(fd); > - return; > - } > - > - new_conn->fd = fd; > - new_conn->type_to_string = server->type_to_string; > - new_conn->no_types = server->no_types; > - new_conn->debug = server->debug; > - new_conn->read_callback = server->read_callback; > - new_conn->disconnect_callback = server->disconnect_callback; > - > - length = sizeof(new_conn->peer_cred); > - r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &new_conn->peer_cred, &length); > - if (r != 0) { > - syslog(LOG_ERR, "Could not get peercred, disconnecting new client"); > - close(fd); > - free(new_conn); > - return; > - } > - > - conn = &server->connections_head; > - while (conn->next) > - conn = conn->next; > - > - new_conn->prev = conn; > - conn->next = new_conn; > - > - if (server->debug) > - syslog(LOG_DEBUG, "new client accepted: %p, pid: %d", > - new_conn, (int)new_conn->peer_cred.pid); > - > - if (server->connect_callback) > - server->connect_callback(new_conn); > -} > - > -void udscs_server_handle_fds(struct udscs_server *server, fd_set *readfds, > - fd_set *writefds) > -{ > - struct udscs_connection *conn, *next_conn; > - > - if (!server) > - return; > - > - if (FD_ISSET(server->fd, readfds)) > - udscs_server_accept(server); > - > - conn = server->connections_head.next; > - while (conn) { > - /* conn maybe destroyed by udscs_client_handle_fds (when disconnected), > - so get the next connection first. */ > - next_conn = conn->next; > - udscs_client_handle_fds(&conn, readfds, writefds); > - conn = next_conn; > - } > -} > - > -void udscs_client_handle_fds(struct udscs_connection **connp, fd_set *readfds, > - fd_set *writefds) > -{ > - if (!*connp) > - return; > - > - if (FD_ISSET((*connp)->fd, readfds)) > - udscs_do_read(connp); > + return NULL; > > - if (*connp && FD_ISSET((*connp)->fd, writefds)) > - udscs_do_write(connp); > + return conn->user_data; > } > > int udscs_write(struct udscs_connection *conn, uint32_t type, uint32_t arg1, > @@ -404,41 +210,7 @@ int udscs_write(struct udscs_connection *conn, uint32_t type, uint32_t arg1, > return 0; > } > > -int udscs_server_write_all(struct udscs_server *server, > - uint32_t type, uint32_t arg1, uint32_t arg2, > - const uint8_t *data, uint32_t size) > -{ > - struct udscs_connection *conn; > - > - conn = server->connections_head.next; > - while (conn) { > - if (udscs_write(conn, type, arg1, arg2, data, size)) > - return -1; > - conn = conn->next; > - } > - > - return 0; > -} > - > -int udscs_server_for_all_clients(struct udscs_server *server, > - udscs_for_all_clients_callback func, void *priv) > -{ > - int r = 0; > - struct udscs_connection *conn, *next_conn; > - > - if (!server) > - return 0; > - > - conn = server->connections_head.next; > - while (conn) { > - /* Get next conn as func may destroy the current conn */ > - next_conn = conn->next; > - r += func(&conn, priv); > - conn = next_conn; > - } > - return r; > -} > - > +/* A helper for udscs_do_read() */ > static void udscs_read_complete(struct udscs_connection **connp) > { > struct udscs_connection *conn = *connp; > @@ -466,6 +238,7 @@ static void udscs_read_complete(struct udscs_connection **connp) > memset(&conn->data, 0, sizeof(conn->data)); > } > > +/* A helper for udscs_client_handle_fds() */ > static void udscs_do_read(struct udscs_connection **connp) > { > ssize_t n; > @@ -516,6 +289,7 @@ static void udscs_do_read(struct udscs_connection **connp) > } > } > > +/* A helper for udscs_client_handle_fds() */ > static void udscs_do_write(struct udscs_connection **connp) > { > ssize_t n; > @@ -549,15 +323,243 @@ static void udscs_do_write(struct udscs_connection **connp) > } > } > > -void udscs_set_user_data(struct udscs_connection *conn, void *data) > +void udscs_client_handle_fds(struct udscs_connection **connp, fd_set *readfds, > + fd_set *writefds) > { > - conn->user_data = data; > + if (!*connp) > + return; > + > + if (FD_ISSET((*connp)->fd, readfds)) > + udscs_do_read(connp); > + > + if (*connp && FD_ISSET((*connp)->fd, writefds)) > + udscs_do_write(connp); > } > > -void *udscs_get_user_data(struct udscs_connection *conn) > +int udscs_client_fill_fds(struct udscs_connection *conn, fd_set *readfds, > + fd_set *writefds) > { > if (!conn) > + return -1; > + > + FD_SET(conn->fd, readfds); > + if (conn->write_buf) > + FD_SET(conn->fd, writefds); > + > + return conn->fd + 1; > +} > + > + > +/* ---------- Server-side implementation ---------- */ > + > +struct udscs_server { > + int fd; > + const char * const *type_to_string; > + int no_types; > + int debug; > + struct udscs_connection connections_head; > + udscs_connect_callback connect_callback; > + udscs_read_callback read_callback; > + udscs_disconnect_callback disconnect_callback; > +}; > + > +struct udscs_server *udscs_create_server(const char *socketname, > + udscs_connect_callback connect_callback, > + udscs_read_callback read_callback, > + udscs_disconnect_callback disconnect_callback, > + const char * const type_to_string[], int no_types, int debug) > +{ > + int c; > + struct sockaddr_un address; > + struct udscs_server *server; > + > + server = calloc(1, sizeof(*server)); > + if (!server) > return NULL; > > - return conn->user_data; > + server->type_to_string = type_to_string; > + server->no_types = no_types; > + server->debug = debug; > + > + server->fd = socket(PF_UNIX, SOCK_STREAM, 0); > + if (server->fd == -1) { > + syslog(LOG_ERR, "creating unix domain socket: %m"); > + free(server); > + return NULL; > + } > + > + address.sun_family = AF_UNIX; > + snprintf(address.sun_path, sizeof(address.sun_path), "%s", socketname); > + c = bind(server->fd, (struct sockaddr *)&address, sizeof(address)); > + if (c != 0) { > + syslog(LOG_ERR, "bind %s: %m", socketname); > + free(server); > + return NULL; > + } > + > + c = listen(server->fd, 5); > + if (c != 0) { > + syslog(LOG_ERR, "listen: %m"); > + free(server); > + return NULL; > + } > + > + server->connect_callback = connect_callback; > + server->read_callback = read_callback; > + server->disconnect_callback = disconnect_callback; > + > + return server; > +} > + > +void udscs_destroy_server(struct udscs_server *server) > +{ > + struct udscs_connection *conn, *next_conn; > + > + if (!server) > + return; > + > + conn = server->connections_head.next; > + while (conn) { > + next_conn = conn->next; > + udscs_destroy_connection(&conn); > + conn = next_conn; > + } > + close(server->fd); > + free(server); > +} > + > +struct ucred udscs_get_peer_cred(struct udscs_connection *conn) > +{ > + return conn->peer_cred; > +} > + > +static void udscs_server_accept(struct udscs_server *server) { > + struct udscs_connection *new_conn, *conn; > + struct sockaddr_un address; > + socklen_t length = sizeof(address); > + int r, fd; > + > + fd = accept(server->fd, (struct sockaddr *)&address, &length); > + if (fd == -1) { > + if (errno == EINTR) > + return; > + syslog(LOG_ERR, "accept: %m"); > + return; > + } > + > + new_conn = calloc(1, sizeof(*conn)); > + if (!new_conn) { > + syslog(LOG_ERR, "out of memory, disconnecting new client"); > + close(fd); > + return; > + } > + > + new_conn->fd = fd; > + new_conn->type_to_string = server->type_to_string; > + new_conn->no_types = server->no_types; > + new_conn->debug = server->debug; > + new_conn->read_callback = server->read_callback; > + new_conn->disconnect_callback = server->disconnect_callback; > + > + length = sizeof(new_conn->peer_cred); > + r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &new_conn->peer_cred, &length); > + if (r != 0) { > + syslog(LOG_ERR, "Could not get peercred, disconnecting new client"); > + close(fd); > + free(new_conn); > + return; > + } > + > + conn = &server->connections_head; > + while (conn->next) > + conn = conn->next; > + > + new_conn->prev = conn; > + conn->next = new_conn; > + > + if (server->debug) > + syslog(LOG_DEBUG, "new client accepted: %p, pid: %d", > + new_conn, (int)new_conn->peer_cred.pid); > + > + if (server->connect_callback) > + server->connect_callback(new_conn); > +} > + > +int udscs_server_fill_fds(struct udscs_server *server, fd_set *readfds, > + fd_set *writefds) > +{ > + struct udscs_connection *conn; > + int nfds = server->fd + 1; > + > + if (!server) > + return -1; > + > + FD_SET(server->fd, readfds); > + > + conn = server->connections_head.next; > + while (conn) { > + int conn_nfds = udscs_client_fill_fds(conn, readfds, writefds); > + if (conn_nfds > nfds) > + nfds = conn_nfds; > + > + conn = conn->next; > + } > + > + return nfds; > +} > + > +void udscs_server_handle_fds(struct udscs_server *server, fd_set *readfds, > + fd_set *writefds) > +{ > + struct udscs_connection *conn, *next_conn; > + > + if (!server) > + return; > + > + if (FD_ISSET(server->fd, readfds)) > + udscs_server_accept(server); > + > + conn = server->connections_head.next; > + while (conn) { > + /* conn maybe destroyed by udscs_client_handle_fds (when disconnected), > + so get the next connection first. */ > + next_conn = conn->next; > + udscs_client_handle_fds(&conn, readfds, writefds); > + conn = next_conn; > + } > +} > + > +int udscs_server_write_all(struct udscs_server *server, > + uint32_t type, uint32_t arg1, uint32_t arg2, > + const uint8_t *data, uint32_t size) > +{ > + struct udscs_connection *conn; > + > + conn = server->connections_head.next; > + while (conn) { > + if (udscs_write(conn, type, arg1, arg2, data, size)) > + return -1; > + conn = conn->next; > + } > + > + return 0; > +} > + > +int udscs_server_for_all_clients(struct udscs_server *server, > + udscs_for_all_clients_callback func, void *priv) > +{ > + int r = 0; > + struct udscs_connection *conn, *next_conn; > + > + if (!server) > + return 0; > + > + conn = server->connections_head.next; > + while (conn) { > + /* Get next conn as func may destroy the current conn */ > + next_conn = conn->next; > + r += func(&conn, priv); > + conn = next_conn; > + } > + return r; > } > diff --git a/src/udscs.h b/src/udscs.h > index 89ab617..8b0b14e 100644 > --- a/src/udscs.h > +++ b/src/udscs.h > @@ -27,8 +27,10 @@ > #include <sys/select.h> > #include <sys/socket.h> > > + > +/* ---------- Generic bits and client-side API ---------- */ > + > struct udscs_connection; > -struct udscs_server; > struct udscs_message_header { > uint32_t type; > uint32_t arg1; > @@ -36,89 +38,107 @@ struct udscs_message_header { > uint32_t size; > }; > > -/* Callbacks with this type will be called when a new connection to a > - server is accepted. */ > -typedef void (*udscs_connect_callback)(struct udscs_connection *conn); > /* Callbacks with this type will be called when a complete message has been > - received. The callback may call udscs_destroy_connection, in which case > - *connp must be made NULL (which udscs_destroy_connection takes care of) */ > + * received. The callback may call udscs_destroy_connection, in which case > + * *connp must be made NULL (which udscs_destroy_connection takes care of). > + */ > typedef void (*udscs_read_callback)(struct udscs_connection **connp, > struct udscs_message_header *header, uint8_t *data); > -/* Callback type for udscs_server_for_all_clients. Clients can be disconnected > - from this callback just like with a read callback. */ > -typedef int (*udscs_for_all_clients_callback)(struct udscs_connection **connp, > - void *priv); > + > /* Callbacks with this type will be called when the connection is disconnected. > - Note: > - 1) udscs will destroy the connection in question itself after > - this callback has completed! > - 2) This callback is always called, even if the disconnect is initiated > - by the udscs user through returning -1 from a read callback, or > - by explictly calling udscs_destroy_connection */ > + * Note: > + * 1) udscs will destroy the connection in question itself after > + * this callback has completed! > + * 2) This callback is always called, even if the disconnect is initiated > + * by the udscs user through returning -1 from a read callback, or > + * by explictly calling udscs_destroy_connection. > + */ > typedef void (*udscs_disconnect_callback)(struct udscs_connection *conn); > > -/* Create a unix domain socket named name and start listening on it. */ > -struct udscs_server *udscs_create_server(const char *socketname, > - udscs_connect_callback connect_callback, > - udscs_read_callback read_callback, > - udscs_disconnect_callback disconnect_callback, > - const char * const type_to_string[], int no_types, int debug); > - > -void udscs_destroy_server(struct udscs_server *server); > - > /* Connect to a unix domain socket named name. */ > struct udscs_connection *udscs_connect(const char *socketname, > udscs_read_callback read_callback, > udscs_disconnect_callback disconnect_callback, > const char * const type_to_string[], int no_types, int debug); > > -/* The contents of connp will be made NULL */ > +/* The contents of connp will be made NULL. */ > void udscs_destroy_connection(struct udscs_connection **connp); > > - > -/* Given an udscs server or client fill the fd_sets pointed to by readfds and > - writefds for select() usage. > - > - Return value: value of the highest fd + 1 */ > -int udscs_server_fill_fds(struct udscs_server *server, fd_set *readfds, > - fd_set *writefds); > - > int udscs_client_fill_fds(struct udscs_connection *conn, fd_set *readfds, > - fd_set *writefds); > - > -/* Handle any events flagged by select for the given udscs server or client. */ > -void udscs_server_handle_fds(struct udscs_server *server, fd_set *readfds, > - fd_set *writefds); > + fd_set *writefds); > > /* Note the connection may be destroyed (when disconnected) by this call > - in this case the disconnect calllback will get called before the > - destruction and the contents of connp will be made NULL */ > + * in this case the disconnect calllback will get called before the > + * destruction and the contents of connp will be made NULL. > + */ > void udscs_client_handle_fds(struct udscs_connection **connp, fd_set *readfds, > - fd_set *writefds); > - > + fd_set *writefds); > > /* Queue a message for delivery to the client connected through conn. > - > - Returns 0 on success -1 on error (only happens when malloc fails) */ > + * Returns 0 on success -1 on error (only happens when malloc fails). > + */ > int udscs_write(struct udscs_connection *conn, uint32_t type, uint32_t arg1, > uint32_t arg2, const uint8_t *data, uint32_t size); > > +/* To associate per connection data with a connection. */ > +void udscs_set_user_data(struct udscs_connection *conn, void *data); > +void *udscs_get_user_data(struct udscs_connection *conn); > + > + > +#ifndef UDSCS_NO_SERVER > + > +/* ---------- Server-side API ---------- */ > + > +struct udscs_server; > + > +/* Callbacks with this type will be called when a new connection to a > + * server is accepted. > + */ > +typedef void (*udscs_connect_callback)(struct udscs_connection *conn); > + > +/* Create a unix domain socket named name and start listening on it. */ > +struct udscs_server *udscs_create_server(const char *socketname, > + udscs_connect_callback connect_callback, > + udscs_read_callback read_callback, > + udscs_disconnect_callback disconnect_callback, > + const char * const type_to_string[], int no_types, int debug); > + > +void udscs_destroy_server(struct udscs_server *server); > + > /* Like udscs_write, but then send the message to all clients connected to > - the server */ > + * the server. > + */ > int udscs_server_write_all(struct udscs_server *server, > - uint32_t type, uint32_t arg1, uint32_t arg2, > - const uint8_t *data, uint32_t size); > + uint32_t type, uint32_t arg1, uint32_t arg2, > + const uint8_t *data, uint32_t size); > + > +/* Callback type for udscs_server_for_all_clients. Clients can be disconnected > + * from this callback just like with a read callback. > + */ > +typedef int (*udscs_for_all_clients_callback)(struct udscs_connection **connp, > + void *priv); > + > /* Call func for all clients connected to the server, passing through > - priv to all func calls. Returns the total of the return values from all > - calls to func */ > + * priv to all func calls. Returns the total of the return values from all > + * calls to func. > + */ > int udscs_server_for_all_clients(struct udscs_server *server, > - udscs_for_all_clients_callback func, void *priv); > + udscs_for_all_clients_callback func, void *priv); > > +/* Given an udscs server or client fill the fd_sets pointed to by readfds and > + * writefds for select() usage. > + * Return value: value of the highest fd + 1 > + */ > +int udscs_server_fill_fds(struct udscs_server *server, fd_set *readfds, > + fd_set *writefds); > + > +/* Handle any events flagged by select for the given udscs server or client. */ > +void udscs_server_handle_fds(struct udscs_server *server, fd_set *readfds, > + fd_set *writefds); > > +/* Returns the peer's user credentials. */ > struct ucred udscs_get_peer_cred(struct udscs_connection *conn); > > -/* For server use, to associate per connection data with a connection */ > -void udscs_set_user_data(struct udscs_connection *conn, void *data); > -void *udscs_get_user_data(struct udscs_connection *conn); > +#endif > > #endif > -- > 2.6.2 > > _______________________________________________ > Spice-devel mailing list > Spice-devel@xxxxxxxxxxxxxxxxxxxxx > http://lists.freedesktop.org/mailman/listinfo/spice-devel _______________________________________________ Spice-devel mailing list Spice-devel@xxxxxxxxxxxxxxxxxxxxx http://lists.freedesktop.org/mailman/listinfo/spice-devel