summaryrefslogtreecommitdiffstats
path: root/qemu/io/channel-websock.c
diff options
context:
space:
mode:
authorRajithaY <rajithax.yerrumsetty@intel.com>2017-04-25 03:31:15 -0700
committerRajitha Yerrumchetty <rajithax.yerrumsetty@intel.com>2017-05-22 06:48:08 +0000
commitbb756eebdac6fd24e8919e2c43f7d2c8c4091f59 (patch)
treeca11e03542edf2d8f631efeca5e1626d211107e3 /qemu/io/channel-websock.c
parenta14b48d18a9ed03ec191cf16b162206998a895ce (diff)
Adding qemu as a submodule of KVMFORNFV
This Patch includes the changes to add qemu as a submodule to kvmfornfv repo and make use of the updated latest qemu for the execution of all testcase Change-Id: I1280af507a857675c7f81d30c95255635667bdd7 Signed-off-by:RajithaY<rajithax.yerrumsetty@intel.com>
Diffstat (limited to 'qemu/io/channel-websock.c')
-rw-r--r--qemu/io/channel-websock.c964
1 files changed, 0 insertions, 964 deletions
diff --git a/qemu/io/channel-websock.c b/qemu/io/channel-websock.c
deleted file mode 100644
index 708178779..000000000
--- a/qemu/io/channel-websock.c
+++ /dev/null
@@ -1,964 +0,0 @@
-/*
- * QEMU I/O channels driver websockets
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include "qemu/osdep.h"
-#include "qapi/error.h"
-#include "io/channel-websock.h"
-#include "crypto/hash.h"
-#include "trace.h"
-
-
-/* Max amount to allow in rawinput/rawoutput buffers */
-#define QIO_CHANNEL_WEBSOCK_MAX_BUFFER 8192
-
-#define QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN 24
-#define QIO_CHANNEL_WEBSOCK_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
-#define QIO_CHANNEL_WEBSOCK_GUID_LEN strlen(QIO_CHANNEL_WEBSOCK_GUID)
-
-#define QIO_CHANNEL_WEBSOCK_HEADER_PROTOCOL "Sec-WebSocket-Protocol"
-#define QIO_CHANNEL_WEBSOCK_HEADER_VERSION "Sec-WebSocket-Version"
-#define QIO_CHANNEL_WEBSOCK_HEADER_KEY "Sec-WebSocket-Key"
-
-#define QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY "binary"
-
-#define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RESPONSE \
- "HTTP/1.1 101 Switching Protocols\r\n" \
- "Upgrade: websocket\r\n" \
- "Connection: Upgrade\r\n" \
- "Sec-WebSocket-Accept: %s\r\n" \
- "Sec-WebSocket-Protocol: binary\r\n" \
- "\r\n"
-#define QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM "\r\n"
-#define QIO_CHANNEL_WEBSOCK_HANDSHAKE_END "\r\n\r\n"
-#define QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION "13"
-
-/* The websockets packet header is variable length
- * depending on the size of the payload... */
-
-/* ...length when using 7-bit payload length */
-#define QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT 6
-/* ...length when using 16-bit payload length */
-#define QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT 8
-/* ...length when using 64-bit payload length */
-#define QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT 14
-
-/* Length of the optional data mask field in header */
-#define QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK 4
-
-/* Maximum length that can fit in 7-bit payload size */
-#define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT 126
-/* Maximum length that can fit in 16-bit payload size */
-#define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT 65536
-
-/* Magic 7-bit length to indicate use of 16-bit payload length */
-#define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT 126
-/* Magic 7-bit length to indicate use of 64-bit payload length */
-#define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT 127
-
-/* Bitmasks & shifts for accessing header fields */
-#define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN 0x80
-#define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE 0x0f
-#define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_HAS_MASK 0x80
-#define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_PAYLOAD_LEN 0x7f
-#define QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_FIN 7
-#define QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_HAS_MASK 7
-
-typedef struct QIOChannelWebsockHeader QIOChannelWebsockHeader;
-
-struct QEMU_PACKED QIOChannelWebsockHeader {
- unsigned char b0;
- unsigned char b1;
- union {
- struct QEMU_PACKED {
- uint16_t l16;
- QIOChannelWebsockMask m16;
- } s16;
- struct QEMU_PACKED {
- uint64_t l64;
- QIOChannelWebsockMask m64;
- } s64;
- QIOChannelWebsockMask m;
- } u;
-};
-
-enum {
- QIO_CHANNEL_WEBSOCK_OPCODE_CONTINUATION = 0x0,
- QIO_CHANNEL_WEBSOCK_OPCODE_TEXT_FRAME = 0x1,
- QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME = 0x2,
- QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE = 0x8,
- QIO_CHANNEL_WEBSOCK_OPCODE_PING = 0x9,
- QIO_CHANNEL_WEBSOCK_OPCODE_PONG = 0xA
-};
-
-static char *qio_channel_websock_handshake_entry(const char *handshake,
- size_t handshake_len,
- const char *name)
-{
- char *begin, *end, *ret = NULL;
- char *line = g_strdup_printf("%s%s: ",
- QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM,
- name);
- begin = g_strstr_len(handshake, handshake_len, line);
- if (begin != NULL) {
- begin += strlen(line);
- end = g_strstr_len(begin, handshake_len - (begin - handshake),
- QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
- if (end != NULL) {
- ret = g_strndup(begin, end - begin);
- }
- }
- g_free(line);
- return ret;
-}
-
-
-static int qio_channel_websock_handshake_send_response(QIOChannelWebsock *ioc,
- const char *key,
- Error **errp)
-{
- char combined_key[QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
- QIO_CHANNEL_WEBSOCK_GUID_LEN + 1];
- char *accept = NULL, *response = NULL;
- size_t responselen;
-
- g_strlcpy(combined_key, key, QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN + 1);
- g_strlcat(combined_key, QIO_CHANNEL_WEBSOCK_GUID,
- QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
- QIO_CHANNEL_WEBSOCK_GUID_LEN + 1);
-
- /* hash and encode it */
- if (qcrypto_hash_base64(QCRYPTO_HASH_ALG_SHA1,
- combined_key,
- QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
- QIO_CHANNEL_WEBSOCK_GUID_LEN,
- &accept,
- errp) < 0) {
- return -1;
- }
-
- response = g_strdup_printf(QIO_CHANNEL_WEBSOCK_HANDSHAKE_RESPONSE, accept);
- responselen = strlen(response);
- buffer_reserve(&ioc->encoutput, responselen);
- buffer_append(&ioc->encoutput, response, responselen);
-
- g_free(accept);
- g_free(response);
-
- return 0;
-}
-
-static int qio_channel_websock_handshake_process(QIOChannelWebsock *ioc,
- const char *line,
- size_t size,
- Error **errp)
-{
- int ret = -1;
- char *protocols = qio_channel_websock_handshake_entry(
- line, size, QIO_CHANNEL_WEBSOCK_HEADER_PROTOCOL);
- char *version = qio_channel_websock_handshake_entry(
- line, size, QIO_CHANNEL_WEBSOCK_HEADER_VERSION);
- char *key = qio_channel_websock_handshake_entry(
- line, size, QIO_CHANNEL_WEBSOCK_HEADER_KEY);
-
- if (!protocols) {
- error_setg(errp, "Missing websocket protocol header data");
- goto cleanup;
- }
-
- if (!version) {
- error_setg(errp, "Missing websocket version header data");
- goto cleanup;
- }
-
- if (!key) {
- error_setg(errp, "Missing websocket key header data");
- goto cleanup;
- }
-
- if (!g_strrstr(protocols, QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY)) {
- error_setg(errp, "No '%s' protocol is supported by client '%s'",
- QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY, protocols);
- goto cleanup;
- }
-
- if (!g_str_equal(version, QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION)) {
- error_setg(errp, "Version '%s' is not supported by client '%s'",
- QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION, version);
- goto cleanup;
- }
-
- if (strlen(key) != QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN) {
- error_setg(errp, "Key length '%zu' was not as expected '%d'",
- strlen(key), QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN);
- goto cleanup;
- }
-
- ret = qio_channel_websock_handshake_send_response(ioc, key, errp);
-
- cleanup:
- g_free(protocols);
- g_free(version);
- g_free(key);
- return ret;
-}
-
-static int qio_channel_websock_handshake_read(QIOChannelWebsock *ioc,
- Error **errp)
-{
- char *handshake_end;
- ssize_t ret;
- /* Typical HTTP headers from novnc are 512 bytes, so limiting
- * total header size to 4096 is easily enough. */
- size_t want = 4096 - ioc->encinput.offset;
- buffer_reserve(&ioc->encinput, want);
- ret = qio_channel_read(ioc->master,
- (char *)buffer_end(&ioc->encinput), want, errp);
- if (ret < 0) {
- return -1;
- }
- ioc->encinput.offset += ret;
-
- handshake_end = g_strstr_len((char *)ioc->encinput.buffer,
- ioc->encinput.offset,
- QIO_CHANNEL_WEBSOCK_HANDSHAKE_END);
- if (!handshake_end) {
- if (ioc->encinput.offset >= 4096) {
- error_setg(errp,
- "End of headers not found in first 4096 bytes");
- return -1;
- } else {
- return 0;
- }
- }
-
- if (qio_channel_websock_handshake_process(ioc,
- (char *)ioc->encinput.buffer,
- ioc->encinput.offset,
- errp) < 0) {
- return -1;
- }
-
- buffer_advance(&ioc->encinput,
- handshake_end - (char *)ioc->encinput.buffer +
- strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_END));
- return 1;
-}
-
-static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,
- GIOCondition condition,
- gpointer user_data)
-{
- QIOTask *task = user_data;
- QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
- qio_task_get_source(task));
- Error *err = NULL;
- ssize_t ret;
-
- ret = qio_channel_write(wioc->master,
- (char *)wioc->encoutput.buffer,
- wioc->encoutput.offset,
- &err);
-
- if (ret < 0) {
- trace_qio_channel_websock_handshake_fail(ioc);
- qio_task_abort(task, err);
- error_free(err);
- return FALSE;
- }
-
- buffer_advance(&wioc->encoutput, ret);
- if (wioc->encoutput.offset == 0) {
- trace_qio_channel_websock_handshake_complete(ioc);
- qio_task_complete(task);
- return FALSE;
- }
- trace_qio_channel_websock_handshake_pending(ioc, G_IO_OUT);
- return TRUE;
-}
-
-static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc,
- GIOCondition condition,
- gpointer user_data)
-{
- QIOTask *task = user_data;
- QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
- qio_task_get_source(task));
- Error *err = NULL;
- int ret;
-
- ret = qio_channel_websock_handshake_read(wioc, &err);
- if (ret < 0) {
- trace_qio_channel_websock_handshake_fail(ioc);
- qio_task_abort(task, err);
- error_free(err);
- return FALSE;
- }
- if (ret == 0) {
- trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
- /* need more data still */
- return TRUE;
- }
-
- object_ref(OBJECT(task));
- trace_qio_channel_websock_handshake_reply(ioc);
- qio_channel_add_watch(
- wioc->master,
- G_IO_OUT,
- qio_channel_websock_handshake_send,
- task,
- (GDestroyNotify)object_unref);
- return FALSE;
-}
-
-
-static void qio_channel_websock_encode(QIOChannelWebsock *ioc)
-{
- size_t header_size;
- union {
- char buf[QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT];
- QIOChannelWebsockHeader ws;
- } header;
-
- if (!ioc->rawoutput.offset) {
- return;
- }
-
- header.ws.b0 = (1 << QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_FIN) |
- (QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME &
- QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE);
- if (ioc->rawoutput.offset <
- QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT) {
- header.ws.b1 = (uint8_t)ioc->rawoutput.offset;
- header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
- } else if (ioc->rawoutput.offset <
- QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT) {
- header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT;
- header.ws.u.s16.l16 = cpu_to_be16((uint16_t)ioc->rawoutput.offset);
- header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
- } else {
- header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT;
- header.ws.u.s64.l64 = cpu_to_be64(ioc->rawoutput.offset);
- header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
- }
- header_size -= QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK;
-
- buffer_reserve(&ioc->encoutput, header_size + ioc->rawoutput.offset);
- buffer_append(&ioc->encoutput, header.buf, header_size);
- buffer_append(&ioc->encoutput, ioc->rawoutput.buffer,
- ioc->rawoutput.offset);
- buffer_reset(&ioc->rawoutput);
-}
-
-
-static ssize_t qio_channel_websock_decode_header(QIOChannelWebsock *ioc,
- Error **errp)
-{
- unsigned char opcode, fin, has_mask;
- size_t header_size;
- size_t payload_len;
- QIOChannelWebsockHeader *header =
- (QIOChannelWebsockHeader *)ioc->encinput.buffer;
-
- if (ioc->payload_remain) {
- error_setg(errp,
- "Decoding header but %zu bytes of payload remain",
- ioc->payload_remain);
- return -1;
- }
- if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT) {
- /* header not complete */
- return QIO_CHANNEL_ERR_BLOCK;
- }
-
- fin = (header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN) >>
- QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_FIN;
- opcode = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE;
- has_mask = (header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_HAS_MASK) >>
- QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_HAS_MASK;
- payload_len = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_PAYLOAD_LEN;
-
- if (opcode == QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE) {
- /* disconnect */
- return 0;
- }
-
- /* Websocket frame sanity check:
- * * Websocket fragmentation is not supported.
- * * All websockets frames sent by a client have to be masked.
- * * Only binary encoding is supported.
- */
- if (!fin) {
- error_setg(errp, "websocket fragmentation is not supported");
- return -1;
- }
- if (!has_mask) {
- error_setg(errp, "websocket frames must be masked");
- return -1;
- }
- if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
- error_setg(errp, "only binary websocket frames are supported");
- return -1;
- }
-
- if (payload_len < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT) {
- ioc->payload_remain = payload_len;
- header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
- ioc->mask = header->u.m;
- } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT &&
- ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT) {
- ioc->payload_remain = be16_to_cpu(header->u.s16.l16);
- header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
- ioc->mask = header->u.s16.m16;
- } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT &&
- ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT) {
- ioc->payload_remain = be64_to_cpu(header->u.s64.l64);
- header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
- ioc->mask = header->u.s64.m64;
- } else {
- /* header not complete */
- return QIO_CHANNEL_ERR_BLOCK;
- }
-
- buffer_advance(&ioc->encinput, header_size);
- return 1;
-}
-
-
-static ssize_t qio_channel_websock_decode_payload(QIOChannelWebsock *ioc,
- Error **errp)
-{
- size_t i;
- size_t payload_len;
- uint32_t *payload32;
-
- if (!ioc->payload_remain) {
- error_setg(errp,
- "Decoding payload but no bytes of payload remain");
- return -1;
- }
-
- /* If we aren't at the end of the payload, then drop
- * off the last bytes, so we're always multiple of 4
- * for purpose of unmasking, except at end of payload
- */
- if (ioc->encinput.offset < ioc->payload_remain) {
- payload_len = ioc->encinput.offset - (ioc->encinput.offset % 4);
- } else {
- payload_len = ioc->payload_remain;
- }
- if (payload_len == 0) {
- return QIO_CHANNEL_ERR_BLOCK;
- }
-
- ioc->payload_remain -= payload_len;
-
- /* unmask frame */
- /* process 1 frame (32 bit op) */
- payload32 = (uint32_t *)ioc->encinput.buffer;
- for (i = 0; i < payload_len / 4; i++) {
- payload32[i] ^= ioc->mask.u;
- }
- /* process the remaining bytes (if any) */
- for (i *= 4; i < payload_len; i++) {
- ioc->encinput.buffer[i] ^= ioc->mask.c[i % 4];
- }
-
- buffer_reserve(&ioc->rawinput, payload_len);
- buffer_append(&ioc->rawinput, ioc->encinput.buffer, payload_len);
- buffer_advance(&ioc->encinput, payload_len);
- return payload_len;
-}
-
-
-QIOChannelWebsock *
-qio_channel_websock_new_server(QIOChannel *master)
-{
- QIOChannelWebsock *wioc;
- QIOChannel *ioc;
-
- wioc = QIO_CHANNEL_WEBSOCK(object_new(TYPE_QIO_CHANNEL_WEBSOCK));
- ioc = QIO_CHANNEL(wioc);
-
- wioc->master = master;
- if (master->features & (1 << QIO_CHANNEL_FEATURE_SHUTDOWN)) {
- ioc->features |= (1 << QIO_CHANNEL_FEATURE_SHUTDOWN);
- }
- object_ref(OBJECT(master));
-
- trace_qio_channel_websock_new_server(wioc, master);
- return wioc;
-}
-
-void qio_channel_websock_handshake(QIOChannelWebsock *ioc,
- QIOTaskFunc func,
- gpointer opaque,
- GDestroyNotify destroy)
-{
- QIOTask *task;
-
- task = qio_task_new(OBJECT(ioc),
- func,
- opaque,
- destroy);
-
- trace_qio_channel_websock_handshake_start(ioc);
- trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
- qio_channel_add_watch(ioc->master,
- G_IO_IN,
- qio_channel_websock_handshake_io,
- task,
- NULL);
-}
-
-
-static void qio_channel_websock_finalize(Object *obj)
-{
- QIOChannelWebsock *ioc = QIO_CHANNEL_WEBSOCK(obj);
-
- buffer_free(&ioc->encinput);
- buffer_free(&ioc->encoutput);
- buffer_free(&ioc->rawinput);
- buffer_free(&ioc->rawoutput);
- object_unref(OBJECT(ioc->master));
- if (ioc->io_tag) {
- g_source_remove(ioc->io_tag);
- }
- if (ioc->io_err) {
- error_free(ioc->io_err);
- }
-}
-
-
-static ssize_t qio_channel_websock_read_wire(QIOChannelWebsock *ioc,
- Error **errp)
-{
- ssize_t ret;
-
- if (ioc->encinput.offset < 4096) {
- size_t want = 4096 - ioc->encinput.offset;
-
- buffer_reserve(&ioc->encinput, want);
- ret = qio_channel_read(ioc->master,
- (char *)ioc->encinput.buffer +
- ioc->encinput.offset,
- want,
- errp);
- if (ret < 0) {
- return ret;
- }
- if (ret == 0 &&
- ioc->encinput.offset == 0) {
- return 0;
- }
- ioc->encinput.offset += ret;
- }
-
- if (ioc->payload_remain == 0) {
- ret = qio_channel_websock_decode_header(ioc, errp);
- if (ret < 0) {
- return ret;
- }
- if (ret == 0) {
- return 0;
- }
- }
-
- ret = qio_channel_websock_decode_payload(ioc, errp);
- if (ret < 0) {
- return ret;
- }
- return ret;
-}
-
-
-static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *ioc,
- Error **errp)
-{
- ssize_t ret;
- ssize_t done = 0;
- qio_channel_websock_encode(ioc);
-
- while (ioc->encoutput.offset > 0) {
- ret = qio_channel_write(ioc->master,
- (char *)ioc->encoutput.buffer,
- ioc->encoutput.offset,
- errp);
- if (ret < 0) {
- if (ret == QIO_CHANNEL_ERR_BLOCK &&
- done > 0) {
- return done;
- } else {
- return ret;
- }
- }
- buffer_advance(&ioc->encoutput, ret);
- done += ret;
- }
- return done;
-}
-
-
-static void qio_channel_websock_flush_free(gpointer user_data)
-{
- QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
- object_unref(OBJECT(wioc));
-}
-
-static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc);
-
-static gboolean qio_channel_websock_flush(QIOChannel *ioc,
- GIOCondition condition,
- gpointer user_data)
-{
- QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
- ssize_t ret;
-
- if (condition & G_IO_OUT) {
- ret = qio_channel_websock_write_wire(wioc, &wioc->io_err);
- if (ret < 0) {
- goto cleanup;
- }
- }
-
- if (condition & G_IO_IN) {
- ret = qio_channel_websock_read_wire(wioc, &wioc->io_err);
- if (ret < 0) {
- goto cleanup;
- }
- if (ret == 0) {
- wioc->io_eof = TRUE;
- }
- }
-
- cleanup:
- qio_channel_websock_set_watch(wioc);
- return FALSE;
-}
-
-
-static void qio_channel_websock_unset_watch(QIOChannelWebsock *ioc)
-{
- if (ioc->io_tag) {
- g_source_remove(ioc->io_tag);
- ioc->io_tag = 0;
- }
-}
-
-static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc)
-{
- GIOCondition cond = 0;
-
- qio_channel_websock_unset_watch(ioc);
-
- if (ioc->io_err) {
- return;
- }
-
- if (ioc->encoutput.offset) {
- cond |= G_IO_OUT;
- }
- if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER &&
- !ioc->io_eof) {
- cond |= G_IO_IN;
- }
-
- if (cond) {
- object_ref(OBJECT(ioc));
- ioc->io_tag =
- qio_channel_add_watch(ioc->master,
- cond,
- qio_channel_websock_flush,
- ioc,
- qio_channel_websock_flush_free);
- }
-}
-
-
-static ssize_t qio_channel_websock_readv(QIOChannel *ioc,
- const struct iovec *iov,
- size_t niov,
- int **fds,
- size_t *nfds,
- Error **errp)
-{
- QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
- size_t i;
- ssize_t got = 0;
- ssize_t ret;
-
- if (wioc->io_err) {
- *errp = error_copy(wioc->io_err);
- return -1;
- }
-
- if (!wioc->rawinput.offset) {
- ret = qio_channel_websock_read_wire(QIO_CHANNEL_WEBSOCK(ioc), errp);
- if (ret < 0) {
- return ret;
- }
- }
-
- for (i = 0 ; i < niov ; i++) {
- size_t want = iov[i].iov_len;
- if (want > (wioc->rawinput.offset - got)) {
- want = (wioc->rawinput.offset - got);
- }
-
- memcpy(iov[i].iov_base,
- wioc->rawinput.buffer + got,
- want);
- got += want;
-
- if (want < iov[i].iov_len) {
- break;
- }
- }
-
- buffer_advance(&wioc->rawinput, got);
- qio_channel_websock_set_watch(wioc);
- return got;
-}
-
-
-static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
- const struct iovec *iov,
- size_t niov,
- int *fds,
- size_t nfds,
- Error **errp)
-{
- QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
- size_t i;
- ssize_t done = 0;
- ssize_t ret;
-
- if (wioc->io_err) {
- *errp = error_copy(wioc->io_err);
- return -1;
- }
-
- if (wioc->io_eof) {
- error_setg(errp, "%s", "Broken pipe");
- return -1;
- }
-
- for (i = 0; i < niov; i++) {
- size_t want = iov[i].iov_len;
- if ((want + wioc->rawoutput.offset) > QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
- want = (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->rawoutput.offset);
- }
- if (want == 0) {
- goto done;
- }
-
- buffer_reserve(&wioc->rawoutput, want);
- buffer_append(&wioc->rawoutput, iov[i].iov_base, want);
- done += want;
- if (want < iov[i].iov_len) {
- break;
- }
- }
-
- done:
- ret = qio_channel_websock_write_wire(wioc, errp);
- if (ret < 0 &&
- ret != QIO_CHANNEL_ERR_BLOCK) {
- qio_channel_websock_unset_watch(wioc);
- return -1;
- }
-
- qio_channel_websock_set_watch(wioc);
-
- if (done == 0) {
- return QIO_CHANNEL_ERR_BLOCK;
- }
-
- return done;
-}
-
-static int qio_channel_websock_set_blocking(QIOChannel *ioc,
- bool enabled,
- Error **errp)
-{
- QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
-
- qio_channel_set_blocking(wioc->master, enabled, errp);
- return 0;
-}
-
-static void qio_channel_websock_set_delay(QIOChannel *ioc,
- bool enabled)
-{
- QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
-
- qio_channel_set_delay(tioc->master, enabled);
-}
-
-static void qio_channel_websock_set_cork(QIOChannel *ioc,
- bool enabled)
-{
- QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
-
- qio_channel_set_cork(tioc->master, enabled);
-}
-
-static int qio_channel_websock_shutdown(QIOChannel *ioc,
- QIOChannelShutdown how,
- Error **errp)
-{
- QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
-
- return qio_channel_shutdown(tioc->master, how, errp);
-}
-
-static int qio_channel_websock_close(QIOChannel *ioc,
- Error **errp)
-{
- QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
-
- return qio_channel_close(wioc->master, errp);
-}
-
-typedef struct QIOChannelWebsockSource QIOChannelWebsockSource;
-struct QIOChannelWebsockSource {
- GSource parent;
- QIOChannelWebsock *wioc;
- GIOCondition condition;
-};
-
-static gboolean
-qio_channel_websock_source_prepare(GSource *source,
- gint *timeout)
-{
- QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
- GIOCondition cond = 0;
- *timeout = -1;
-
- if (wsource->wioc->rawinput.offset) {
- cond |= G_IO_IN;
- }
- if (wsource->wioc->rawoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
- cond |= G_IO_OUT;
- }
-
- return cond & wsource->condition;
-}
-
-static gboolean
-qio_channel_websock_source_check(GSource *source)
-{
- QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
- GIOCondition cond = 0;
-
- if (wsource->wioc->rawinput.offset) {
- cond |= G_IO_IN;
- }
- if (wsource->wioc->rawoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
- cond |= G_IO_OUT;
- }
-
- return cond & wsource->condition;
-}
-
-static gboolean
-qio_channel_websock_source_dispatch(GSource *source,
- GSourceFunc callback,
- gpointer user_data)
-{
- QIOChannelFunc func = (QIOChannelFunc)callback;
- QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
- GIOCondition cond = 0;
-
- if (wsource->wioc->rawinput.offset) {
- cond |= G_IO_IN;
- }
- if (wsource->wioc->rawoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
- cond |= G_IO_OUT;
- }
-
- return (*func)(QIO_CHANNEL(wsource->wioc),
- (cond & wsource->condition),
- user_data);
-}
-
-static void
-qio_channel_websock_source_finalize(GSource *source)
-{
- QIOChannelWebsockSource *ssource = (QIOChannelWebsockSource *)source;
-
- object_unref(OBJECT(ssource->wioc));
-}
-
-GSourceFuncs qio_channel_websock_source_funcs = {
- qio_channel_websock_source_prepare,
- qio_channel_websock_source_check,
- qio_channel_websock_source_dispatch,
- qio_channel_websock_source_finalize
-};
-
-static GSource *qio_channel_websock_create_watch(QIOChannel *ioc,
- GIOCondition condition)
-{
- QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
- QIOChannelWebsockSource *ssource;
- GSource *source;
-
- source = g_source_new(&qio_channel_websock_source_funcs,
- sizeof(QIOChannelWebsockSource));
- ssource = (QIOChannelWebsockSource *)source;
-
- ssource->wioc = wioc;
- object_ref(OBJECT(wioc));
-
- ssource->condition = condition;
-
- qio_channel_websock_set_watch(wioc);
- return source;
-}
-
-static void qio_channel_websock_class_init(ObjectClass *klass,
- void *class_data G_GNUC_UNUSED)
-{
- QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
-
- ioc_klass->io_writev = qio_channel_websock_writev;
- ioc_klass->io_readv = qio_channel_websock_readv;
- ioc_klass->io_set_blocking = qio_channel_websock_set_blocking;
- ioc_klass->io_set_cork = qio_channel_websock_set_cork;
- ioc_klass->io_set_delay = qio_channel_websock_set_delay;
- ioc_klass->io_close = qio_channel_websock_close;
- ioc_klass->io_shutdown = qio_channel_websock_shutdown;
- ioc_klass->io_create_watch = qio_channel_websock_create_watch;
-}
-
-static const TypeInfo qio_channel_websock_info = {
- .parent = TYPE_QIO_CHANNEL,
- .name = TYPE_QIO_CHANNEL_WEBSOCK,
- .instance_size = sizeof(QIOChannelWebsock),
- .instance_finalize = qio_channel_websock_finalize,
- .class_init = qio_channel_websock_class_init,
-};
-
-static void qio_channel_websock_register_types(void)
-{
- type_register_static(&qio_channel_websock_info);
-}
-
-type_init(qio_channel_websock_register_types);