Re: [PATCH v2 1/3] vdagent: Group the client and server functions together

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



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




[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux]     [Linux OMAP]     [Linux MIPS]     [ECOS]     [Asterisk Internet PBX]     [Linux API]     [Monitors]