[Spice-devel] [PATCH 4/5] server: add websockets support via libwebsockets
Alon Levy
alevy at redhat.com
Fri Oct 19 05:04:33 PDT 2012
Some notes I forgot / updates.
> New API: spice_server_set_ws_ports
>
> This adds an optional dependency on libwebsockets. You need to get my
> patched 0.0.3 version here:
> git://people.freedesktop.org/~alon/libwebsockets
These patches are already upstream (git://git.warmcat.com/libwebsockets). The library is not new, the version number probably reflects expectations of unstable API, but since we don't build with it by default I don't think it's a problem.
>
> There is no qemu patches yet, to test change in reds.c the default
> value
> of spice_ws_port to 5959 (for the default of spice-html5).
qemu patch exists, like I wrote in the cover letter.
>
> For testing there is an online client at
> http://spice-space.org/spice-html5/spice.html
>
> Known issues:
> 1. The tester (server/tests/test_display_no_ssl) gets into dropping
> all
> data after a few seconds, I think it's an issue with the
> implemented
> watches, but haven't figured it out.
>
> 2. libwebsocket's read interface is inverted to what our code
> expects,
> i.e. there is no libwebsocket_read, so there is an additional copy
> involved (see RedsWebSocket). This can be fixed.
>
> 3. Listening on a separate port. Since the headers are different, we
> could listen on the same port (first three bytes RED/GET). I don't
> know
> if we want to?
>
> Todos:
> 1. SSL not implemented yet. Needs some thought as to how.
>
> 2. Serve spice-html5 when accessed as a http server. Nice to have.
> ---
> configure.ac | 15 ++
> server/Makefile.am | 4 +
> server/reds-private.h | 47 +++++-
> server/reds.c | 79 ++++++----
> server/reds.h | 17 +++
> server/reds_websockets.c | 311
> +++++++++++++++++++++++++++++++++++++++
> server/reds_websockets.h | 9 ++
> server/spice-server.syms | 5 +
> server/spice.h | 7 +
> server/tests/test_display_base.c | 4 +-
> 10 files changed, 466 insertions(+), 32 deletions(-)
> create mode 100644 server/reds_websockets.c
> create mode 100644 server/reds_websockets.h
>
> diff --git a/configure.ac b/configure.ac
> index dff930d..5561d2c 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -160,6 +160,13 @@ AC_ARG_ENABLE(automated_tests,
> AS_IF([test x"$enable_automated_tests" != "xno"],
> [enable_automated_tests="yes"])
> AM_CONDITIONAL(SUPPORT_AUTOMATED_TESTS, test
> "x$enable_automated_tests" != "xno")
>
> +AC_ARG_ENABLE(libwebsockets,
> +[ --enable-libwebsockets Enable websockets server support (no
> need for proxy)],,
> +[enable_libwebsockets="yes"])
> +AS_IF([test x"enable_libwebsockets" != "xyes"],
> [enable_websockets="no"])
> +if test "x$enable_libwebsockets" = "xyes"; then
> + AC_DEFINE([USE_LIBWEBSOCKETS], [1], [Define if supporting
> websocket connections])
> +fi
>
> dnl
> =========================================================================
> dnl Check deps
> @@ -237,6 +244,12 @@ if test "x$enable_smartcard" = "xyes"; then
> SPICE_REQUIRES+=" libcacard >= 0.1.2"
> fi
>
> +if test "x$enable_libwebsockets" = "xyes"; then
> + PKG_CHECK_MODULES(LIBWEBSOCKETS, libwebsockets >= 0.0.3)
> + AC_SUBST(LIBWEBSOCKETS_LIBS)
> + AC_SUBST(LIBWEBSOCKETS_CFLAGS)
> + SPICE_REQUIRES+=" libwebsockets >= 0.0.3"
> +fi
>
> PKG_CHECK_MODULES(PIXMAN, pixman-1 >= 0.17.7)
> AC_SUBST(PIXMAN_CFLAGS)
> @@ -536,6 +549,8 @@ echo "
> SASL support: ${enable_sasl}
>
> Automated tests: ${enable_automated_tests}
> +
> + libwebsockets: ${enable_libwebsockets}
> "
>
> if test $os_win32 == "yes" ; then
> diff --git a/server/Makefile.am b/server/Makefile.am
> index b62d98c..a7d56d4 100644
> --- a/server/Makefile.am
> +++ b/server/Makefile.am
> @@ -10,6 +10,7 @@ AM_CPPFLAGS = \
> $(SLIRP_CFLAGS) \
> $(SMARTCARD_CFLAGS) \
> $(SSL_CFLAGS) \
> + $(LIBWEBSOCKETS_CFLAGS) \
> $(VISIBILITY_HIDDEN_CFLAGS) \
> $(WARN_CFLAGS) \
> $(NULL)
> @@ -38,6 +39,7 @@ libspice_server_la_LIBADD = \
> $(SLIRP_LIBS) \
> $(SSL_LIBS) \
> $(Z_LIBS) \
> + $(LIBWEBSOCKETS_LIBS) \
> $(NULL)
>
> libspice_server_la_SOURCES = \
> @@ -91,6 +93,8 @@ libspice_server_la_SOURCES = \
> spicevmc.c \
> zlib_encoder.c \
> zlib_encoder.h \
> + reds_websockets.c \
> + reds_websockets.h \
> $(NULL)
>
> if SUPPORT_TUNNEL
> diff --git a/server/reds-private.h b/server/reds-private.h
> index 3db6565..a5903b3 100644
> --- a/server/reds-private.h
> +++ b/server/reds-private.h
> @@ -4,6 +4,16 @@
> #include <time.h>
>
> #include <spice/protocol.h>
> +#include <spice/stats.h>
> +
> +#if USE_LIBWEBSOCKETS
> +#include <libwebsockets.h>
> +#endif
> +
> +#include "reds.h"
> +#include "char_device.h"
> +#include "agent-msg-filter.h"
> +#include "main_channel.h"
>
> #define MIGRATE_TIMEOUT (1000 * 10) /* 10sec */
> #define MM_TIMER_GRANULARITY_MS (1000 / 30)
> @@ -34,10 +44,6 @@ typedef struct VDIReadBuf {
> uint8_t data[SPICE_AGENT_MAX_DATA_SIZE];
> } VDIReadBuf;
>
> -static VDIReadBuf *vdi_port_read_buf_get(void);
> -static VDIReadBuf *vdi_port_read_buf_ref(VDIReadBuf *buf);
> -static void vdi_port_read_buf_unref(VDIReadBuf *buf);
> -
> enum {
> VDI_PORT_READ_STATE_READ_HEADER,
> VDI_PORT_READ_STATE_GET_BUFF,
> @@ -125,9 +131,19 @@ typedef struct RedsClientMonitorsConfig {
> int buffer_pos;
> } RedsClientMonitorsConfig;
>
> +#ifdef USE_LIBWEBSOCKETS
> +#define REDS_MAX_WEBSOCKETS 32
> +#endif
> +
> typedef struct RedsState {
> int listen_socket;
> int secure_listen_socket;
> +#ifdef USE_LIBWEBSOCKETS
> + struct libwebsocket_context *ws_context;
> + RedsWebSocket ws[REDS_MAX_WEBSOCKETS];
> + int ws_in_service_fd;
> + int ws_count;
> +#endif
> SpiceWatch *listen_watch;
> SpiceWatch *secure_listen_watch;
> VDIPortState agent_state;
> @@ -179,4 +195,27 @@ typedef struct RedsState {
> RedsClientMonitorsConfig client_monitors_config;
> } RedsState;
>
> +typedef struct AsyncRead {
> + RedsStream *stream;
> + void *opaque;
> + uint8_t *now;
> + uint8_t *end;
> + void (*done)(void *opaque);
> + void (*error)(void *opaque, int err);
> +} AsyncRead;
> +
> +typedef struct RedLinkInfo {
> + RedsStream *stream;
> + AsyncRead asyc_read;
> + SpiceLinkHeader link_header;
> + SpiceLinkMess *link_mess;
> + int mess_pos;
> + TicketInfo tiTicketing;
> + SpiceLinkAuthMechanism auth_mechanism;
> + int skip_auth;
> +} RedLinkInfo;
> +
> +RedLinkInfo *spice_server_add_client_create_link(SpiceServer *s, int
> socket, int skip_auth);
> +void reds_handle_new_link(RedLinkInfo *link);
> +
> #endif
> diff --git a/server/reds.c b/server/reds.c
> index 98c8706..bd16764 100644
> --- a/server/reds.c
> +++ b/server/reds.c
> @@ -74,9 +74,16 @@
> #ifdef USE_SMARTCARD
> #include "smartcard.h"
> #endif
> +#if USE_LIBWEBSOCKETS
> +#include "reds_websockets.h"
> +#endif
>
> #include "reds-private.h"
>
> +static VDIReadBuf *vdi_port_read_buf_get(void);
> +static VDIReadBuf *vdi_port_read_buf_ref(VDIReadBuf *buf);
> +static void vdi_port_read_buf_unref(VDIReadBuf *buf);
> +
> SpiceCoreInterface *core = NULL;
> static SpiceCharDeviceInstance *vdagent = NULL;
> static SpiceMigrateInstance *migration_interface = NULL;
> @@ -99,6 +106,10 @@ static TicketAuthentication taTicket;
>
> static int spice_port = -1;
> static int spice_secure_port = -1;
> +#if USE_LIBWEBSOCKETS
> +static int spice_ws_port = -1;
> +static int spice_wss_port = -1;
> +#endif
> static int spice_listen_socket_fd = -1;
> static char spice_addr[256];
> static int spice_family = PF_UNSPEC;
> @@ -127,26 +138,6 @@ static bool exit_on_disconnect = FALSE;
>
> static RedsState *reds = NULL;
>
> -typedef struct AsyncRead {
> - RedsStream *stream;
> - void *opaque;
> - uint8_t *now;
> - uint8_t *end;
> - void (*done)(void *opaque);
> - void (*error)(void *opaque, int err);
> -} AsyncRead;
> -
> -typedef struct RedLinkInfo {
> - RedsStream *stream;
> - AsyncRead asyc_read;
> - SpiceLinkHeader link_header;
> - SpiceLinkMess *link_mess;
> - int mess_pos;
> - TicketInfo tiTicketing;
> - SpiceLinkAuthMechanism auth_mechanism;
> - int skip_auth;
> -} RedLinkInfo;
> -
> typedef struct RedSSLParameters {
> char keyfile_password[256];
> char certs_file[256];
> @@ -2718,7 +2709,7 @@ static void reds_handle_read_header_done(void
> *opaque)
> async_read_handler(0, 0, &link->asyc_read);
> }
>
> -static void reds_handle_new_link(RedLinkInfo *link)
> +void reds_handle_new_link(RedLinkInfo *link)
> {
> AsyncRead *obj = &link->asyc_read;
> obj->opaque = link;
> @@ -2882,7 +2873,6 @@ static void reds_accept_ssl_connection(int fd,
> int event, void *data)
> }
> }
>
> -
> static void reds_accept(int fd, int event, void *data)
> {
> int socket;
> @@ -2896,25 +2886,33 @@ static void reds_accept(int fd, int event,
> void *data)
> close(socket);
> }
>
> -
> -SPICE_GNUC_VISIBLE int spice_server_add_client(SpiceServer *s, int
> socket, int skip_auth)
> +RedLinkInfo *spice_server_add_client_create_link(SpiceServer *s, int
> socket, int skip_auth)
> {
> RedLinkInfo *link;
> - RedsStream *stream;
>
> spice_assert(reds == s);
> if (!(link = reds_init_client_connection(socket))) {
> spice_warning("accept failed");
> - return -1;
> + return NULL;
> }
>
> link->skip_auth = skip_auth;
> + return link;
> +}
> +
> +SPICE_GNUC_VISIBLE int spice_server_add_client(SpiceServer *s, int
> socket, int skip_auth)
> +{
> + RedLinkInfo *link;
> + RedsStream *stream;
>
> + link = spice_server_add_client_create_link(s, socket,
> skip_auth);
> + if (!link) {
> + return -1;
> + }
> stream = link->stream;
> stream->read = stream_read_cb;
> stream->write = stream_write_cb;
> stream->writev = stream_writev_cb;
> -
> reds_handle_new_link(link);
> return 0;
> }
> @@ -3033,6 +3031,12 @@ static int reds_init_net(void)
> return -1;
> }
> }
> +
> +#if USE_LIBWEBSOCKETS
> + if (spice_ws_port != -1 || spice_wss_port != -1) {
> + reds_init_websocket(reds, spice_addr, spice_ws_port,
> spice_wss_port);
> + }
> +#endif
> return 0;
> }
>
> @@ -3949,6 +3953,27 @@ SPICE_GNUC_VISIBLE int
> spice_server_set_port(SpiceServer *s, int port)
> return 0;
> }
>
> +
> +SPICE_GNUC_VISIBLE int spice_server_set_ws_ports(SpiceServer *s, int
> ws_port, int wss_port)
> +{
> +#if USE_LIBWEBSOCKETS
> + spice_assert(reds == s);
> + if ((ws_port < 1 || ws_port > 0xffff) && (wss_port < 1 ||
> wss_port > 0xffff)) {
> + return -1;
> + }
> + if (ws_port > 0 && ws_port < 0xffff) {
> + spice_ws_port = ws_port;
> + }
> + if (wss_port > 0 && wss_port < 0xffff) {
> + spice_wss_port = wss_port;
> + }
> + return 0;
> +#else
> + fprintf(stderr, "libwebsockets is unsupported in this spice
> build\n");
> + return -1;
> +#endif
> +}
> +
> SPICE_GNUC_VISIBLE void spice_server_set_addr(SpiceServer *s, const
> char *addr, int flags)
> {
> spice_assert(reds == s);
> diff --git a/server/reds.h b/server/reds.h
> index f8e8d56..0d4f933 100644
> --- a/server/reds.h
> +++ b/server/reds.h
> @@ -65,6 +65,20 @@ typedef struct RedsSASL {
> } RedsSASL;
> #endif
>
> +#ifdef USE_LIBWEBSOCKETS
> +typedef struct RedsWebSocket {
> + struct libwebsocket_context *context;
> + struct libwebsocket *wsi;
> + SpiceWatch *watch;
> + int fd;
> + unsigned events;
> + /* buffer of available data to read, always starts at offset 0
> to data_avail - 1. */
> + unsigned char *data;
> + unsigned data_len;
> + unsigned data_avail;
> +} RedsWebSocket;
> +#endif
> +
> struct RedsStream {
> int socket;
> SpiceWatch *watch;
> @@ -73,6 +87,9 @@ struct RedsStream {
> receive may return data afterward. check the flag before
> calling receive*/
> int shutdown;
> SSL *ssl;
> +#ifdef USE_LIBWEBSOCKETS
> + RedsWebSocket *ws;
> +#endif
>
> #if HAVE_SASL
> RedsSASL sasl;
> diff --git a/server/reds_websockets.c b/server/reds_websockets.c
> new file mode 100644
> index 0000000..24df2e5
> --- /dev/null
> +++ b/server/reds_websockets.c
> @@ -0,0 +1,311 @@
> +#include "config.h"
> +
> +#ifdef USE_LIBWEBSOCKETS
> +#include <unistd.h>
> +#include <errno.h>
> +#include <libwebsockets.h>
> +
> +#include "spice.h"
> +#include "reds.h"
> +#include "reds-private.h"
> +#include "reds_websockets.h"
> +
> +static ssize_t stream_write_ws_cb(RedsStream *s, const void *buf,
> size_t size)
> +{
> + /* TODO: better way to handle the requirement of libwebsocket,
> perhaps
> + * we should make a writev version for libwebsocket. Assuming
> writev doesn't
> + * cause a linearlizing copy itself. */
> + ssize_t ret;
> + unsigned char *padded_buf = spice_malloc(size +
> LWS_SEND_BUFFER_PRE_PADDING +
> +
> LWS_SEND_BUFFER_POST_PADDING);
> + spice_assert(s && s->ws);
> + memcpy(padded_buf + LWS_SEND_BUFFER_PRE_PADDING, buf, size);
> + ret = libwebsocket_write(s->ws->wsi,
> &padded_buf[LWS_SEND_BUFFER_PRE_PADDING], size,
> + LWS_WRITE_BINARY);
> + free(padded_buf);
> + return ret == 0 ? size : -1; /* XXX exact bytes required? if not
> this is
> + good enough, else need to change
> + libwebsocket */
> +}
> +
> +static void reds_websocket_append_data(RedsWebSocket *ws, unsigned
> char *buf,
> + size_t size)
> +{
> + if (!ws->data) {
> + ws->data = spice_malloc(size);
> + ws->data_len = size;
> + ws->data_avail = 0;
> + }
> + if (ws->data_len < size + ws->data_avail) {
> + ws->data_len = size + ws->data_avail;
> + ws->data = realloc(ws->data, ws->data_len);
> + }
> + memcpy(ws->data + ws->data_avail, buf, size);
> + ws->data_avail += size;
> +}
> +
> +static ssize_t reds_websocket_read_data(RedsWebSocket *ws, unsigned
> char *buf,
> + size_t size)
> +{
> + ssize_t ret;
> +
> + ret = ws->data_avail > size ? size : ws->data_avail;
> + if (ret > 0) {
> + memcpy(buf, ws->data, ret);
> + }
> + if (ret > 0 && ret < ws->data_avail) {
> + memmove(ws->data, ws->data + ret, ws->data_avail - ret);
> + }
> + ws->data_avail -= ret;
> + if (ws->data_avail == 0 && ret == size) {
> + ws->data = NULL;
> + ws->data_len = ws->data_avail = 0;
> + }
> + return ret;
> +}
> +
> +static int reds_libwebsocket_service_fd(RedsState *s, struct pollfd
> *pfd)
> +{
> + int ret;
> + if (s->ws_in_service_fd) {
> + return 0;
> + }
> + s->ws_in_service_fd = 1;
> + ret = libwebsocket_service_fd(s->ws_context, pfd);
> + s->ws_in_service_fd = 0;
> + if (ret != 0) {
> + if (errno == EAGAIN) {
> + spice_debug("libwebsocket_servide_fd EAGAIN,
> pfd->revents = %d",
> + pfd->revents);
> + return 0;
> + }
> + /* since read is the last systemcall, errno should be set
> correctly */
> + spice_debug("libwebsocket_service_fd errored; (%d) %s",
> + errno, sys_errlist[errno]);
> + return -1;
> + }
> + return 0;
> +}
> +
> +static ssize_t stream_read_ws_cb(RedsStream *s, void *buf, size_t
> size)
> +{
> + RedsWebSocket *ws;
> + struct pollfd pfd;
> + RedsState *reds_state;
> +
> + /* TODO: perhaps change libwebsocket to allow a socket like
> read. Then
> + * we can avoid the whole RedsWebSocket->data{,_len,_avail}. */
> + spice_assert(s && s->ws);
> + ws = s->ws;
> + reds_state = libwebsocket_context_user(ws->context);
> + if (size == 0) {
> + return 0;
> + }
> + spice_debug("%p %d / %d", ws->data, ws->data_avail,
> ws->data_len);
> + if (ws->data_avail < size && !reds_state->ws_in_service_fd) {
> + pfd.fd = ws->fd;
> + pfd.events = ws->events;
> + pfd.revents = POLLIN;
> + if (reds_libwebsocket_service_fd(reds_state, &pfd)) {
> + return -1;
> + }
> + }
> + if (ws->data_avail == 0) {
> + errno = EAGAIN; /* force a reset of the watch on the fd, so
> that
> + libwebsocket_service_fd has a chance to
> run */
> + return -1;
> + }
> + return reds_websocket_read_data(ws, buf, size);
> +}
> +
> +static RedsWebSocket *reds_ws_from_fd(RedsState *s, int fd)
> +{
> + int i;
> +
> + for (i = 0 ; i < s->ws_count ; ++i) {
> + if (s->ws[i].fd == fd) {
> + return &s->ws[i];
> + }
> + }
> + spice_error("%s: no match for %d (%d ws sockets)\n", __func__,
> + fd, s->ws_count);
> + return NULL;
> +}
> +
> +static int callback_http(struct libwebsocket_context *context,
> + struct libwebsocket *wsi,
> + void *user, void *in, size_t len)
> +{
> + const char *message = "TODO: serve spice-html5";
> + char buf[512];
> + int n;
> +
> + n = snprintf(buf, sizeof(buf),
> + "HTTP/1.0 200 OK\x0d\x0a"
> + "Server: spice\x0d\x0a"
> + "Content-Type: text/html\x0d\x0a"
> + "Content-Length: %zu\x0d\x0a"
> + "\x0d\x0a"
> + "%s", strlen(message), message);
> + libwebsocket_write(wsi, (unsigned char *)buf, n,
> LWS_WRITE_HTTP);
> + return 0;
> +}
> +
> +static int spice_server_add_ws_client(SpiceServer *s, int socket,
> int skip_auth,
> + RedsWebSocket *ws)
> +{
> + RedLinkInfo *link;
> + RedsStream *stream;
> +
> + link = spice_server_add_client_create_link(s, socket,
> skip_auth);
> + if (!link) {
> + return -1;
> + }
> + stream = link->stream;
> + stream->read = stream_read_ws_cb;
> + stream->write = stream_write_ws_cb;
> + stream->writev = NULL; /* falls back to write iteration */
> + stream->ws = ws;
> + reds_handle_new_link(link);
> + return 0;
> +}
> +
> +static void watch_ws(int fd, int event, void *data)
> +{
> + struct libwebsocket_context *context = data;
> + RedsState *s = libwebsocket_context_user(context);
> + struct pollfd pfd = {
> + .fd = fd,
> + .events = reds_ws_from_fd(s, fd)->events,
> + .revents = (event & SPICE_WATCH_EVENT_READ ? POLLIN : 0) |
> + (event & SPICE_WATCH_EVENT_WRITE ? POLLOUT : 0)
> + };
> +
> + reds_libwebsocket_service_fd(s, &pfd);
> +}
> +
> +static int callback_ws(struct libwebsocket_context *context,
> + struct libwebsocket *wsi,
> + enum libwebsocket_callback_reasons reason,
> void *user,
> + void *in, size_t len)
> +{
> + int fd;
> + RedsState *s = libwebsocket_context_user(context);
> + int n;
> + RedsWebSocket *ws;
> + int events;
> +
> + spice_debug("%s: reason %d user %lu len %zd \n", __func__,
> reason,
> + (unsigned long)user, len);
> + switch (reason) {
> + case LWS_CALLBACK_HTTP:
> + return callback_http(context, wsi, user, in, len);
> +
> + case LWS_CALLBACK_ADD_POLL_FD:
> + if (s->ws_count >= REDS_MAX_WEBSOCKETS) {
> + spice_warning("exceeded websockets maximum watches");
> + return 1; /* close connection */
> + }
> + spice_debug("adding ws for fd %d", (int)(long)user);
> + events = (int)(long)len;
> + ws = &s->ws[s->ws_count];
> + ws->watch = core->watch_add((int)(long)user,
> + (events & POLLIN ?
> SPICE_WATCH_EVENT_READ: 0) |
> + (events & POLLOUT ?
> SPICE_WATCH_EVENT_WRITE : 0),
> + watch_ws, (void *)context);
> + ws->fd = (int)(long)user;
> + ws->events = events;
> + s->ws_count++;
> + break;
> +
> + case LWS_CALLBACK_DEL_POLL_FD:
> + spice_debug("removing ws for fd %d", (int)(long)user);
> + for (n = 0; n < s->ws_count; n++) {
> + if (s->ws[n].fd == (int)(long)user) {
> + s->ws[n] = s->ws[s->ws_count - 1];
> + }
> + s->ws_count--;
> + }
> + break;
> +
> + case LWS_CALLBACK_SET_MODE_POLL_FD:
> + reds_ws_from_fd(s, (int)(long)user)->events |=
> (int)(long)len;
> + break;
> +
> + case LWS_CALLBACK_CLEAR_MODE_POLL_FD:
> + reds_ws_from_fd(s, (int)(long)user)->events &=
> (int)(long)len;
> + break;
> +
> + case LWS_CALLBACK_ESTABLISHED:
> + fd = libwebsocket_get_socket_fd(wsi);
> + ws = reds_ws_from_fd(s, fd);
> + *(RedsWebSocket **)user = ws;
> + ws->wsi = wsi;
> + ws->context = context;
> + ws->data_avail = 0;
> + spice_debug("LWS_CALLBACK_ESTABLISHED\n");
> + spice_server_add_ws_client(s, fd, 0, ws);
> + break;
> +
> + case LWS_CALLBACK_RECEIVE:
> + spice_debug("LWS_CALLBACK_CLIENT_RECEIVE\n");
> + spice_assert(user != NULL);
> + ws = *(RedsWebSocket **)user;
> + spice_assert(ws != NULL);
> + reds_websocket_append_data(ws, in, len);
> + break;
> +
> + case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
> + case LWS_CALLBACK_CLIENT_ESTABLISHED:
> + case LWS_CALLBACK_CLOSED:
> + case LWS_CALLBACK_CLIENT_RECEIVE:
> + case LWS_CALLBACK_CLIENT_RECEIVE_PONG:
> + case LWS_CALLBACK_CLIENT_WRITEABLE:
> + case LWS_CALLBACK_SERVER_WRITEABLE:
> + case LWS_CALLBACK_BROADCAST:
> + case LWS_CALLBACK_FILTER_NETWORK_CONNECTION:
> + case LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION:
> + case LWS_CALLBACK_OPENSSL_LOAD_EXTRA_CLIENT_VERIFY_CERTS:
> + case LWS_CALLBACK_OPENSSL_LOAD_EXTRA_SERVER_VERIFY_CERTS:
> + case LWS_CALLBACK_OPENSSL_PERFORM_CLIENT_CERT_VERIFICATION:
> + case LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER:
> + case LWS_CALLBACK_CONFIRM_EXTENSION_OKAY:
> + case LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED:
> + break;
> + }
> + return 0;
> +}
> +
> +static struct libwebsocket_protocols ws_protocols[] = {
> + /* first protocol must always be HTTP handler */
> +
> + {
> + "binary", /* name - based on spice-html5 :) */
> + callback_ws, /* callback */
> + sizeof(void*), /* per_session_data_size */
> + /* below initializing library used values to avoid warning
> */
> + NULL,
> + 0,
> + 0,
> + 0
> + },
> + {
> + NULL, NULL, 0, NULL, 0, 0, 0 /* End of list */
> + }
> +};
> +
> +void reds_init_websocket(RedsState *s, const char *addr,
> + int ws_port, int wss_port)
> +{
> + if (ws_port != -1) {
> + s->ws_context = libwebsocket_create_context(ws_port,
> + strlen(addr) ? addr : NULL,
> + ws_protocols, libwebsocket_internal_extensions,
> + NULL /*cert_path*/, NULL /*key_path*/, -1, -1, 0
> /*opts*/,
> + s);
> + }
> + if (wss_port != -1) {
> + spice_error("TODO: secure websocket not supported");
> + }
> +}
> +#endif
> diff --git a/server/reds_websockets.h b/server/reds_websockets.h
> new file mode 100644
> index 0000000..ce0a975
> --- /dev/null
> +++ b/server/reds_websockets.h
> @@ -0,0 +1,9 @@
> +#ifndef REDS_WEBSOCKETS_H
> +#define REDS_WEBSOCKETS_H
> +
> +#include "reds-private.h"
> +
> +void reds_init_websocket(RedsState *s, const char *addr,
> + int ws_port, int wss_port);
> +
> +#endif
> diff --git a/server/spice-server.syms b/server/spice-server.syms
> index eadfed8..aef8f5a 100644
> --- a/server/spice-server.syms
> +++ b/server/spice-server.syms
> @@ -130,3 +130,8 @@ SPICE_SERVER_0.11.4 {
> global:
> spice_server_set_exit_on_disconnect;
> } SPICE_SERVER_0.11.2;
> +
> +SPICE_SERVER_0.12.1 {
> +global:
> + spice_server_set_ws_ports;
> +} SPICE_SERVER_0.11.4;
> diff --git a/server/spice.h b/server/spice.h
> index c1478e0..7ca5033 100644
> --- a/server/spice.h
> +++ b/server/spice.h
> @@ -434,6 +434,13 @@ void spice_server_destroy(SpiceServer *s);
> int spice_server_set_compat_version(SpiceServer *s,
> spice_compat_version_t version);
> int spice_server_set_port(SpiceServer *s, int port);
> +
> +/* @ws_port: -1 for don't set, otherwise in [1,65535] port to listen
> + * for unencrypted websocket connections.
> + * @wss_port: -1 for don't set, otherwise in [1,65535] port to
> listen
> + * for encrypted websocket connections.
> + */
> +int spice_server_set_ws_ports(SpiceServer *s, int ws_port, int
> wss_port);
> void spice_server_set_addr(SpiceServer *s, const char *addr, int
> flags);
> int spice_server_set_listen_socket_fd(SpiceServer *s, int
> listen_fd);
> int spice_server_set_exit_on_disconnect(SpiceServer *s, int flag);
> diff --git a/server/tests/test_display_base.c
> b/server/tests/test_display_base.c
> index 588e960..9eaa584 100644
> --- a/server/tests/test_display_base.c
> +++ b/server/tests/test_display_base.c
> @@ -701,13 +701,14 @@ static int flush_resources(QXLInstance *qin)
> return TRUE;
> }
>
> -static void client_monitors_config(QXLInstance *qin,
> VDAgentMonitorsConfig *monitors_config)
> +static int client_monitors_config(QXLInstance *qin,
> VDAgentMonitorsConfig *monitors_config)
> {
> if (!monitors_config) {
> printf("%s: NULL monitors_config\n", __func__);
> } else {
> printf("%s: %d\n", __func__,
> monitors_config->num_of_monitors);
> }
> + return 0;
> }
>
> QXLInterface display_sif = {
> @@ -815,6 +816,7 @@ Test *test_new(SpiceCoreInterface *core)
> printf("TESTER: listening on port %d (unsecure)\n", port);
> spice_server_set_port(server, port);
> spice_server_set_noauth(server);
> + spice_server_set_ws_ports(test->server, 5959, -1);
> spice_server_init(server, core);
>
> cursor_init();
> --
> 1.7.12.1
>
> _______________________________________________
> Spice-devel mailing list
> Spice-devel at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/spice-devel
>
More information about the Spice-devel
mailing list