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/rawoutput 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 GCC_FMT_ATTR(2, 3)
 155 qio_channel_websock_handshake_send_res(QIOChannelWebsock *ioc,
 156                                        const char *resmsg,
 157                                        ...)
 158 {
 159     va_list vargs;
 160     char *response;
 161     size_t responselen;
 162
 163     va_start(vargs, resmsg);
 164     response = g_strdup_vprintf(resmsg, vargs);
 165     responselen = strlen(response);
 166     buffer_reserve(&ioc->encoutput, responselen);
 167     buffer_append(&ioc->encoutput, response, responselen);
 168     va_end(vargs);
 169 }
 170
 171 static gchar *qio_channel_websock_date_str(void)
 172 {
 173     struct tm tm;
 174     time_t now = time(NULL);
 175     char datebuf[128];
 176
 177     gmtime_r(&now, &tm);
 178
 179     strftime(datebuf, sizeof(datebuf), "%a, %d %b %Y %H:%M:%S GMT", &tm);
 180
 181     return g_strdup(datebuf);
 182 }
 183
 184 static void qio_channel_websock_handshake_send_res_err(QIOChannelWebsock *ioc,
 185                                                        const char *resdata)
 186 {
 187     char *date = qio_channel_websock_date_str();
 188     qio_channel_websock_handshake_send_res(ioc, resdata, date);
 189     g_free(date);
 190 }
 191
 192 enum {
 193     QIO_CHANNEL_WEBSOCK_STATUS_NORMAL = 1000,
 194     QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR = 1002,
 195     QIO_CHANNEL_WEBSOCK_STATUS_INVALID_DATA = 1003,
 196     QIO_CHANNEL_WEBSOCK_STATUS_POLICY = 1008,
 197     QIO_CHANNEL_WEBSOCK_STATUS_TOO_LARGE = 1009,
 198     QIO_CHANNEL_WEBSOCK_STATUS_SERVER_ERR = 1011,
 199 };
 200
 201 static size_t
 202 qio_channel_websock_extract_headers(QIOChannelWebsock *ioc,
 203                                     char *buffer,
 204                                     QIOChannelWebsockHTTPHeader *hdrs,
 205                                     size_t nhdrsalloc,
 206                                     Error **errp)
 207 {
 208     char *nl, *sep, *tmp;
 209     size_t nhdrs = 0;
 210
 211     /*
 212      * First parse the HTTP protocol greeting of format:
 213      *
 214      *   $METHOD $PATH $VERSION
 215      *
 216      * e.g.
 217      *
 218      *   GET / HTTP/1.1
 219      */
 220
 221     nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
 222     if (!nl) {
 223         error_setg(errp, "Missing HTTP header delimiter");
 224         goto bad_request;
 225     }
 226     *nl = '\0';
 227
 228     tmp = strchr(buffer, ' ');
 229     if (!tmp) {
 230         error_setg(errp, "Missing HTTP path delimiter");
 231         return 0;
 232     }
 233     *tmp = '\0';
 234
 235     if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_METHOD)) {
 236         error_setg(errp, "Unsupported HTTP method %s", buffer);
 237         goto bad_request;
 238     }
 239
 240     buffer = tmp + 1;
 241     tmp = strchr(buffer, ' ');
 242     if (!tmp) {
 243         error_setg(errp, "Missing HTTP version delimiter");
 244         goto bad_request;
 245     }
 246     *tmp = '\0';
 247
 248     if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_PATH)) {
 249         qio_channel_websock_handshake_send_res_err(
 250             ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_NOT_FOUND);
 251         error_setg(errp, "Unexpected HTTP path %s", buffer);
 252         return 0;
 253     }
 254
 255     buffer = tmp + 1;
 256
 257     if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_VERSION)) {
 258         error_setg(errp, "Unsupported HTTP version %s", buffer);
 259         goto bad_request;
 260     }
 261
 262     buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
 263
 264     /*
 265      * Now parse all the header fields of format
 266      *
 267      *   $NAME: $VALUE
 268      *
 269      * e.g.
 270      *
 271      *   Cache-control: no-cache
 272      */
 273     do {
 274         QIOChannelWebsockHTTPHeader *hdr;
 275
 276         nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
 277         if (nl) {
 278             *nl = '\0';
 279         }
 280
 281         sep = strchr(buffer, ':');
 282         if (!sep) {
 283             error_setg(errp, "Malformed HTTP header");
 284             goto bad_request;
 285         }
 286         *sep = '\0';
 287         sep++;
 288         while (*sep == ' ') {
 289             sep++;
 290         }
 291
 292         if (nhdrs >= nhdrsalloc) {
 293             error_setg(errp, "Too many HTTP headers");
 294             goto bad_request;
 295         }
 296
 297         hdr = &hdrs[nhdrs++];
 298         hdr->name = buffer;
 299         hdr->value = sep;
 300
 301         /* Canonicalize header name for easier identification later */
 302         for (tmp = hdr->name; *tmp; tmp++) {
 303             *tmp = g_ascii_tolower(*tmp);
 304         }
 305
 306         if (nl) {
 307             buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
 308         }
 309     } while (nl != NULL);
 310
 311     return nhdrs;
 312
 313  bad_request:
 314     qio_channel_websock_handshake_send_res_err(
 315         ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_BAD_REQUEST);
 316     return 0;
 317 }
 318
 319 static const char *
 320 qio_channel_websock_find_header(QIOChannelWebsockHTTPHeader *hdrs,
 321                                 size_t nhdrs,
 322                                 const char *name)
 323 {
 324     size_t i;
 325
 326     for (i = 0; i < nhdrs; i++) {
 327         if (g_str_equal(hdrs[i].name, name)) {
 328             return hdrs[i].value;
 329         }
 330     }
 331
 332     return NULL;
 333 }
 334
 335
 336 static void qio_channel_websock_handshake_send_res_ok(QIOChannelWebsock *ioc,
 337                                                       const char *key,
 338                                                       Error **errp)
 339 {
 340     char combined_key[QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
 341                       QIO_CHANNEL_WEBSOCK_GUID_LEN + 1];
 342     char *accept = NULL;
 343     char *date = qio_channel_websock_date_str();
 344
 345     g_strlcpy(combined_key, key, QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN + 1);
 346     g_strlcat(combined_key, QIO_CHANNEL_WEBSOCK_GUID,
 347               QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
 348               QIO_CHANNEL_WEBSOCK_GUID_LEN + 1);
 349
 350     /* hash and encode it */
 351     if (qcrypto_hash_base64(QCRYPTO_HASH_ALG_SHA1,
 352                             combined_key,
 353                             QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
 354                             QIO_CHANNEL_WEBSOCK_GUID_LEN,
 355                             &accept,
 356                             errp) < 0) {
 357         qio_channel_websock_handshake_send_res_err(
 358             ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_SERVER_ERR);
 359         return;
 360     }
 361
 362     qio_channel_websock_handshake_send_res(
 363         ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_OK, date, accept);
 364
 365     g_free(date);
 366     g_free(accept);
 367 }
 368
 369 static void qio_channel_websock_handshake_process(QIOChannelWebsock *ioc,
 370                                                   char *buffer,
 371                                                   Error **errp)
 372 {
 373     QIOChannelWebsockHTTPHeader hdrs[32];
 374     size_t nhdrs = G_N_ELEMENTS(hdrs);
 375     const char *protocols = NULL, *version = NULL, *key = NULL,
 376         *host = NULL, *connection = NULL, *upgrade = NULL;
 377
 378     nhdrs = qio_channel_websock_extract_headers(ioc, buffer, hdrs, nhdrs, errp);
 379     if (!nhdrs) {
 380         return;
 381     }
 382
 383     protocols = qio_channel_websock_find_header(
 384         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_PROTOCOL);
 385     if (!protocols) {
 386         error_setg(errp, "Missing websocket protocol header data");
 387         goto bad_request;
 388     }
 389
 390     version = qio_channel_websock_find_header(
 391         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_VERSION);
 392     if (!version) {
 393         error_setg(errp, "Missing websocket version header data");
 394         goto bad_request;
 395     }
 396
 397     key = qio_channel_websock_find_header(
 398         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_KEY);
 399     if (!key) {
 400         error_setg(errp, "Missing websocket key header data");
 401         goto bad_request;
 402     }
 403
 404     host = qio_channel_websock_find_header(
 405         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_HOST);
 406     if (!host) {
 407         error_setg(errp, "Missing websocket host header data");
 408         goto bad_request;
 409     }
 410
 411     connection = qio_channel_websock_find_header(
 412         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_CONNECTION);
 413     if (!connection) {
 414         error_setg(errp, "Missing websocket connection header data");
 415         goto bad_request;
 416     }
 417
 418     upgrade = qio_channel_websock_find_header(
 419         hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_UPGRADE);
 420     if (!upgrade) {
 421         error_setg(errp, "Missing websocket upgrade header data");
 422         goto bad_request;
 423     }
 424
 425     if (!g_strrstr(protocols, QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY)) {
 426         error_setg(errp, "No '%s' protocol is supported by client '%s'",
 427                    QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY, protocols);
 428         goto bad_request;
 429     }
 430
 431     if (!g_str_equal(version, QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION)) {
 432         error_setg(errp, "Version '%s' is not supported by client '%s'",
 433                    QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION, version);
 434         goto bad_request;
 435     }
 436
 437     if (strlen(key) != QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN) {
 438         error_setg(errp, "Key length '%zu' was not as expected '%d'",
 439                    strlen(key), QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN);
 440         goto bad_request;
 441     }
 442
 443     if (strcasecmp(connection, QIO_CHANNEL_WEBSOCK_CONNECTION_UPGRADE) != 0) {
 444         error_setg(errp, "No connection upgrade requested '%s'", connection);
 445         goto bad_request;
 446     }
 447
 448     if (strcasecmp(upgrade, QIO_CHANNEL_WEBSOCK_UPGRADE_WEBSOCKET) != 0) {
 449         error_setg(errp, "Incorrect upgrade method '%s'", upgrade);
 450         goto bad_request;
 451     }
 452
 453     qio_channel_websock_handshake_send_res_ok(ioc, key, errp);
 454     return;
 455
 456  bad_request:
 457     qio_channel_websock_handshake_send_res_err(
 458         ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_BAD_REQUEST);
 459 }
 460
 461 static int qio_channel_websock_handshake_read(QIOChannelWebsock *ioc,
 462                                               Error **errp)
 463 {
 464     char *handshake_end;
 465     ssize_t ret;
 466     /* Typical HTTP headers from novnc are 512 bytes, so limiting
 467      * total header size to 4096 is easily enough. */
 468     size_t want = 4096 - ioc->encinput.offset;
 469     buffer_reserve(&ioc->encinput, want);
 470     ret = qio_channel_read(ioc->master,
 471                            (char *)buffer_end(&ioc->encinput), want, errp);
 472     if (ret < 0) {
 473         return -1;
 474     }
 475     ioc->encinput.offset += ret;
 476
 477     handshake_end = g_strstr_len((char *)ioc->encinput.buffer,
 478                                  ioc->encinput.offset,
 479                                  QIO_CHANNEL_WEBSOCK_HANDSHAKE_END);
 480     if (!handshake_end) {
 481         if (ioc->encinput.offset >= 4096) {
 482             qio_channel_websock_handshake_send_res_err(
 483                 ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_TOO_LARGE);
 484             error_setg(errp,
 485                        "End of headers not found in first 4096 bytes");
 486             return 1;
 487         } else {
 488             return 0;
 489         }
 490     }
 491     *handshake_end = '\0';
 492
 493     qio_channel_websock_handshake_process(ioc,
 494                                           (char *)ioc->encinput.buffer,
 495                                           errp);
 496
 497     buffer_advance(&ioc->encinput,
 498                    handshake_end - (char *)ioc->encinput.buffer +
 499                    strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_END));
 500     return 1;
 501 }
 502
 503 static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,
 504                                                    GIOCondition condition,
 505                                                    gpointer user_data)
 506 {
 507     QIOTask *task = user_data;
 508     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
 509         qio_task_get_source(task));
 510     Error *err = NULL;
 511     ssize_t ret;
 512
 513     ret = qio_channel_write(wioc->master,
 514                             (char *)wioc->encoutput.buffer,
 515                             wioc->encoutput.offset,
 516                             &err);
 517
 518     if (ret < 0) {
 519         trace_qio_channel_websock_handshake_fail(ioc, error_get_pretty(err));
 520         qio_task_set_error(task, err);
 521         qio_task_complete(task);
 522         return FALSE;
 523     }
 524
 525     buffer_advance(&wioc->encoutput, ret);
 526     if (wioc->encoutput.offset == 0) {
 527         if (wioc->io_err) {
 528             trace_qio_channel_websock_handshake_fail(
 529                 ioc, error_get_pretty(wioc->io_err));
 530             qio_task_set_error(task, wioc->io_err);
 531             wioc->io_err = NULL;
 532             qio_task_complete(task);
 533         } else {
 534             trace_qio_channel_websock_handshake_complete(ioc);
 535             qio_task_complete(task);
 536         }
 537         return FALSE;
 538     }
 539     trace_qio_channel_websock_handshake_pending(ioc, G_IO_OUT);
 540     return TRUE;
 541 }
 542
 543 static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc,
 544                                                  GIOCondition condition,
 545                                                  gpointer user_data)
 546 {
 547     QIOTask *task = user_data;
 548     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
 549         qio_task_get_source(task));
 550     Error *err = NULL;
 551     int ret;
 552
 553     ret = qio_channel_websock_handshake_read(wioc, &err);
 554     if (ret < 0) {
 555         /*
 556          * We only take this path on a fatal I/O error reading from
 557          * client connection, as most of the time we have an
 558          * HTTP 4xx err response to send instead
 559          */
 560         trace_qio_channel_websock_handshake_fail(ioc, error_get_pretty(err));
 561         qio_task_set_error(task, err);
 562         qio_task_complete(task);
 563         return FALSE;
 564     }
 565     if (ret == 0) {
 566         trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
 567         /* need more data still */
 568         return TRUE;
 569     }
 570
 571     if (err) {
 572         error_propagate(&wioc->io_err, err);
 573     }
 574
 575     trace_qio_channel_websock_handshake_reply(ioc);
 576     qio_channel_add_watch(
 577         wioc->master,
 578         G_IO_OUT,
 579         qio_channel_websock_handshake_send,
 580         task,
 581         NULL);
 582     return FALSE;
 583 }
 584
 585
 586 static void qio_channel_websock_encode_buffer(QIOChannelWebsock *ioc,
 587                                               Buffer *output,
 588                                               uint8_t opcode, Buffer *buffer)
 589 {
 590     size_t header_size;
 591     union {
 592         char buf[QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT];
 593         QIOChannelWebsockHeader ws;
 594     } header;
 595
 596     header.ws.b0 = QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN |
 597         (opcode & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE);
 598     if (buffer->offset < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT) {
 599         header.ws.b1 = (uint8_t)buffer->offset;
 600         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
 601     } else if (buffer->offset <
 602                QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT) {
 603         header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT;
 604         header.ws.u.s16.l16 = cpu_to_be16((uint16_t)buffer->offset);
 605         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
 606     } else {
 607         header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT;
 608         header.ws.u.s64.l64 = cpu_to_be64(buffer->offset);
 609         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
 610     }
 611     header_size -= QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK;
 612
 613     trace_qio_channel_websock_encode(ioc, opcode, header_size, buffer->offset);
 614     buffer_reserve(output, header_size + buffer->offset);
 615     buffer_append(output, header.buf, header_size);
 616     buffer_append(output, buffer->buffer, buffer->offset);
 617 }
 618
 619
 620 static void qio_channel_websock_encode(QIOChannelWebsock *ioc)
 621 {
 622     if (!ioc->rawoutput.offset) {
 623         return;
 624     }
 625     qio_channel_websock_encode_buffer(
 626         ioc, &ioc->encoutput, QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME,
 627         &ioc->rawoutput);
 628     buffer_reset(&ioc->rawoutput);
 629 }
 630
 631
 632 static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *, Error **);
 633
 634
 635 static void qio_channel_websock_write_close(QIOChannelWebsock *ioc,
 636                                             uint16_t code, const char *reason)
 637 {
 638     buffer_reserve(&ioc->rawoutput, 2 + (reason ? strlen(reason) : 0));
 639     *(uint16_t *)(ioc->rawoutput.buffer + ioc->rawoutput.offset) =
 640         cpu_to_be16(code);
 641     ioc->rawoutput.offset += 2;
 642     if (reason) {
 643         buffer_append(&ioc->rawoutput, reason, strlen(reason));
 644     }
 645     qio_channel_websock_encode_buffer(
 646         ioc, &ioc->encoutput, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
 647         &ioc->rawoutput);
 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             qio_channel_websock_encode_buffer(
 818                 ioc, &ioc->encoutput, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
 819                 &ioc->encinput);
 820             qio_channel_websock_write_wire(ioc, NULL);
 821             qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
 822         } else {
 823             /* send our own status */
 824             qio_channel_websock_write_close(
 825                 ioc, QIO_CHANNEL_WEBSOCK_STATUS_NORMAL, "peer requested close");
 826         }
 827         return -1;
 828     } else if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_PING) {
 829         /* ping frames produce an immediate reply */
 830         buffer_reset(&ioc->ping_reply);
 831         qio_channel_websock_encode_buffer(
 832             ioc, &ioc->ping_reply, QIO_CHANNEL_WEBSOCK_OPCODE_PONG,
 833             &ioc->encinput);
 834     }   /* pong frames are ignored */
 835
 836     if (payload_len) {
 837         buffer_advance(&ioc->encinput, payload_len);
 838     }
 839     return 0;
 840 }
 841
 842
 843 QIOChannelWebsock *
 844 qio_channel_websock_new_server(QIOChannel *master)
 845 {
 846     QIOChannelWebsock *wioc;
 847     QIOChannel *ioc;
 848
 849     wioc = QIO_CHANNEL_WEBSOCK(object_new(TYPE_QIO_CHANNEL_WEBSOCK));
 850     ioc = QIO_CHANNEL(wioc);
 851
 852     wioc->master = master;
 853     if (qio_channel_has_feature(master, QIO_CHANNEL_FEATURE_SHUTDOWN)) {
 854         qio_channel_set_feature(ioc, QIO_CHANNEL_FEATURE_SHUTDOWN);
 855     }
 856     object_ref(OBJECT(master));
 857
 858     trace_qio_channel_websock_new_server(wioc, master);
 859     return wioc;
 860 }
 861
 862 void qio_channel_websock_handshake(QIOChannelWebsock *ioc,
 863                                    QIOTaskFunc func,
 864                                    gpointer opaque,
 865                                    GDestroyNotify destroy)
 866 {
 867     QIOTask *task;
 868
 869     task = qio_task_new(OBJECT(ioc),
 870                         func,
 871                         opaque,
 872                         destroy);
 873
 874     trace_qio_channel_websock_handshake_start(ioc);
 875     trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
 876     qio_channel_add_watch(ioc->master,
 877                           G_IO_IN,
 878                           qio_channel_websock_handshake_io,
 879                           task,
 880                           NULL);
 881 }
 882
 883
 884 static void qio_channel_websock_finalize(Object *obj)
 885 {
 886     QIOChannelWebsock *ioc = QIO_CHANNEL_WEBSOCK(obj);
 887
 888     buffer_free(&ioc->encinput);
 889     buffer_free(&ioc->encoutput);
 890     buffer_free(&ioc->rawinput);
 891     buffer_free(&ioc->rawoutput);
 892     buffer_free(&ioc->ping_reply);
 893     object_unref(OBJECT(ioc->master));
 894     if (ioc->io_tag) {
 895         g_source_remove(ioc->io_tag);
 896     }
 897     if (ioc->io_err) {
 898         error_free(ioc->io_err);
 899     }
 900 }
 901
 902
 903 static ssize_t qio_channel_websock_read_wire(QIOChannelWebsock *ioc,
 904                                              Error **errp)
 905 {
 906     ssize_t ret;
 907
 908     if (ioc->encinput.offset < 4096) {
 909         size_t want = 4096 - ioc->encinput.offset;
 910
 911         buffer_reserve(&ioc->encinput, want);
 912         ret = qio_channel_read(ioc->master,
 913                                (char *)ioc->encinput.buffer +
 914                                ioc->encinput.offset,
 915                                want,
 916                                errp);
 917         if (ret < 0) {
 918             return ret;
 919         }
 920         if (ret == 0 && ioc->encinput.offset == 0) {
 921             ioc->io_eof = TRUE;
 922             return 0;
 923         }
 924         ioc->encinput.offset += ret;
 925     }
 926
 927     while (ioc->encinput.offset != 0) {
 928         if (ioc->payload_remain == 0) {
 929             ret = qio_channel_websock_decode_header(ioc, errp);
 930             if (ret < 0) {
 931                 return ret;
 932             }
 933         }
 934
 935         ret = qio_channel_websock_decode_payload(ioc, errp);
 936         if (ret < 0) {
 937             return ret;
 938         }
 939     }
 940     return 1;
 941 }
 942
 943
 944 static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *ioc,
 945                                               Error **errp)
 946 {
 947     ssize_t ret;
 948     ssize_t done = 0;
 949
 950     /* ping replies take priority over binary data */
 951     if (!ioc->ping_reply.offset) {
 952         qio_channel_websock_encode(ioc);
 953     } else if (!ioc->encoutput.offset) {
 954         buffer_move_empty(&ioc->encoutput, &ioc->ping_reply);
 955     }
 956
 957     while (ioc->encoutput.offset > 0) {
 958         ret = qio_channel_write(ioc->master,
 959                                 (char *)ioc->encoutput.buffer,
 960                                 ioc->encoutput.offset,
 961                                 errp);
 962         if (ret < 0) {
 963             if (ret == QIO_CHANNEL_ERR_BLOCK &&
 964                 done > 0) {
 965                 return done;
 966             } else {
 967                 return ret;
 968             }
 969         }
 970         buffer_advance(&ioc->encoutput, ret);
 971         done += ret;
 972     }
 973     return done;
 974 }
 975
 976
 977 static void qio_channel_websock_flush_free(gpointer user_data)
 978 {
 979     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
 980     object_unref(OBJECT(wioc));
 981 }
 982
 983 static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc);
 984
 985 static gboolean qio_channel_websock_flush(QIOChannel *ioc,
 986                                           GIOCondition condition,
 987                                           gpointer user_data)
 988 {
 989     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
 990     ssize_t ret;
 991
 992     if (condition & G_IO_OUT) {
 993         ret = qio_channel_websock_write_wire(wioc, &wioc->io_err);
 994         if (ret < 0) {
 995             goto cleanup;
 996         }
 997     }
 998
 999     if (condition & G_IO_IN) {
1000         ret = qio_channel_websock_read_wire(wioc, &wioc->io_err);
1001         if (ret < 0) {
1002             goto cleanup;
1003         }
1004     }
1005
1006  cleanup:
1007     qio_channel_websock_set_watch(wioc);
1008     return FALSE;
1009 }
1010
1011
1012 static void qio_channel_websock_unset_watch(QIOChannelWebsock *ioc)
1013 {
1014     if (ioc->io_tag) {
1015         g_source_remove(ioc->io_tag);
1016         ioc->io_tag = 0;
1017     }
1018 }
1019
1020 static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc)
1021 {
1022     GIOCondition cond = 0;
1023
1024     qio_channel_websock_unset_watch(ioc);
1025
1026     if (ioc->io_err) {
1027         return;
1028     }
1029
1030     if (ioc->encoutput.offset || ioc->ping_reply.offset) {
1031         cond |= G_IO_OUT;
1032     }
1033     if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER &&
1034         !ioc->io_eof) {
1035         cond |= G_IO_IN;
1036     }
1037
1038     if (cond) {
1039         object_ref(OBJECT(ioc));
1040         ioc->io_tag =
1041             qio_channel_add_watch(ioc->master,
1042                                   cond,
1043                                   qio_channel_websock_flush,
1044                                   ioc,
1045                                   qio_channel_websock_flush_free);
1046     }
1047 }
1048
1049
1050 static ssize_t qio_channel_websock_readv(QIOChannel *ioc,
1051                                          const struct iovec *iov,
1052                                          size_t niov,
1053                                          int **fds,
1054                                          size_t *nfds,
1055                                          Error **errp)
1056 {
1057     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1058     size_t i;
1059     ssize_t got = 0;
1060     ssize_t ret;
1061
1062     if (wioc->io_err) {
1063         error_propagate(errp, error_copy(wioc->io_err));
1064         return -1;
1065     }
1066
1067     if (!wioc->rawinput.offset) {
1068         ret = qio_channel_websock_read_wire(QIO_CHANNEL_WEBSOCK(ioc), errp);
1069         if (ret < 0) {
1070             return ret;
1071         }
1072     }
1073
1074     for (i = 0 ; i < niov ; i++) {
1075         size_t want = iov[i].iov_len;
1076         if (want > (wioc->rawinput.offset - got)) {
1077             want = (wioc->rawinput.offset - got);
1078         }
1079
1080         memcpy(iov[i].iov_base,
1081                wioc->rawinput.buffer + got,
1082                want);
1083         got += want;
1084
1085         if (want < iov[i].iov_len) {
1086             break;
1087         }
1088     }
1089
1090     buffer_advance(&wioc->rawinput, got);
1091     qio_channel_websock_set_watch(wioc);
1092     return got;
1093 }
1094
1095
1096 static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
1097                                           const struct iovec *iov,
1098                                           size_t niov,
1099                                           int *fds,
1100                                           size_t nfds,
1101                                           Error **errp)
1102 {
1103     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1104     size_t i;
1105     ssize_t done = 0;
1106     ssize_t ret;
1107
1108     if (wioc->io_err) {
1109         error_propagate(errp, error_copy(wioc->io_err));
1110         return -1;
1111     }
1112
1113     if (wioc->io_eof) {
1114         error_setg(errp, "%s", "Broken pipe");
1115         return -1;
1116     }
1117
1118     for (i = 0; i < niov; i++) {
1119         size_t want = iov[i].iov_len;
1120         if ((want + wioc->rawoutput.offset) > QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
1121             want = (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->rawoutput.offset);
1122         }
1123         if (want == 0) {
1124             goto done;
1125         }
1126
1127         buffer_reserve(&wioc->rawoutput, want);
1128         buffer_append(&wioc->rawoutput, iov[i].iov_base, want);
1129         done += want;
1130         if (want < iov[i].iov_len) {
1131             break;
1132         }
1133     }
1134
1135  done:
1136     ret = qio_channel_websock_write_wire(wioc, errp);
1137     if (ret < 0 &&
1138         ret != QIO_CHANNEL_ERR_BLOCK) {
1139         qio_channel_websock_unset_watch(wioc);
1140         return -1;
1141     }
1142
1143     qio_channel_websock_set_watch(wioc);
1144
1145     if (done == 0) {
1146         return QIO_CHANNEL_ERR_BLOCK;
1147     }
1148
1149     return done;
1150 }
1151
1152 static int qio_channel_websock_set_blocking(QIOChannel *ioc,
1153                                             bool enabled,
1154                                             Error **errp)
1155 {
1156     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1157
1158     qio_channel_set_blocking(wioc->master, enabled, errp);
1159     return 0;
1160 }
1161
1162 static void qio_channel_websock_set_delay(QIOChannel *ioc,
1163                                           bool enabled)
1164 {
1165     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1166
1167     qio_channel_set_delay(tioc->master, enabled);
1168 }
1169
1170 static void qio_channel_websock_set_cork(QIOChannel *ioc,
1171                                          bool enabled)
1172 {
1173     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1174
1175     qio_channel_set_cork(tioc->master, enabled);
1176 }
1177
1178 static int qio_channel_websock_shutdown(QIOChannel *ioc,
1179                                         QIOChannelShutdown how,
1180                                         Error **errp)
1181 {
1182     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1183
1184     return qio_channel_shutdown(tioc->master, how, errp);
1185 }
1186
1187 static int qio_channel_websock_close(QIOChannel *ioc,
1188                                      Error **errp)
1189 {
1190     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1191
1192     trace_qio_channel_websock_close(ioc);
1193     return qio_channel_close(wioc->master, errp);
1194 }
1195
1196 typedef struct QIOChannelWebsockSource QIOChannelWebsockSource;
1197 struct QIOChannelWebsockSource {
1198     GSource parent;
1199     QIOChannelWebsock *wioc;
1200     GIOCondition condition;
1201 };
1202
1203 static gboolean
1204 qio_channel_websock_source_check(GSource *source)
1205 {
1206     QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
1207     GIOCondition cond = 0;
1208
1209     if (wsource->wioc->rawinput.offset || wsource->wioc->io_eof) {
1210         cond |= G_IO_IN;
1211     }
1212     if (wsource->wioc->rawoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
1213         cond |= G_IO_OUT;
1214     }
1215
1216     return cond & wsource->condition;
1217 }
1218
1219 static gboolean
1220 qio_channel_websock_source_prepare(GSource *source,
1221                                    gint *timeout)
1222 {
1223     *timeout = -1;
1224     return qio_channel_websock_source_check(source);
1225 }
1226
1227 static gboolean
1228 qio_channel_websock_source_dispatch(GSource *source,
1229                                     GSourceFunc callback,
1230                                     gpointer user_data)
1231 {
1232     QIOChannelFunc func = (QIOChannelFunc)callback;
1233     QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
1234
1235     return (*func)(QIO_CHANNEL(wsource->wioc),
1236                    qio_channel_websock_source_check(source),
1237                    user_data);
1238 }
1239
1240 static void
1241 qio_channel_websock_source_finalize(GSource *source)
1242 {
1243     QIOChannelWebsockSource *ssource = (QIOChannelWebsockSource *)source;
1244
1245     object_unref(OBJECT(ssource->wioc));
1246 }
1247
1248 GSourceFuncs qio_channel_websock_source_funcs = {
1249     qio_channel_websock_source_prepare,
1250     qio_channel_websock_source_check,
1251     qio_channel_websock_source_dispatch,
1252     qio_channel_websock_source_finalize
1253 };
1254
1255 static GSource *qio_channel_websock_create_watch(QIOChannel *ioc,
1256                                                  GIOCondition condition)
1257 {
1258     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1259     QIOChannelWebsockSource *ssource;
1260     GSource *source;
1261
1262     source = g_source_new(&qio_channel_websock_source_funcs,
1263                           sizeof(QIOChannelWebsockSource));
1264     ssource = (QIOChannelWebsockSource *)source;
1265
1266     ssource->wioc = wioc;
1267     object_ref(OBJECT(wioc));
1268
1269     ssource->condition = condition;
1270
1271     qio_channel_websock_set_watch(wioc);
1272     return source;
1273 }
1274
1275 static void qio_channel_websock_class_init(ObjectClass *klass,
1276                                            void *class_data G_GNUC_UNUSED)
1277 {
1278     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
1279
1280     ioc_klass->io_writev = qio_channel_websock_writev;
1281     ioc_klass->io_readv = qio_channel_websock_readv;
1282     ioc_klass->io_set_blocking = qio_channel_websock_set_blocking;
1283     ioc_klass->io_set_cork = qio_channel_websock_set_cork;
1284     ioc_klass->io_set_delay = qio_channel_websock_set_delay;
1285     ioc_klass->io_close = qio_channel_websock_close;
1286     ioc_klass->io_shutdown = qio_channel_websock_shutdown;
1287     ioc_klass->io_create_watch = qio_channel_websock_create_watch;
1288 }
1289
1290 static const TypeInfo qio_channel_websock_info = {
1291     .parent = TYPE_QIO_CHANNEL,
1292     .name = TYPE_QIO_CHANNEL_WEBSOCK,
1293     .instance_size = sizeof(QIOChannelWebsock),
1294     .instance_finalize = qio_channel_websock_finalize,
1295     .class_init = qio_channel_websock_class_init,
1296 };
1297
1298 static void qio_channel_websock_register_types(void)
1299 {
1300     type_register_static(&qio_channel_websock_info);
1301 }
1302
1303 type_init(qio_channel_websock_register_types);