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_buffer(QIOChannelWebsock *ioc,
 586                                               Buffer *output,
 587                                               uint8_t opcode, Buffer *buffer)
 588 {
 589     size_t header_size;
 590     union {
 591         char buf[QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT];
 592         QIOChannelWebsockHeader ws;
 593     } header;
 594
 595     header.ws.b0 = QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN |
 596         (opcode & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE);
 597     if (buffer->offset < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT) {
 598         header.ws.b1 = (uint8_t)buffer->offset;
 599         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
 600     } else if (buffer->offset <
 601                QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT) {
 602         header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT;
 603         header.ws.u.s16.l16 = cpu_to_be16((uint16_t)buffer->offset);
 604         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
 605     } else {
 606         header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT;
 607         header.ws.u.s64.l64 = cpu_to_be64(buffer->offset);
 608         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
 609     }
 610     header_size -= QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK;
 611
 612     trace_qio_channel_websock_encode(ioc, opcode, header_size, buffer->offset);
 613     buffer_reserve(output, header_size + buffer->offset);
 614     buffer_append(output, header.buf, header_size);
 615     buffer_append(output, buffer->buffer, buffer->offset);
 616 }
 617
 618
 619 static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *, Error **);
 620
 621
 622 static void qio_channel_websock_write_close(QIOChannelWebsock *ioc,
 623                                             uint16_t code, const char *reason)
 624 {
 625     buffer_reserve(&ioc->rawoutput, 2 + (reason ? strlen(reason) : 0));
 626     *(uint16_t *)(ioc->rawoutput.buffer + ioc->rawoutput.offset) =
 627         cpu_to_be16(code);
 628     ioc->rawoutput.offset += 2;
 629     if (reason) {
 630         buffer_append(&ioc->rawoutput, reason, strlen(reason));
 631     }
 632     qio_channel_websock_encode_buffer(
 633         ioc, &ioc->encoutput, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
 634         &ioc->rawoutput);
 635     buffer_reset(&ioc->rawoutput);
 636     qio_channel_websock_write_wire(ioc, NULL);
 637     qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
 638 }
 639
 640
 641 static int qio_channel_websock_decode_header(QIOChannelWebsock *ioc,
 642                                              Error **errp)
 643 {
 644     unsigned char opcode, fin, has_mask;
 645     size_t header_size;
 646     size_t payload_len;
 647     QIOChannelWebsockHeader *header =
 648         (QIOChannelWebsockHeader *)ioc->encinput.buffer;
 649
 650     if (ioc->payload_remain) {
 651         error_setg(errp,
 652                    "Decoding header but %zu bytes of payload remain",
 653                    ioc->payload_remain);
 654         qio_channel_websock_write_close(
 655             ioc, QIO_CHANNEL_WEBSOCK_STATUS_SERVER_ERR,
 656             "internal server error");
 657         return -1;
 658     }
 659     if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT) {
 660         /* header not complete */
 661         return QIO_CHANNEL_ERR_BLOCK;
 662     }
 663
 664     fin = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN;
 665     opcode = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE;
 666     has_mask = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_HAS_MASK;
 667     payload_len = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_PAYLOAD_LEN;
 668
 669     /* Save or restore opcode. */
 670     if (opcode) {
 671         ioc->opcode = opcode;
 672     } else {
 673         opcode = ioc->opcode;
 674     }
 675
 676     trace_qio_channel_websock_header_partial_decode(ioc, payload_len,
 677                                                     fin, opcode, (int)has_mask);
 678
 679     if (opcode == QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE) {
 680         /* disconnect */
 681         return 0;
 682     }
 683
 684     /* Websocket frame sanity check:
 685      * * Fragmentation is only supported for binary frames.
 686      * * All frames sent by a client MUST be masked.
 687      * * Only binary and ping/pong encoding is supported.
 688      */
 689     if (!fin) {
 690         if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
 691             error_setg(errp, "only binary websocket frames may be fragmented");
 692             qio_channel_websock_write_close(
 693                 ioc, QIO_CHANNEL_WEBSOCK_STATUS_POLICY ,
 694                 "only binary frames may be fragmented");
 695             return -1;
 696         }
 697     } else {
 698         if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME &&
 699             opcode != QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE &&
 700             opcode != QIO_CHANNEL_WEBSOCK_OPCODE_PING &&
 701             opcode != QIO_CHANNEL_WEBSOCK_OPCODE_PONG) {
 702             error_setg(errp, "unsupported opcode: %#04x; only binary, close, "
 703                        "ping, and pong websocket frames are supported", opcode);
 704             qio_channel_websock_write_close(
 705                 ioc, QIO_CHANNEL_WEBSOCK_STATUS_INVALID_DATA ,
 706                 "only binary, close, ping, and pong frames are supported");
 707             return -1;
 708         }
 709     }
 710     if (!has_mask) {
 711         error_setg(errp, "client websocket frames must be masked");
 712         qio_channel_websock_write_close(
 713             ioc, QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR,
 714             "client frames must be masked");
 715         return -1;
 716     }
 717
 718     if (payload_len < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT) {
 719         ioc->payload_remain = payload_len;
 720         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
 721         ioc->mask = header->u.m;
 722     } else if (opcode & QIO_CHANNEL_WEBSOCK_CONTROL_OPCODE_MASK) {
 723         error_setg(errp, "websocket control frame is too large");
 724         qio_channel_websock_write_close(
 725             ioc, QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR,
 726             "control frame is too large");
 727         return -1;
 728     } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT &&
 729                ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT) {
 730         ioc->payload_remain = be16_to_cpu(header->u.s16.l16);
 731         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
 732         ioc->mask = header->u.s16.m16;
 733     } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT &&
 734                ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT) {
 735         ioc->payload_remain = be64_to_cpu(header->u.s64.l64);
 736         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
 737         ioc->mask = header->u.s64.m64;
 738     } else {
 739         /* header not complete */
 740         return QIO_CHANNEL_ERR_BLOCK;
 741     }
 742
 743     trace_qio_channel_websock_header_full_decode(
 744         ioc, header_size, ioc->payload_remain, ioc->mask.u);
 745     buffer_advance(&ioc->encinput, header_size);
 746     return 0;
 747 }
 748
 749
 750 static int qio_channel_websock_decode_payload(QIOChannelWebsock *ioc,
 751                                               Error **errp)
 752 {
 753     size_t i;
 754     size_t payload_len = 0;
 755     uint32_t *payload32;
 756
 757     if (ioc->payload_remain) {
 758         /* If we aren't at the end of the payload, then drop
 759          * off the last bytes, so we're always multiple of 4
 760          * for purpose of unmasking, except at end of payload
 761          */
 762         if (ioc->encinput.offset < ioc->payload_remain) {
 763             /* Wait for the entire payload before processing control frames
 764              * because the payload will most likely be echoed back. */
 765             if (ioc->opcode & QIO_CHANNEL_WEBSOCK_CONTROL_OPCODE_MASK) {
 766                 return QIO_CHANNEL_ERR_BLOCK;
 767             }
 768             payload_len = ioc->encinput.offset - (ioc->encinput.offset % 4);
 769         } else {
 770             payload_len = ioc->payload_remain;
 771         }
 772         if (payload_len == 0) {
 773             return QIO_CHANNEL_ERR_BLOCK;
 774         }
 775
 776         ioc->payload_remain -= payload_len;
 777
 778         /* unmask frame */
 779         /* process 1 frame (32 bit op) */
 780         payload32 = (uint32_t *)ioc->encinput.buffer;
 781         for (i = 0; i < payload_len / 4; i++) {
 782             payload32[i] ^= ioc->mask.u;
 783         }
 784         /* process the remaining bytes (if any) */
 785         for (i *= 4; i < payload_len; i++) {
 786             ioc->encinput.buffer[i] ^= ioc->mask.c[i % 4];
 787         }
 788     }
 789
 790     trace_qio_channel_websock_payload_decode(
 791         ioc, ioc->opcode, ioc->payload_remain);
 792
 793     if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
 794         if (payload_len) {
 795             /* binary frames are passed on */
 796             buffer_reserve(&ioc->rawinput, payload_len);
 797             buffer_append(&ioc->rawinput, ioc->encinput.buffer, payload_len);
 798         }
 799     } else if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE) {
 800         /* close frames are echoed back */
 801         error_setg(errp, "websocket closed by peer");
 802         if (payload_len) {
 803             /* echo client status */
 804             qio_channel_websock_encode_buffer(
 805                 ioc, &ioc->encoutput, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
 806                 &ioc->encinput);
 807             qio_channel_websock_write_wire(ioc, NULL);
 808             qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
 809         } else {
 810             /* send our own status */
 811             qio_channel_websock_write_close(
 812                 ioc, QIO_CHANNEL_WEBSOCK_STATUS_NORMAL, "peer requested close");
 813         }
 814         return -1;
 815     } else if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_PING) {
 816         /* ping frames produce an immediate reply, as long as we've not still
 817          * got a previous pong queued, in which case we drop the new pong */
 818         if (ioc->pong_remain == 0) {
 819             qio_channel_websock_encode_buffer(
 820                 ioc, &ioc->encoutput, QIO_CHANNEL_WEBSOCK_OPCODE_PONG,
 821                 &ioc->encinput);
 822             ioc->pong_remain = ioc->encoutput.offset;
 823         }
 824     }   /* pong frames are ignored */
 825
 826     if (payload_len) {
 827         buffer_advance(&ioc->encinput, payload_len);
 828     }
 829     return 0;
 830 }
 831
 832
 833 QIOChannelWebsock *
 834 qio_channel_websock_new_server(QIOChannel *master)
 835 {
 836     QIOChannelWebsock *wioc;
 837     QIOChannel *ioc;
 838
 839     wioc = QIO_CHANNEL_WEBSOCK(object_new(TYPE_QIO_CHANNEL_WEBSOCK));
 840     ioc = QIO_CHANNEL(wioc);
 841
 842     wioc->master = master;
 843     if (qio_channel_has_feature(master, QIO_CHANNEL_FEATURE_SHUTDOWN)) {
 844         qio_channel_set_feature(ioc, QIO_CHANNEL_FEATURE_SHUTDOWN);
 845     }
 846     object_ref(OBJECT(master));
 847
 848     trace_qio_channel_websock_new_server(wioc, master);
 849     return wioc;
 850 }
 851
 852 void qio_channel_websock_handshake(QIOChannelWebsock *ioc,
 853                                    QIOTaskFunc func,
 854                                    gpointer opaque,
 855                                    GDestroyNotify destroy)
 856 {
 857     QIOTask *task;
 858
 859     task = qio_task_new(OBJECT(ioc),
 860                         func,
 861                         opaque,
 862                         destroy);
 863
 864     trace_qio_channel_websock_handshake_start(ioc);
 865     trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
 866     qio_channel_add_watch(ioc->master,
 867                           G_IO_IN,
 868                           qio_channel_websock_handshake_io,
 869                           task,
 870                           NULL);
 871 }
 872
 873
 874 static void qio_channel_websock_finalize(Object *obj)
 875 {
 876     QIOChannelWebsock *ioc = QIO_CHANNEL_WEBSOCK(obj);
 877
 878     buffer_free(&ioc->encinput);
 879     buffer_free(&ioc->encoutput);
 880     buffer_free(&ioc->rawinput);
 881     buffer_free(&ioc->rawoutput);
 882     object_unref(OBJECT(ioc->master));
 883     if (ioc->io_tag) {
 884         g_source_remove(ioc->io_tag);
 885     }
 886     if (ioc->io_err) {
 887         error_free(ioc->io_err);
 888     }
 889 }
 890
 891
 892 static ssize_t qio_channel_websock_read_wire(QIOChannelWebsock *ioc,
 893                                              Error **errp)
 894 {
 895     ssize_t ret;
 896
 897     if (ioc->encinput.offset < 4096) {
 898         size_t want = 4096 - ioc->encinput.offset;
 899
 900         buffer_reserve(&ioc->encinput, want);
 901         ret = qio_channel_read(ioc->master,
 902                                (char *)ioc->encinput.buffer +
 903                                ioc->encinput.offset,
 904                                want,
 905                                errp);
 906         if (ret < 0) {
 907             return ret;
 908         }
 909         if (ret == 0 && ioc->encinput.offset == 0) {
 910             ioc->io_eof = TRUE;
 911             return 0;
 912         }
 913         ioc->encinput.offset += ret;
 914     }
 915
 916     while (ioc->encinput.offset != 0) {
 917         if (ioc->payload_remain == 0) {
 918             ret = qio_channel_websock_decode_header(ioc, errp);
 919             if (ret < 0) {
 920                 return ret;
 921             }
 922         }
 923
 924         ret = qio_channel_websock_decode_payload(ioc, errp);
 925         if (ret < 0) {
 926             return ret;
 927         }
 928     }
 929     return 1;
 930 }
 931
 932
 933 static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *ioc,
 934                                               Error **errp)
 935 {
 936     ssize_t ret;
 937     ssize_t done = 0;
 938
 939     while (ioc->encoutput.offset > 0) {
 940         ret = qio_channel_write(ioc->master,
 941                                 (char *)ioc->encoutput.buffer,
 942                                 ioc->encoutput.offset,
 943                                 errp);
 944         if (ret < 0) {
 945             if (ret == QIO_CHANNEL_ERR_BLOCK &&
 946                 done > 0) {
 947                 return done;
 948             } else {
 949                 return ret;
 950             }
 951         }
 952         buffer_advance(&ioc->encoutput, ret);
 953         done += ret;
 954         if (ioc->pong_remain < ret) {
 955             ioc->pong_remain = 0;
 956         } else {
 957             ioc->pong_remain -= ret;
 958         }
 959     }
 960     return done;
 961 }
 962
 963
 964 static void qio_channel_websock_flush_free(gpointer user_data)
 965 {
 966     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
 967     object_unref(OBJECT(wioc));
 968 }
 969
 970 static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc);
 971
 972 static gboolean qio_channel_websock_flush(QIOChannel *ioc,
 973                                           GIOCondition condition,
 974                                           gpointer user_data)
 975 {
 976     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
 977     ssize_t ret;
 978
 979     if (condition & G_IO_OUT) {
 980         ret = qio_channel_websock_write_wire(wioc, &wioc->io_err);
 981         if (ret < 0) {
 982             goto cleanup;
 983         }
 984     }
 985
 986     if (condition & G_IO_IN) {
 987         ret = qio_channel_websock_read_wire(wioc, &wioc->io_err);
 988         if (ret < 0) {
 989             goto cleanup;
 990         }
 991     }
 992
 993  cleanup:
 994     qio_channel_websock_set_watch(wioc);
 995     return FALSE;
 996 }
 997
 998
 999 static void qio_channel_websock_unset_watch(QIOChannelWebsock *ioc)
