io/channel-websock.c

   1 /*
   2  * QEMU I/O channels driver websockets
   3  *
   4  * Copyright (c) 2015 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "qapi/error.h"
  23 #include "qemu/bswap.h"
  24 #include "io/channel-websock.h"
  25 #include "crypto/hash.h"
  26 #include "trace.h"
  27
  28 #include <time.h>
  29
  30
  31 /* Max amount to allow in rawinput/encoutput buffers */
  32 #define QIO_CHANNEL_WEBSOCK_MAX_BUFFER 8192
  33
  34 #define QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN 24
  35 #define QIO_CHANNEL_WEBSOCK_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
  36 #define QIO_CHANNEL_WEBSOCK_GUID_LEN strlen(QIO_CHANNEL_WEBSOCK_GUID)
  37
  38 #define QIO_CHANNEL_WEBSOCK_HEADER_PROTOCOL "sec-websocket-protocol"
  39 #define QIO_CHANNEL_WEBSOCK_HEADER_VERSION "sec-websocket-version"
  40 #define QIO_CHANNEL_WEBSOCK_HEADER_KEY "sec-websocket-key"
  41 #define QIO_CHANNEL_WEBSOCK_HEADER_UPGRADE "upgrade"
  42 #define QIO_CHANNEL_WEBSOCK_HEADER_HOST "host"
  43 #define QIO_CHANNEL_WEBSOCK_HEADER_CONNECTION "connection"
  44
  45 #define QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY "binary"
  46 #define QIO_CHANNEL_WEBSOCK_CONNECTION_UPGRADE "Upgrade"
  47 #define QIO_CHANNEL_WEBSOCK_UPGRADE_WEBSOCKET "websocket"
  48
  49 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_COMMON \
  50     "Server: QEMU VNC\r\n"                       \
  51     "Date: %s\r\n"
  52
  53 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_OK    \
  54     "HTTP/1.1 101 Switching Protocols\r\n"      \
  55     QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_COMMON    \
  56     "Upgrade: websocket\r\n"                    \
  57     "Connection: Upgrade\r\n"                   \
  58     "Sec-WebSocket-Accept: %s\r\n"              \
  59     "Sec-WebSocket-Protocol: binary\r\n"        \
  60     "\r\n"
  61 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_NOT_FOUND \
  62     "HTTP/1.1 404 Not Found\r\n"                    \
  63     QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_COMMON        \
  64     "Connection: close\r\n"                         \
  65     "\r\n"
  66 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_BAD_REQUEST \
  67     "HTTP/1.1 400 Bad Request\r\n"                    \
  68     QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_COMMON          \
  69     "Connection: close\r\n"                           \
  70     "Sec-WebSocket-Version: "                         \
  71     QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION             \
  72     "\r\n"
  73 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_SERVER_ERR \
  74     "HTTP/1.1 500 Internal Server Error\r\n"         \
  75     QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_COMMON         \
  76     "Connection: close\r\n"                          \
  77     "\r\n"
  78 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_TOO_LARGE  \
  79     "HTTP/1.1 403 Request Entity Too Large\r\n"      \
  80     QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_COMMON         \
  81     "Connection: close\r\n"                          \
  82     "\r\n"
  83 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM "\r\n"
  84 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_END "\r\n\r\n"
  85 #define QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION "13"
  86 #define QIO_CHANNEL_WEBSOCK_HTTP_METHOD "GET"
  87 #define QIO_CHANNEL_WEBSOCK_HTTP_PATH "/"
  88 #define QIO_CHANNEL_WEBSOCK_HTTP_VERSION "HTTP/1.1"
  89
  90 /* The websockets packet header is variable length
  91  * depending on the size of the payload... */
  92
  93 /* ...length when using 7-bit payload length */
  94 #define QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT 6
  95 /* ...length when using 16-bit payload length */
  96 #define QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT 8
  97 /* ...length when using 64-bit payload length */
  98 #define QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT 14
  99
 100 /* Length of the optional data mask field in header */
 101 #define QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK 4
 102
 103 /* Maximum length that can fit in 7-bit payload size */
 104 #define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT 126
 105 /* Maximum length that can fit in 16-bit payload size */
 106 #define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT 65536
 107
 108 /* Magic 7-bit length to indicate use of 16-bit payload length */
 109 #define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT 126
 110 /* Magic 7-bit length to indicate use of 64-bit payload length */
 111 #define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT 127
 112
 113 /* Bitmasks for accessing header fields */
 114 #define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN 0x80
 115 #define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE 0x0f
 116 #define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_HAS_MASK 0x80
 117 #define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_PAYLOAD_LEN 0x7f
 118 #define QIO_CHANNEL_WEBSOCK_CONTROL_OPCODE_MASK 0x8
 119
 120 typedef struct QIOChannelWebsockHeader QIOChannelWebsockHeader;
 121
 122 struct QEMU_PACKED QIOChannelWebsockHeader {
 123     unsigned char b0;
 124     unsigned char b1;
 125     union {
 126         struct QEMU_PACKED {
 127             uint16_t l16;
 128             QIOChannelWebsockMask m16;
 129         } s16;
 130         struct QEMU_PACKED {
 131             uint64_t l64;
 132             QIOChannelWebsockMask m64;
 133         } s64;
 134         QIOChannelWebsockMask m;
 135     } u;
 136 };
 137
 138 typedef struct QIOChannelWebsockHTTPHeader QIOChannelWebsockHTTPHeader;
 139
 140 struct QIOChannelWebsockHTTPHeader {
 141     char *name;
 142     char *value;
 143 };
 144
 145 enum {
 146     QIO_CHANNEL_WEBSOCK_OPCODE_CONTINUATION = 0x0,
 147     QIO_CHANNEL_WEBSOCK_OPCODE_TEXT_FRAME = 0x1,
 148     QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME = 0x2,
 149     QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE = 0x8,
 150     QIO_CHANNEL_WEBSOCK_OPCODE_PING = 0x9,
 151     QIO_CHANNEL_WEBSOCK_OPCODE_PONG = 0xA
 152 };
 153
 154 static void qio_channel_websock_handshake_send_res(QIOChannelWebsock *ioc,
 155                                                    const char *resmsg,
 156                                                    ...)
 157 {
 158     va_list vargs;
 159     char *response;
 160     size_t responselen;
 161
 162     va_start(vargs, resmsg);
 163     response = g_strdup_vprintf(resmsg, vargs);
 164     responselen = strlen(response);
 165     buffer_reserve(&ioc->encoutput, responselen);
 166     buffer_append(&ioc->encoutput, response, responselen);
 167     va_end(vargs);
 168 }
 169
 170 static gchar *qio_channel_websock_date_str(void)
 171 {
 172     struct tm tm;
 173     time_t now = time(NULL);
 174     char datebuf[128];
 175
 176     gmtime_r(&now, &tm);
 177
 178     strftime(datebuf, sizeof(datebuf), "%a, %d %b %Y %H:%M:%S GMT", &tm);
 179
 180     return g_strdup(datebuf);
 181 }
 182
 183 static void qio_channel_websock_handshake_send_res_err(QIOChannelWebsock *ioc,
 184                                                        const char *resdata)
 185 {
 186     char *date = qio_channel_websock_date_str();
 187     qio_channel_websock_handshake_send_res(ioc, resdata, date);
 188     g_free(date);
 189 }
 190
 191 enum {
 192     QIO_CHANNEL_WEBSOCK_STATUS_NORMAL = 1000,
 193     QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR = 1002,
 194     QIO_CHANNEL_WEBSOCK_STATUS_INVALID_DATA = 1003,
 195     QIO_CHANNEL_WEBSOCK_STATUS_POLICY = 1008,
 196     QIO_CHANNEL_WEBSOCK_STATUS_TOO_LARGE = 1009,
 197     QIO_CHANNEL_WEBSOCK_STATUS_SERVER_ERR = 1011,
 198 };
 199
 200 static size_t
 201 qio_channel_websock_extract_headers(QIOChannelWebsock *ioc,
 202                                     char *buffer,
 203                                     QIOChannelWebsockHTTPHeader *hdrs,
 204                                     size_t nhdrsalloc,
 205                                     Error **errp)
 206 {
 207     char *nl, *sep, *tmp;
 208     size_t nhdrs = 0;
 209
 210     /*
 211      * First parse the HTTP protocol greeting of format:
 212      *
 213      *   $METHOD $PATH $VERSION
 214      *
 215      * e.g.
 216      *
 217      *   GET / HTTP/1.1
 218      */
 219
 220     nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
 221     if (!nl) {
 222         error_setg(errp, "Missing HTTP header delimiter");
 223         goto bad_request;
 224     }
 225     *nl = '\0';
 226
 227     tmp = strchr(buffer, ' ');
 228     if (!tmp) {
 229         error_setg(errp, "Missing HTTP path delimiter");
 230         return 0;
 231     }
 232     *tmp = '\0';
 233
 234     if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_METHOD)) {
 235         error_setg(errp, "Unsupported HTTP method %s", buffer);
 236         goto bad_request;
 237     }
 238
 239     buffer = tmp + 1;
 240     tmp = strchr(buffer, ' ');
 241     if (!tmp) {
 242         error_setg(errp, "Missing HTTP version delimiter");
 243         goto bad_request;
 244     }
 245     *tmp = '\0';
 246
 247     if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_PATH)) {
 248         qio_channel_websock_handshake_send_res_err(
 249             ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_NOT_FOUND);
 250         error_setg(errp, "Unexpected HTTP path %s", buffer);
 251         return 0;
 252     }
 253
 254     buffer = tmp + 1;
 255
 256     if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_VERSION)) {
 257         error_setg(errp, "Unsupported HTTP version %s", buffer);
 258         goto bad_request;
 259     }
 260
 261     buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
 262
 263     /*
 264      * Now parse all the header fields of format
 265      *
 266      *   $NAME: $VALUE
 267      *
 268      * e.g.
 269      *
 270      *   Cache-control: no-cache
 271      */
 272     do {
 273         QIOChannelWebsockHTTPHeader *hdr;
 274
 275         nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
 276         if (nl) {
 277             *nl = '\0';
 278         }
 279
 280         sep = strchr(buffer, ':');
 281         if (!sep) {
 282             error_setg(errp, "Malformed HTTP header");
 283             goto bad_request;
 284         }
 285         *sep = '\0';
 286         sep++;
 287         while (*sep == ' ') {
 288             sep++;
 289         }
 290
 291         if (nhdrs >= nhdrsalloc) {
 292             error_setg(errp, "Too many HTTP headers");
 293             goto bad_request;
 294         }
 295
 296         hdr = &hdrs[nhdrs++];
 297         hdr->name = buffer;
 298         hdr->value = sep;
 299
 300         /* Canonicalize header name for easier identification later */
 301         for (tmp = hdr->name; *tmp; tmp++) {
 302             *tmp = g_ascii_tolower(*tmp);
 303         }
 304
 305         if (nl) {
 306             buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
 307         }
 308     } while (nl != NULL);
 309
 310     return nhdrs;
 311
 312  bad_request:
 313     qio_channel_websock_handshake_send_res_err(
 314         ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_BAD_REQUEST);
 315     return 0;
 316 }
 317
 318 static const char *
 319 qio_channel_websock_find_header(QIOChannelWebsockHTTPHeader *hdrs,
 320                                 size_t nhdrs,
 321                                 const char *name)
 322 {
 323     size_t i;
 324
 325     for (i = 0; i < nhdrs; i++) {
 326         if (g_str_equal(hdrs[i].name, name)) {
 327             return hdrs[i].value;
 328         }
 329     }
 330
 331     return NULL;
 332 }
 333
 334
 335 static void qio_channel_websock_handshake_send_res_ok(QIOChannelWebsock *ioc,
 336                                                       const char *key,
 337                                                       Error **errp)
 338 {
 339     char combined_key[QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
 340                       QIO_CHANNEL_WEBSOCK_GUID_LEN + 1];
 341     char *accept = NULL;
 342     char *date = qio_channel_websock_date_str();
 343
 344     g_strlcpy(combined_key, key, QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN + 1);
 345     g_strlcat(combined_key, QIO_CHANNEL_WEBSOCK_GUID,
 346               QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
 347               QIO_CHANNEL_WEBSOCK_GUID_LEN + 1);
 348
 349     /* hash and encode it */
 350     if (qcrypto_hash_base64(QCRYPTO_HASH_ALG_SHA1,
 351                             combined_key,
 352                             QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
 353                             QIO_CHANNEL_WEBSOCK_GUID_LEN,
 354                             &accept,
 355                             errp) < 0) {
 356         qio_channel_websock_handshake_send_res_err(
 357             ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_SERVER_ERR);
 358         return;
 359     }
 360
 361     qio_channel_websock_handshake_send_res(
 362         ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_OK, date, accept);
 363
 364     g_free(date);
 365     g_free(accept);
 366 }
 367
 368 static void qio_channel_websock_handshake_process(QIOChannelWebsock *ioc,
 369                                                   char *buffer,
 370                                                   Error **errp)
 371 {
 372     QIOChannelWebsockHTTPHeader hdrs[32];
 373     size_t nhdrs = G_N_ELEMENTS(hdrs);
 374     const char *protocols = NULL, *version = NULL, *key = NULL,
 375         *host = NULL, *connection = NULL, *upgrade = NULL;
 376
 377     nhdrs = qio_channel_websock_extract_headers(ioc, buffer, hdrs, nhdrs, errp);
 378     if (!nhdrs) {
 379         return;
 380     }
 381
 382     protocols = qio_channel_websock_find_header(
 383         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_PROTOCOL);
 384     if (!protocols) {
 385         error_setg(errp, "Missing websocket protocol header data");
 386         goto bad_request;
 387     }
 388
 389     version = qio_channel_websock_find_header(
 390         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_VERSION);
 391     if (!version) {
 392         error_setg(errp, "Missing websocket version header data");
 393         goto bad_request;
 394     }
 395
 396     key = qio_channel_websock_find_header(
 397         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_KEY);
 398     if (!key) {
 399         error_setg(errp, "Missing websocket key header data");
 400         goto bad_request;
 401     }
 402
 403     host = qio_channel_websock_find_header(
 404         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_HOST);
 405     if (!host) {
 406         error_setg(errp, "Missing websocket host header data");
 407         goto bad_request;
 408     }
 409
 410     connection = qio_channel_websock_find_header(
 411         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_CONNECTION);
 412     if (!connection) {
 413         error_setg(errp, "Missing websocket connection header data");
 414         goto bad_request;
 415     }
 416
 417     upgrade = qio_channel_websock_find_header(
 418         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_UPGRADE);
 419     if (!upgrade) {
 420         error_setg(errp, "Missing websocket upgrade header data");
 421         goto bad_request;
 422     }
 423
 424     if (!g_strrstr(protocols, QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY)) {
 425         error_setg(errp, "No '%s' protocol is supported by client '%s'",
 426                    QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY, protocols);
 427         goto bad_request;
 428     }
 429
 430     if (!g_str_equal(version, QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION)) {
 431         error_setg(errp, "Version '%s' is not supported by client '%s'",
 432                    QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION, version);
 433         goto bad_request;
 434     }
 435
 436     if (strlen(key) != QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN) {
 437         error_setg(errp, "Key length '%zu' was not as expected '%d'",
 438                    strlen(key), QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN);
 439         goto bad_request;
 440     }
 441
 442     if (strcasecmp(connection, QIO_CHANNEL_WEBSOCK_CONNECTION_UPGRADE) != 0) {
 443         error_setg(errp, "No connection upgrade requested '%s'", connection);
 444         goto bad_request;
 445     }
 446
 447     if (strcasecmp(upgrade, QIO_CHANNEL_WEBSOCK_UPGRADE_WEBSOCKET) != 0) {
 448         error_setg(errp, "Incorrect upgrade method '%s'", upgrade);
 449         goto bad_request;
 450     }
 451
 452     qio_channel_websock_handshake_send_res_ok(ioc, key, errp);
 453     return;
 454
 455  bad_request:
 456     qio_channel_websock_handshake_send_res_err(
 457         ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_BAD_REQUEST);
 458 }
 459
 460 static int qio_channel_websock_handshake_read(QIOChannelWebsock *ioc,
 461                                               Error **errp)
 462 {
 463     char *handshake_end;
 464     ssize_t ret;
 465     /* Typical HTTP headers from novnc are 512 bytes, so limiting
 466      * total header size to 4096 is easily enough. */
 467     size_t want = 4096 - ioc->encinput.offset;
 468     buffer_reserve(&ioc->encinput, want);
 469     ret = qio_channel_read(ioc->master,
 470                            (char *)buffer_end(&ioc->encinput), want, errp);
 471     if (ret < 0) {
 472         return -1;
 473     }
 474     ioc->encinput.offset += ret;
 475
 476     handshake_end = g_strstr_len((char *)ioc->encinput.buffer,
 477                                  ioc->encinput.offset,
 478                                  QIO_CHANNEL_WEBSOCK_HANDSHAKE_END);
 479     if (!handshake_end) {
 480         if (ioc->encinput.offset >= 4096) {
 481             qio_channel_websock_handshake_send_res_err(
 482                 ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_TOO_LARGE);
 483             error_setg(errp,
 484                        "End of headers not found in first 4096 bytes");
 485             return 1;
 486         } else {
 487             return 0;
 488         }
 489     }
 490     *handshake_end = '\0';
 491
 492     qio_channel_websock_handshake_process(ioc,
 493                                           (char *)ioc->encinput.buffer,
 494                                           errp);
 495
 496     buffer_advance(&ioc->encinput,
 497                    handshake_end - (char *)ioc->encinput.buffer +
 498                    strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_END));
 499     return 1;
 500 }
 501
 502 static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,
 503                                                    GIOCondition condition,
 504                                                    gpointer user_data)
 505 {
 506     QIOTask *task = user_data;
 507     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
 508         qio_task_get_source(task));
 509     Error *err = NULL;
 510     ssize_t ret;
 511
 512     ret = qio_channel_write(wioc->master,
 513                             (char *)wioc->encoutput.buffer,
 514                             wioc->encoutput.offset,
 515                             &err);
 516
 517     if (ret < 0) {
 518         trace_qio_channel_websock_handshake_fail(ioc, error_get_pretty(err));
 519         qio_task_set_error(task, err);
 520         qio_task_complete(task);
 521         return FALSE;
 522     }
 523
 524     buffer_advance(&wioc->encoutput, ret);
 525     if (wioc->encoutput.offset == 0) {
 526         if (wioc->io_err) {
 527             trace_qio_channel_websock_handshake_fail(
 528                 ioc, error_get_pretty(wioc->io_err));
 529             qio_task_set_error(task, wioc->io_err);
 530             wioc->io_err = NULL;
 531             qio_task_complete(task);
 532         } else {
 533             trace_qio_channel_websock_handshake_complete(ioc);
 534             qio_task_complete(task);
 535         }
 536         return FALSE;
 537     }
 538     trace_qio_channel_websock_handshake_pending(ioc, G_IO_OUT);
 539     return TRUE;
 540 }
 541
 542 static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc,
 543                                                  GIOCondition condition,
 544                                                  gpointer user_data)
 545 {
 546     QIOTask *task = user_data;
 547     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
 548         qio_task_get_source(task));
 549     Error *err = NULL;
 550     int ret;
 551
 552     ret = qio_channel_websock_handshake_read(wioc, &err);
 553     if (ret < 0) {
 554         /*
 555          * We only take this path on a fatal I/O error reading from
 556          * client connection, as most of the time we have an
 557          * HTTP 4xx err response to send instead
 558          */
 559         trace_qio_channel_websock_handshake_fail(ioc, error_get_pretty(err));
 560         qio_task_set_error(task, err);
 561         qio_task_complete(task);
 562         return FALSE;
 563     }
 564     if (ret == 0) {
 565         trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
 566         /* need more data still */
 567         return TRUE;
 568     }
 569
 570     if (err) {
 571         error_propagate(&wioc->io_err, err);
 572     }
 573
 574     trace_qio_channel_websock_handshake_reply(ioc);
 575     qio_channel_add_watch(
 576         wioc->master,
 577         G_IO_OUT,
 578         qio_channel_websock_handshake_send,
 579         task,
 580         NULL);
 581     return FALSE;
 582 }
 583
 584
 585 static void qio_channel_websock_encode(QIOChannelWebsock *ioc,
 586                                        uint8_t opcode,
 587                                        const struct iovec *iov,
 588                                        size_t niov,
 589                                        size_t size)
 590 {
 591     size_t header_size;
 592     size_t i;
 593     union {
 594         char buf[QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT];
 595         QIOChannelWebsockHeader ws;
 596     } header;
 597
 598     assert(size <= iov_size(iov, niov));
 599
 600     header.ws.b0 = QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN |
 601         (opcode & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE);
 602     if (size < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT) {
 603         header.ws.b1 = (uint8_t)size;
 604         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
 605     } else if (size < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT) {
 606         header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT;
 607         header.ws.u.s16.l16 = cpu_to_be16((uint16_t)size);
 608         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
 609     } else {
 610         header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT;
 611         header.ws.u.s64.l64 = cpu_to_be64(size);
 612         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
 613     }
 614     header_size -= QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK;
 615
 616     trace_qio_channel_websock_encode(ioc, opcode, header_size, size);
 617     buffer_reserve(&ioc->encoutput, header_size + size);
 618     buffer_append(&ioc->encoutput, header.buf, header_size);
 619     for (i = 0; i < niov && size != 0; i++) {
 620         size_t want = iov[i].iov_len;
 621         if (want > size) {
 622             want = size;
 623         }
 624         buffer_append(&ioc->encoutput, iov[i].iov_base, want);
 625         size -= want;
 626     }
 627 }
 628
 629
 630 static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *, Error **);
 631
 632
 633 static void qio_channel_websock_write_close(QIOChannelWebsock *ioc,
 634                                             uint16_t code, const char *reason)
 635 {
 636     struct iovec iov;
 637     buffer_reserve(&ioc->rawoutput, 2 + (reason ? strlen(reason) : 0));
 638     *(uint16_t *)(ioc->rawoutput.buffer + ioc->rawoutput.offset) =
 639         cpu_to_be16(code);
 640     ioc->rawoutput.offset += 2;
 641     if (reason) {
 642         buffer_append(&ioc->rawoutput, reason, strlen(reason));
 643     }
 644     iov.iov_base = ioc->rawoutput.buffer;
 645     iov.iov_len = ioc->rawoutput.offset;
 646     qio_channel_websock_encode(ioc, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
 647                                &iov, 1, iov.iov_len);
 648     buffer_reset(&ioc->rawoutput);
 649     qio_channel_websock_write_wire(ioc, NULL);
 650     qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
 651 }
 652
 653
 654 static int qio_channel_websock_decode_header(QIOChannelWebsock *ioc,
 655                                              Error **errp)
 656 {
 657     unsigned char opcode, fin, has_mask;
 658     size_t header_size;
 659     size_t payload_len;
 660     QIOChannelWebsockHeader *header =
 661         (QIOChannelWebsockHeader *)ioc->encinput.buffer;
 662
 663     if (ioc->payload_remain) {
 664         error_setg(errp,
 665                    "Decoding header but %zu bytes of payload remain",
 666                    ioc->payload_remain);
 667         qio_channel_websock_write_close(
 668             ioc, QIO_CHANNEL_WEBSOCK_STATUS_SERVER_ERR,
 669             "internal server error");
 670         return -1;
 671     }
 672     if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT) {
 673         /* header not complete */
 674         return QIO_CHANNEL_ERR_BLOCK;
 675     }
 676
 677     fin = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN;
 678     opcode = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE;
 679     has_mask = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_HAS_MASK;
 680     payload_len = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_PAYLOAD_LEN;
 681
 682     /* Save or restore opcode. */
 683     if (opcode) {
 684         ioc->opcode = opcode;
 685     } else {
 686         opcode = ioc->opcode;
 687     }
 688
 689     trace_qio_channel_websock_header_partial_decode(ioc, payload_len,
 690                                                     fin, opcode, (int)has_mask);
 691
 692     if (opcode == QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE) {
 693         /* disconnect */
 694         return 0;
 695     }
 696
 697     /* Websocket frame sanity check:
 698      * * Fragmentation is only supported for binary frames.
 699      * * All frames sent by a client MUST be masked.
 700      * * Only binary and ping/pong encoding is supported.
 701      */
 702     if (!fin) {
 703         if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
 704             error_setg(errp, "only binary websocket frames may be fragmented");
 705             qio_channel_websock_write_close(
 706                 ioc, QIO_CHANNEL_WEBSOCK_STATUS_POLICY ,
 707                 "only binary frames may be fragmented");
 708             return -1;
 709         }
 710     } else {
 711         if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME &&
 712             opcode != QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE &&
 713             opcode != QIO_CHANNEL_WEBSOCK_OPCODE_PING &&
 714             opcode != QIO_CHANNEL_WEBSOCK_OPCODE_PONG) {
 715             error_setg(errp, "unsupported opcode: %#04x; only binary, close, "
 716                        "ping, and pong websocket frames are supported", opcode);
 717             qio_channel_websock_write_close(
 718                 ioc, QIO_CHANNEL_WEBSOCK_STATUS_INVALID_DATA ,
 719                 "only binary, close, ping, and pong frames are supported");
 720             return -1;
 721         }
 722     }
 723     if (!has_mask) {
 724         error_setg(errp, "client websocket frames must be masked");
 725         qio_channel_websock_write_close(
 726             ioc, QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR,
 727             "client frames must be masked");
 728         return -1;
 729     }
 730
 731     if (payload_len < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT) {
 732         ioc->payload_remain = payload_len;
 733         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
 734         ioc->mask = header->u.m;
 735     } else if (opcode & QIO_CHANNEL_WEBSOCK_CONTROL_OPCODE_MASK) {
 736         error_setg(errp, "websocket control frame is too large");
 737         qio_channel_websock_write_close(
 738             ioc, QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR,
 739             "control frame is too large");
 740         return -1;
 741     } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT &&
 742                ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT) {
 743         ioc->payload_remain = be16_to_cpu(header->u.s16.l16);
 744         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
 745         ioc->mask = header->u.s16.m16;
 746     } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT &&
 747                ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT) {
 748         ioc->payload_remain = be64_to_cpu(header->u.s64.l64);
 749         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
 750         ioc->mask = header->u.s64.m64;
 751     } else {
 752         /* header not complete */
 753         return QIO_CHANNEL_ERR_BLOCK;
 754     }
 755
 756     trace_qio_channel_websock_header_full_decode(
 757         ioc, header_size, ioc->payload_remain, ioc->mask.u);
 758     buffer_advance(&ioc->encinput, header_size);
 759     return 0;
 760 }
 761
 762
 763 static int qio_channel_websock_decode_payload(QIOChannelWebsock *ioc,
 764                                               Error **errp)
 765 {
 766     size_t i;
 767     size_t payload_len = 0;
 768     uint32_t *payload32;
 769
 770     if (ioc->payload_remain) {
 771         /* If we aren't at the end of the payload, then drop
 772          * off the last bytes, so we're always multiple of 4
 773          * for purpose of unmasking, except at end of payload
 774          */
 775         if (ioc->encinput.offset < ioc->payload_remain) {
 776             /* Wait for the entire payload before processing control frames
 777              * because the payload will most likely be echoed back. */
 778             if (ioc->opcode & QIO_CHANNEL_WEBSOCK_CONTROL_OPCODE_MASK) {
 779                 return QIO_CHANNEL_ERR_BLOCK;
 780             }
 781             payload_len = ioc->encinput.offset - (ioc->encinput.offset % 4);
 782         } else {
 783             payload_len = ioc->payload_remain;
 784         }
 785         if (payload_len == 0) {
 786             return QIO_CHANNEL_ERR_BLOCK;
 787         }
 788
 789         ioc->payload_remain -= payload_len;
 790
 791         /* unmask frame */
 792         /* process 1 frame (32 bit op) */
 793         payload32 = (uint32_t *)ioc->encinput.buffer;
 794         for (i = 0; i < payload_len / 4; i++) {
 795             payload32[i] ^= ioc->mask.u;
 796         }
 797         /* process the remaining bytes (if any) */
 798         for (i *= 4; i < payload_len; i++) {
 799             ioc->encinput.buffer[i] ^= ioc->mask.c[i % 4];
 800         }
 801     }
 802
 803     trace_qio_channel_websock_payload_decode(
 804         ioc, ioc->opcode, ioc->payload_remain);
 805
 806     if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
 807         if (payload_len) {
 808             /* binary frames are passed on */
 809             buffer_reserve(&ioc->rawinput, payload_len);
 810             buffer_append(&ioc->rawinput, ioc->encinput.buffer, payload_len);
 811         }
 812     } else if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE) {
 813         /* close frames are echoed back */
 814         error_setg(errp, "websocket closed by peer");
 815         if (payload_len) {
 816             /* echo client status */
 817             struct iovec iov = { .iov_base = ioc->encinput.buffer,
 818                                  .iov_len = ioc->encinput.offset };
 819             qio_channel_websock_encode(ioc, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
 820                                        &iov, 1, iov.iov_len);
 821             qio_channel_websock_write_wire(ioc, NULL);
 822             qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
 823         } else {
 824             /* send our own status */
 825             qio_channel_websock_write_close(
 826                 ioc, QIO_CHANNEL_WEBSOCK_STATUS_NORMAL, "peer requested close");
 827         }
 828         return -1;
 829     } else if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_PING) {
 830         /* ping frames produce an immediate reply, as long as we've not still
 831          * got a previous pong queued, in which case we drop the new pong */
 832         if (ioc->pong_remain == 0) {
 833             struct iovec iov = { .iov_base = ioc->encinput.buffer,
 834                                  .iov_len = ioc->encinput.offset };
 835             qio_channel_websock_encode(ioc, QIO_CHANNEL_WEBSOCK_OPCODE_PONG,
 836                                        &iov, 1, iov.iov_len);
 837             ioc->pong_remain = ioc->encoutput.offset;
 838         }
 839     }   /* pong frames are ignored */
 840
 841     if (payload_len) {
 842         buffer_advance(&ioc->encinput, payload_len);
 843     }
 844     return 0;
 845 }
 846
 847
 848 QIOChannelWebsock *
 849 qio_channel_websock_new_server(QIOChannel *master)
 850 {
 851     QIOChannelWebsock *wioc;
 852     QIOChannel *ioc;
 853
 854     wioc = QIO_CHANNEL_WEBSOCK(object_new(TYPE_QIO_CHANNEL_WEBSOCK));
 855     ioc = QIO_CHANNEL(wioc);
 856
 857     wioc->master = master;
 858     if (qio_channel_has_feature(master, QIO_CHANNEL_FEATURE_SHUTDOWN)) {
 859         qio_channel_set_feature(ioc, QIO_CHANNEL_FEATURE_SHUTDOWN);
 860     }
 861     object_ref(OBJECT(master));
 862
 863     trace_qio_channel_websock_new_server(wioc, master);
 864     return wioc;
 865 }
 866
 867 void qio_channel_websock_handshake(QIOChannelWebsock *ioc,
 868                                    QIOTaskFunc func,
 869                                    gpointer opaque,
 870                                    GDestroyNotify destroy)
 871 {
 872     QIOTask *task;
 873
 874     task = qio_task_new(OBJECT(ioc),
 875                         func,
 876                         opaque,
 877                         destroy);
 878
 879     trace_qio_channel_websock_handshake_start(ioc);
 880     trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
 881     qio_channel_add_watch(ioc->master,
 882                           G_IO_IN,
 883                           qio_channel_websock_handshake_io,
 884                           task,
 885                           NULL);
 886 }
 887
 888
 889 static void qio_channel_websock_finalize(Object *obj)
 890 {
 891     QIOChannelWebsock *ioc = QIO_CHANNEL_WEBSOCK(obj);
 892
 893     buffer_free(&ioc->encinput);
 894     buffer_free(&ioc->encoutput);
 895     buffer_free(&ioc->rawinput);
 896     buffer_free(&ioc->rawoutput);
 897     object_unref(OBJECT(ioc->master));
 898     if (ioc->io_tag) {
 899         g_source_remove(ioc->io_tag);
 900     }
 901     if (ioc->io_err) {
 902         error_free(ioc->io_err);
 903     }
 904 }
 905
 906
 907 static ssize_t qio_channel_websock_read_wire(QIOChannelWebsock *ioc,
 908                                              Error **errp)
 909 {
 910     ssize_t ret;
 911
 912     if (ioc->encinput.offset < 4096) {
 913         size_t want = 4096 - ioc->encinput.offset;
 914
 915         buffer_reserve(&ioc->encinput, want);
 916         ret = qio_channel_read(ioc->master,
 917                                (char *)ioc->encinput.buffer +
 918                                ioc->encinput.offset,
 919                                want,
 920                                errp);
 921         if (ret < 0) {
 922             return ret;
 923         }
 924         if (ret == 0 && ioc->encinput.offset == 0) {
 925             ioc->io_eof = TRUE;
 926             return 0;
 927         }
 928         ioc->encinput.offset += ret;
 929     }
 930
 931     while (ioc->encinput.offset != 0) {
 932         if (ioc->payload_remain == 0) {
 933             ret = qio_channel_websock_decode_header(ioc, errp);
 934             if (ret < 0) {
 935                 return ret;
 936             }
 937         }
 938
 939         ret = qio_channel_websock_decode_payload(ioc, errp);
 940         if (ret < 0) {
 941             return ret;
 942         }
 943     }
 944     return 1;
 945 }
 946
 947
 948 static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *ioc,
 949                                               Error **errp)
 950 {
 951     ssize_t ret;
 952     ssize_t done = 0;
 953
 954     while (ioc->encoutput.offset > 0) {
 955         ret = qio_channel_write(ioc->master,
 956                                 (char *)ioc->encoutput.buffer,
 957                                 ioc->encoutput.offset,
 958                                 errp);
 959         if (ret < 0) {
 960             if (ret == QIO_CHANNEL_ERR_BLOCK &&
 961                 done > 0) {
 962                 return done;
 963             } else {
 964                 return ret;
 965             }
 966         }
 967         buffer_advance(&ioc->encoutput, ret);
 968         done += ret;
 969         if (ioc->pong_remain < ret) {
 970             ioc->pong_remain = 0;
 971         } else {
 972             ioc->pong_remain -= ret;
 973         }
 974     }
 975     return done;
 976 }
 977
 978
 979 static void qio_channel_websock_flush_free(gpointer user_data)
 980 {
 981     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
 982     object_unref(OBJECT(wioc));
 983 }
 984
 985 static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc);
 986
 987 static gboolean qio_channel_websock_flush(QIOChannel *ioc,
 988                                           GIOCondition condition,
 989                                           gpointer user_data)
 990 {
 991     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
 992     ssize_t ret;
 993
 994     if (condition & G_IO_OUT) {
 995         ret = qio_channel_websock_write_wire(wioc, &wioc->io_err);
 996         if (ret < 0) {
 997             goto cleanup;
 998         }
 999     }
1000
1001     if (condition & G_IO_IN) {
1002         ret = qio_channel_websock_read_wire(wioc, &wioc->io_err);
1003         if (ret < 0) {
1004             goto cleanup;
1005         }
1006     }
1007
1008  cleanup:
1009     qio_channel_websock_set_watch(wioc);
1010     return FALSE;
1011 }
1012
1013
1014 static void qio_channel_websock_unset_watch(QIOChannelWebsock *ioc)
1015 {
1016     if (ioc->io_tag) {
1017         g_source_remove(ioc->io_tag);
1018         ioc->io_tag = 0;
1019     }
1020 }
1021
1022 static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc)
1023 {
1024     GIOCondition cond = 0;
1025
1026     qio_channel_websock_unset_watch(ioc);
1027
1028     if (ioc->io_err) {
1029         return;
1030     }
1031
1032     if (ioc->encoutput.offset) {
1033         cond |= G_IO_OUT;
1034     }
1035     if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER &&
1036         !ioc->io_eof) {
1037         cond |= G_IO_IN;
1038     }
1039
1040     if (cond) {
1041         object_ref(OBJECT(ioc));
1042         ioc->io_tag =
1043             qio_channel_add_watch(ioc->master,
1044                                   cond,
1045                                   qio_channel_websock_flush,
1046                                   ioc,
1047                                   qio_channel_websock_flush_free);
1048     }
1049 }
1050
1051
1052 static ssize_t qio_channel_websock_readv(QIOChannel *ioc,
1053                                          const struct iovec *iov,
1054                                          size_t niov,
1055                                          int **fds,
1056                                          size_t *nfds,
1057                                          Error **errp)
1058 {
1059     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1060     size_t i;
1061     ssize_t got = 0;
1062     ssize_t ret;
1063
1064     if (wioc->io_err) {
1065         error_propagate(errp, error_copy(wioc->io_err));
1066         return -1;
1067     }
1068
1069     if (!wioc->rawinput.offset) {
1070         ret = qio_channel_websock_read_wire(QIO_CHANNEL_WEBSOCK(ioc), errp);
1071         if (ret < 0) {
1072             return ret;
1073         }
1074     }
1075
1076     for (i = 0 ; i < niov ; i++) {
1077         size_t want = iov[i].iov_len;
1078         if (want > (wioc->rawinput.offset - got)) {
1079             want = (wioc->rawinput.offset - got);
1080         }
1081
1082         memcpy(iov[i].iov_base,
1083                wioc->rawinput.buffer + got,
1084                want);
1085         got += want;
1086
1087         if (want < iov[i].iov_len) {
1088             break;
1089         }
1090     }
1091
1092     buffer_advance(&wioc->rawinput, got);
1093     qio_channel_websock_set_watch(wioc);
1094     return got;
1095 }
1096
1097
1098 static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
1099                                           const struct iovec *iov,
1100                                           size_t niov,
1101                                           int *fds,
1102                                           size_t nfds,
1103                                           Error **errp)
1104 {
1105     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1106     size_t i;
1107     ssize_t done = 0;
1108     ssize_t ret;
1109
1110     if (wioc->io_err) {
1111         error_propagate(errp, error_copy(wioc->io_err));
1112         return -1;
1113     }
1114
1115     if (wioc->io_eof) {
1116         error_setg(errp, "%s", "Broken pipe");
1117         return -1;
1118     }
1119
1120     for (i = 0; i < niov; i++) {
1121         size_t want = iov[i].iov_len;
1122         if ((want + wioc->rawoutput.offset) > QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
1123             want = (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->rawoutput.offset);
1124         }
1125         if (want == 0) {
1126             goto done;
1127         }
1128
1129         buffer_reserve(&wioc->rawoutput, want);
1130         buffer_append(&wioc->rawoutput, iov[i].iov_base, want);
1131         done += want;
1132         if (want < iov[i].iov_len) {
1133             break;
1134         }
1135     }
1136
1137  done:
1138     if (wioc->rawoutput.offset) {
1139         struct iovec iov = { .iov_base = wioc->rawoutput.buffer,
1140                              .iov_len = wioc->rawoutput.offset };
1141         qio_channel_websock_encode(wioc,
1142                                    QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME,
1143                                    &iov, 1, iov.iov_len);
1144         buffer_reset(&wioc->rawoutput);
1145     }
1146     ret = qio_channel_websock_write_wire(wioc, errp);
1147     if (ret < 0 &&
1148         ret != QIO_CHANNEL_ERR_BLOCK) {
1149         qio_channel_websock_unset_watch(wioc);
1150         return -1;
1151     }
1152
1153     qio_channel_websock_set_watch(wioc);
1154
1155     if (done == 0) {
1156         return QIO_CHANNEL_ERR_BLOCK;
1157     }
1158
1159     return done;
1160 }
1161
1162 static int qio_channel_websock_set_blocking(QIOChannel *ioc,
1163                                             bool enabled,
1164                                             Error **errp)
1165 {
1166     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1167
1168     qio_channel_set_blocking(wioc->master, enabled, errp);
1169     return 0;
1170 }
1171
1172 static void qio_channel_websock_set_delay(QIOChannel *ioc,
1173                                           bool enabled)
1174 {
1175     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1176
1177     qio_channel_set_delay(tioc->master, enabled);
1178 }
1179
1180 static void qio_channel_websock_set_cork(QIOChannel *ioc,
1181                                          bool enabled)
1182 {
1183     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1184
1185     qio_channel_set_cork(tioc->master, enabled);
1186 }
1187
1188 static int qio_channel_websock_shutdown(QIOChannel *ioc,
1189                                         QIOChannelShutdown how,
1190                                         Error **errp)
1191 {
1192     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1193
1194     return qio_channel_shutdown(tioc->master, how, errp);
1195 }
1196
1197 static int qio_channel_websock_close(QIOChannel *ioc,
1198                                      Error **errp)
1199 {
1200     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1201
1202     trace_qio_channel_websock_close(ioc);
1203     return qio_channel_close(wioc->master, errp);
1204 }
1205
1206 typedef struct QIOChannelWebsockSource QIOChannelWebsockSource;
1207 struct QIOChannelWebsockSource {
1208     GSource parent;
1209     QIOChannelWebsock *wioc;
1210     GIOCondition condition;
1211 };
1212
1213 static gboolean
1214 qio_channel_websock_source_check(GSource *source)
1215 {
1216     QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
1217     GIOCondition cond = 0;
1218
1219     if (wsource->wioc->rawinput.offset || wsource->wioc->io_eof) {
1220         cond |= G_IO_IN;
1221     }
1222     if (wsource->wioc->encoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
1223         cond |= G_IO_OUT;
1224     }
1225
1226     return cond & wsource->condition;
1227 }
1228
1229 static gboolean
1230 qio_channel_websock_source_prepare(GSource *source,
1231                                    gint *timeout)
1232 {
1233     *timeout = -1;
1234     return qio_channel_websock_source_check(source);
1235 }
1236
1237 static gboolean
1238 qio_channel_websock_source_dispatch(GSource *source,
1239                                     GSourceFunc callback,
1240                                     gpointer user_data)
1241 {
1242     QIOChannelFunc func = (QIOChannelFunc)callback;
1243     QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
1244
1245     return (*func)(QIO_CHANNEL(wsource->wioc),
1246                    qio_channel_websock_source_check(source),
1247                    user_data);
1248 }
1249
1250 static void
1251 qio_channel_websock_source_finalize(GSource *source)
1252 {
1253     QIOChannelWebsockSource *ssource = (QIOChannelWebsockSource *)source;
1254
1255     object_unref(OBJECT(ssource->wioc));
1256 }
1257
1258 GSourceFuncs qio_channel_websock_source_funcs = {
1259     qio_channel_websock_source_prepare,
1260     qio_channel_websock_source_check,
1261     qio_channel_websock_source_dispatch,
1262     qio_channel_websock_source_finalize
1263 };
1264
1265 static GSource *qio_channel_websock_create_watch(QIOChannel *ioc,
1266                                                  GIOCondition condition)
1267 {
1268     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1269     QIOChannelWebsockSource *ssource;
1270     GSource *source;
1271
1272     source = g_source_new(&qio_channel_websock_source_funcs,
1273                           sizeof(QIOChannelWebsockSource));
1274     ssource = (QIOChannelWebsockSource *)source;
1275
1276     ssource->wioc = wioc;
1277     object_ref(OBJECT(wioc));
1278
1279     ssource->condition = condition;
1280
1281     qio_channel_websock_set_watch(wioc);
1282     return source;
1283 }
1284
1285 static void qio_channel_websock_class_init(ObjectClass *klass,
1286                                            void *class_data G_GNUC_UNUSED)
1287 {
1288     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
1289
1290     ioc_klass->io_writev = qio_channel_websock_writev;
1291     ioc_klass->io_readv = qio_channel_websock_readv;
1292     ioc_klass->io_set_blocking = qio_channel_websock_set_blocking;
1293     ioc_klass->io_set_cork = qio_channel_websock_set_cork;
1294     ioc_klass->io_set_delay = qio_channel_websock_set_delay;
1295     ioc_klass->io_close = qio_channel_websock_close;
1296     ioc_klass->io_shutdown = qio_channel_websock_shutdown;
1297     ioc_klass->io_create_watch = qio_channel_websock_create_watch;
1298 }
1299
1300 static const TypeInfo qio_channel_websock_info = {
1301     .parent = TYPE_QIO_CHANNEL,
1302     .name = TYPE_QIO_CHANNEL_WEBSOCK,
1303     .instance_size = sizeof(QIOChannelWebsock),
1304     .instance_finalize = qio_channel_websock_finalize,
1305     .class_init = qio_channel_websock_class_init,
1306 };
1307
1308 static void qio_channel_websock_register_types(void)
1309 {
1310     type_register_static(&qio_channel_websock_info);
1311 }
1312
1313 type_init(qio_channel_websock_register_types);