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