1000 {
1001     if (ioc->io_tag) {
1002         g_source_remove(ioc->io_tag);
1003         ioc->io_tag = 0;
1004     }
1005 }
1006
1007 static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc)
1008 {
1009     GIOCondition cond = 0;
1010
1011     qio_channel_websock_unset_watch(ioc);
1012
1013     if (ioc->io_err) {
1014         return;
1015     }
1016
1017     if (ioc->encoutput.offset) {
1018         cond |= G_IO_OUT;
1019     }
1020     if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER &&
1021         !ioc->io_eof) {
1022         cond |= G_IO_IN;
1023     }
1024
1025     if (cond) {
1026         object_ref(OBJECT(ioc));
1027         ioc->io_tag =
1028             qio_channel_add_watch(ioc->master,
1029                                   cond,
1030                                   qio_channel_websock_flush,
1031                                   ioc,
1032                                   qio_channel_websock_flush_free);
1033     }
1034 }
1035
1036
1037 static ssize_t qio_channel_websock_readv(QIOChannel *ioc,
1038                                          const struct iovec *iov,
1039                                          size_t niov,
1040                                          int **fds,
1041                                          size_t *nfds,
1042                                          Error **errp)
1043 {
1044     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1045     size_t i;
1046     ssize_t got = 0;
1047     ssize_t ret;
1048
1049     if (wioc->io_err) {
1050         error_propagate(errp, error_copy(wioc->io_err));
1051         return -1;
1052     }
1053
1054     if (!wioc->rawinput.offset) {
1055         ret = qio_channel_websock_read_wire(QIO_CHANNEL_WEBSOCK(ioc), errp);
1056         if (ret < 0) {
1057             return ret;
1058         }
1059     }
1060
1061     for (i = 0 ; i < niov ; i++) {
1062         size_t want = iov[i].iov_len;
1063         if (want > (wioc->rawinput.offset - got)) {
1064             want = (wioc->rawinput.offset - got);
1065         }
1066
1067         memcpy(iov[i].iov_base,
1068                wioc->rawinput.buffer + got,
1069                want);
1070         got += want;
1071
1072         if (want < iov[i].iov_len) {
1073             break;
1074         }
1075     }
1076
1077     buffer_advance(&wioc->rawinput, got);
1078     qio_channel_websock_set_watch(wioc);
1079     return got;
1080 }
1081
1082
1083 static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
1084                                           const struct iovec *iov,
1085                                           size_t niov,
1086                                           int *fds,
1087                                           size_t nfds,
1088                                           Error **errp)
1089 {
1090     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1091     size_t i;
1092     ssize_t done = 0;
1093     ssize_t ret;
1094
1095     if (wioc->io_err) {
1096         error_propagate(errp, error_copy(wioc->io_err));
1097         return -1;
1098     }
1099
1100     if (wioc->io_eof) {
1101         error_setg(errp, "%s", "Broken pipe");
1102         return -1;
1103     }
1104
1105     for (i = 0; i < niov; i++) {
1106         size_t want = iov[i].iov_len;
1107         if ((want + wioc->rawoutput.offset) > QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
1108             want = (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->rawoutput.offset);
1109         }
1110         if (want == 0) {
1111             goto done;
1112         }
1113
1114         buffer_reserve(&wioc->rawoutput, want);
1115         buffer_append(&wioc->rawoutput, iov[i].iov_base, want);
1116         done += want;
1117         if (want < iov[i].iov_len) {
1118             break;
1119         }
1120     }
1121
1122  done:
1123     if (ioc->rawoutput.offset) {
1124         qio_channel_websock_encode_buffer(
1125             ioc, &ioc->encoutput, QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME,
1126             &ioc->rawoutput);
1127         buffer_reset(&ioc->rawoutput);
1128     }
1129     ret = qio_channel_websock_write_wire(wioc, errp);
1130     if (ret < 0 &&
1131         ret != QIO_CHANNEL_ERR_BLOCK) {
1132         qio_channel_websock_unset_watch(wioc);
1133         return -1;
1134     }
1135
1136     qio_channel_websock_set_watch(wioc);
1137
1138     if (done == 0) {
1139         return QIO_CHANNEL_ERR_BLOCK;
1140     }
1141
1142     return done;
1143 }
1144
1145 static int qio_channel_websock_set_blocking(QIOChannel *ioc,
1146                                             bool enabled,
1147                                             Error **errp)
1148 {
1149     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1150
1151     qio_channel_set_blocking(wioc->master, enabled, errp);
1152     return 0;
1153 }
1154
1155 static void qio_channel_websock_set_delay(QIOChannel *ioc,
1156                                           bool enabled)
1157 {
1158     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1159
1160     qio_channel_set_delay(tioc->master, enabled);
1161 }
1162
1163 static void qio_channel_websock_set_cork(QIOChannel *ioc,
1164                                          bool enabled)
1165 {
1166     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1167
1168     qio_channel_set_cork(tioc->master, enabled);
1169 }
1170
1171 static int qio_channel_websock_shutdown(QIOChannel *ioc,
1172                                         QIOChannelShutdown how,
1173                                         Error **errp)
1174 {
1175     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1176
1177     return qio_channel_shutdown(tioc->master, how, errp);
1178 }
1179
1180 static int qio_channel_websock_close(QIOChannel *ioc,
1181                                      Error **errp)
1182 {
1183     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1184
1185     trace_qio_channel_websock_close(ioc);
1186     return qio_channel_close(wioc->master, errp);
1187 }
1188
1189 typedef struct QIOChannelWebsockSource QIOChannelWebsockSource;
1190 struct QIOChannelWebsockSource {
1191     GSource parent;
1192     QIOChannelWebsock *wioc;
1193     GIOCondition condition;
1194 };
1195
1196 static gboolean
1197 qio_channel_websock_source_check(GSource *source)
1198 {
1199     QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
1200     GIOCondition cond = 0;
1201
1202     if (wsource->wioc->rawinput.offset || wsource->wioc->io_eof) {
1203         cond |= G_IO_IN;
1204     }
1205     if (wsource->wioc->encoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
1206         cond |= G_IO_OUT;
1207     }
1208
1209     return cond & wsource->condition;
1210 }
1211
1212 static gboolean
1213 qio_channel_websock_source_prepare(GSource *source,
1214                                    gint *timeout)
1215 {
1216     *timeout = -1;
1217     return qio_channel_websock_source_check(source);
1218 }
1219
1220 static gboolean
1221 qio_channel_websock_source_dispatch(GSource *source,
1222                                     GSourceFunc callback,
1223                                     gpointer user_data)
1224 {
1225     QIOChannelFunc func = (QIOChannelFunc)callback;
1226     QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
1227
1228     return (*func)(QIO_CHANNEL(wsource->wioc),
1229                    qio_channel_websock_source_check(source),
1230                    user_data);
1231 }
1232
1233 static void
1234 qio_channel_websock_source_finalize(GSource *source)
1235 {
1236     QIOChannelWebsockSource *ssource = (QIOChannelWebsockSource *)source;
1237
1238     object_unref(OBJECT(ssource->wioc));
1239 }
1240
1241 GSourceFuncs qio_channel_websock_source_funcs = {
1242     qio_channel_websock_source_prepare,
1243     qio_channel_websock_source_check,
1244     qio_channel_websock_source_dispatch,
1245     qio_channel_websock_source_finalize
1246 };
1247
1248 static GSource *qio_channel_websock_create_watch(QIOChannel *ioc,
1249                                                  GIOCondition condition)
1250 {
1251     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1252     QIOChannelWebsockSource *ssource;
1253     GSource *source;
1254
1255     source = g_source_new(&qio_channel_websock_source_funcs,
1256                           sizeof(QIOChannelWebsockSource));
1257     ssource = (QIOChannelWebsockSource *)source;
1258
1259     ssource->wioc = wioc;
1260     object_ref(OBJECT(wioc));
1261
1262     ssource->condition = condition;
1263
1264     qio_channel_websock_set_watch(wioc);
1265     return source;
1266 }
1267
1268 static void qio_channel_websock_class_init(ObjectClass *klass,
1269                                            void *class_data G_GNUC_UNUSED)
1270 {
1271     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
1272
1273     ioc_klass->io_writev = qio_channel_websock_writev;
1274     ioc_klass->io_readv = qio_channel_websock_readv;
1275     ioc_klass->io_set_blocking = qio_channel_websock_set_blocking;
1276     ioc_klass->io_set_cork = qio_channel_websock_set_cork;
1277     ioc_klass->io_set_delay = qio_channel_websock_set_delay;
1278     ioc_klass->io_close = qio_channel_websock_close;
1279     ioc_klass->io_shutdown = qio_channel_websock_shutdown;
1280     ioc_klass->io_create_watch = qio_channel_websock_create_watch;
1281 }
1282
1283 static const TypeInfo qio_channel_websock_info = {
1284     .parent = TYPE_QIO_CHANNEL,
1285     .name = TYPE_QIO_CHANNEL_WEBSOCK,
1286     .instance_size = sizeof(QIOChannelWebsock),
1287     .instance_finalize = qio_channel_websock_finalize,
1288     .class_init = qio_channel_websock_class_init,
1289 };
1290
1291 static void qio_channel_websock_register_types(void)
1292 {
1293     type_register_static(&qio_channel_websock_info);
1294 }
1295
1296 type_init(qio_channel_websock_register_types);