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 "io/channel-websock.h"
  24 #include "crypto/hash.h"
  25 #include "trace.h"
  26
  27
  28 /* Max amount to allow in rawinput/rawoutput buffers */
  29 #define QIO_CHANNEL_WEBSOCK_MAX_BUFFER 8192
  30
  31 #define QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN 24
  32 #define QIO_CHANNEL_WEBSOCK_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
  33 #define QIO_CHANNEL_WEBSOCK_GUID_LEN strlen(QIO_CHANNEL_WEBSOCK_GUID)
  34
  35 #define QIO_CHANNEL_WEBSOCK_HEADER_PROTOCOL "Sec-WebSocket-Protocol"
  36 #define QIO_CHANNEL_WEBSOCK_HEADER_VERSION "Sec-WebSocket-Version"
  37 #define QIO_CHANNEL_WEBSOCK_HEADER_KEY "Sec-WebSocket-Key"
  38
  39 #define QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY "binary"
  40
  41 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RESPONSE  \
  42     "HTTP/1.1 101 Switching Protocols\r\n"      \
  43     "Upgrade: websocket\r\n"                    \
  44     "Connection: Upgrade\r\n"                   \
  45     "Sec-WebSocket-Accept: %s\r\n"              \
  46     "Sec-WebSocket-Protocol: binary\r\n"        \
  47     "\r\n"
  48 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM "\r\n"
  49 #define QIO_CHANNEL_WEBSOCK_HANDSHAKE_END "\r\n\r\n"
  50 #define QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION "13"
  51
  52 /* The websockets packet header is variable length
  53  * depending on the size of the payload... */
  54
  55 /* ...length when using 7-bit payload length */
  56 #define QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT 6
  57 /* ...length when using 16-bit payload length */
  58 #define QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT 8
  59 /* ...length when using 64-bit payload length */
  60 #define QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT 14
  61
  62 /* Length of the optional data mask field in header */
  63 #define QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK 4
  64
  65 /* Maximum length that can fit in 7-bit payload size */
  66 #define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT 126
  67 /* Maximum length that can fit in 16-bit payload size */
  68 #define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT 65536
  69
  70 /* Magic 7-bit length to indicate use of 16-bit payload length */
  71 #define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT 126
  72 /* Magic 7-bit length to indicate use of 64-bit payload length */
  73 #define QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT 127
  74
  75 /* Bitmasks & shifts for accessing header fields */
  76 #define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN 0x80
  77 #define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE 0x0f
  78 #define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_HAS_MASK 0x80
  79 #define QIO_CHANNEL_WEBSOCK_HEADER_FIELD_PAYLOAD_LEN 0x7f
  80 #define QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_FIN 7
  81 #define QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_HAS_MASK 7
  82
  83 typedef struct QIOChannelWebsockHeader QIOChannelWebsockHeader;
  84
  85 struct QEMU_PACKED QIOChannelWebsockHeader {
  86     unsigned char b0;
  87     unsigned char b1;
  88     union {
  89         struct QEMU_PACKED {
  90             uint16_t l16;
  91             QIOChannelWebsockMask m16;
  92         } s16;
  93         struct QEMU_PACKED {
  94             uint64_t l64;
  95             QIOChannelWebsockMask m64;
  96         } s64;
  97         QIOChannelWebsockMask m;
  98     } u;
  99 };
 100
 101 enum {
 102     QIO_CHANNEL_WEBSOCK_OPCODE_CONTINUATION = 0x0,
 103     QIO_CHANNEL_WEBSOCK_OPCODE_TEXT_FRAME = 0x1,
 104     QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME = 0x2,
 105     QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE = 0x8,
 106     QIO_CHANNEL_WEBSOCK_OPCODE_PING = 0x9,
 107     QIO_CHANNEL_WEBSOCK_OPCODE_PONG = 0xA
 108 };
 109
 110 static char *qio_channel_websock_handshake_entry(const char *handshake,
 111                                                  size_t handshake_len,
 112                                                  const char *name)
 113 {
 114     char *begin, *end, *ret = NULL;
 115     char *line = g_strdup_printf("%s%s: ",
 116                                  QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM,
 117                                  name);
 118     begin = g_strstr_len(handshake, handshake_len, line);
 119     if (begin != NULL) {
 120         begin += strlen(line);
 121         end = g_strstr_len(begin, handshake_len - (begin - handshake),
 122                 QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
 123         if (end != NULL) {
 124             ret = g_strndup(begin, end - begin);
 125         }
 126     }
 127     g_free(line);
 128     return ret;
 129 }
 130
 131
 132 static int qio_channel_websock_handshake_send_response(QIOChannelWebsock *ioc,
 133                                                        const char *key,
 134                                                        Error **errp)
 135 {
 136     char combined_key[QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
 137                       QIO_CHANNEL_WEBSOCK_GUID_LEN + 1];
 138     char *accept = NULL, *response = NULL;
 139     size_t responselen;
 140
 141     g_strlcpy(combined_key, key, QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN + 1);
 142     g_strlcat(combined_key, QIO_CHANNEL_WEBSOCK_GUID,
 143               QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
 144               QIO_CHANNEL_WEBSOCK_GUID_LEN + 1);
 145
 146     /* hash and encode it */
 147     if (qcrypto_hash_base64(QCRYPTO_HASH_ALG_SHA1,
 148                             combined_key,
 149                             QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
 150                             QIO_CHANNEL_WEBSOCK_GUID_LEN,
 151                             &accept,
 152                             errp) < 0) {
 153         return -1;
 154     }
 155
 156     response = g_strdup_printf(QIO_CHANNEL_WEBSOCK_HANDSHAKE_RESPONSE, accept);
 157     responselen = strlen(response);
 158     buffer_reserve(&ioc->encoutput, responselen);
 159     buffer_append(&ioc->encoutput, response, responselen);
 160
 161     g_free(accept);
 162     g_free(response);
 163
 164     return 0;
 165 }
 166
 167 static int qio_channel_websock_handshake_process(QIOChannelWebsock *ioc,
 168                                                  const char *line,
 169                                                  size_t size,
 170                                                  Error **errp)
 171 {
 172     int ret = -1;
 173     char *protocols = qio_channel_websock_handshake_entry(
 174         line, size, QIO_CHANNEL_WEBSOCK_HEADER_PROTOCOL);
 175     char *version = qio_channel_websock_handshake_entry(
 176         line, size, QIO_CHANNEL_WEBSOCK_HEADER_VERSION);
 177     char *key = qio_channel_websock_handshake_entry(
 178         line, size, QIO_CHANNEL_WEBSOCK_HEADER_KEY);
 179
 180     if (!protocols) {
 181         error_setg(errp, "Missing websocket protocol header data");
 182         goto cleanup;
 183     }
 184
 185     if (!version) {
 186         error_setg(errp, "Missing websocket version header data");
 187         goto cleanup;
 188     }
 189
 190     if (!key) {
 191         error_setg(errp, "Missing websocket key header data");
 192         goto cleanup;
 193     }
 194
 195     if (!g_strrstr(protocols, QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY)) {
 196         error_setg(errp, "No '%s' protocol is supported by client '%s'",
 197                    QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY, protocols);
 198         goto cleanup;
 199     }
 200
 201     if (!g_str_equal(version, QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION)) {
 202         error_setg(errp, "Version '%s' is not supported by client '%s'",
 203                    QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION, version);
 204         goto cleanup;
 205     }
 206
 207     if (strlen(key) != QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN) {
 208         error_setg(errp, "Key length '%zu' was not as expected '%d'",
 209                    strlen(key), QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN);
 210         goto cleanup;
 211     }
 212
 213     ret = qio_channel_websock_handshake_send_response(ioc, key, errp);
 214
 215  cleanup:
 216     g_free(protocols);
 217     g_free(version);
 218     g_free(key);
 219     return ret;
 220 }
 221
 222 static int qio_channel_websock_handshake_read(QIOChannelWebsock *ioc,
 223                                               Error **errp)
 224 {
 225     char *handshake_end;
 226     ssize_t ret;
 227     /* Typical HTTP headers from novnc are 512 bytes, so limiting
 228      * total header size to 4096 is easily enough. */
 229     size_t want = 4096 - ioc->encinput.offset;
 230     buffer_reserve(&ioc->encinput, want);
 231     ret = qio_channel_read(ioc->master,
 232                            (char *)buffer_end(&ioc->encinput), want, errp);
 233     if (ret < 0) {
 234         return -1;
 235     }
 236     ioc->encinput.offset += ret;
 237
 238     handshake_end = g_strstr_len((char *)ioc->encinput.buffer,
 239                                  ioc->encinput.offset,
 240                                  QIO_CHANNEL_WEBSOCK_HANDSHAKE_END);
 241     if (!handshake_end) {
 242         if (ioc->encinput.offset >= 4096) {
 243             error_setg(errp,
 244                        "End of headers not found in first 4096 bytes");
 245             return -1;
 246         } else {
 247             return 0;
 248         }
 249     }
 250
 251     if (qio_channel_websock_handshake_process(ioc,
 252                                               (char *)ioc->encinput.buffer,
 253                                               ioc->encinput.offset,
 254                                               errp) < 0) {
 255         return -1;
 256     }
 257
 258     buffer_advance(&ioc->encinput,
 259                    handshake_end - (char *)ioc->encinput.buffer +
 260                    strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_END));
 261     return 1;
 262 }
 263
 264 static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,
 265                                                    GIOCondition condition,
 266                                                    gpointer user_data)
 267 {
 268     QIOTask *task = user_data;
 269     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
 270         qio_task_get_source(task));
 271     Error *err = NULL;
 272     ssize_t ret;
 273
 274     ret = qio_channel_write(wioc->master,
 275                             (char *)wioc->encoutput.buffer,
 276                             wioc->encoutput.offset,
 277                             &err);
 278
 279     if (ret < 0) {
 280         trace_qio_channel_websock_handshake_fail(ioc);
 281         qio_task_abort(task, err);
 282         error_free(err);
 283         return FALSE;
 284     }
 285
 286     buffer_advance(&wioc->encoutput, ret);
 287     if (wioc->encoutput.offset == 0) {
 288         trace_qio_channel_websock_handshake_complete(ioc);
 289         qio_task_complete(task);
 290         return FALSE;
 291     }
 292     trace_qio_channel_websock_handshake_pending(ioc, G_IO_OUT);
 293     return TRUE;
 294 }
 295
 296 static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc,
 297                                                  GIOCondition condition,
 298                                                  gpointer user_data)
 299 {
 300     QIOTask *task = user_data;
 301     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
 302         qio_task_get_source(task));
 303     Error *err = NULL;
 304     int ret;
 305
 306     ret = qio_channel_websock_handshake_read(wioc, &err);
 307     if (ret < 0) {
 308         trace_qio_channel_websock_handshake_fail(ioc);
 309         qio_task_abort(task, err);
 310         error_free(err);
 311         return FALSE;
 312     }
 313     if (ret == 0) {
 314         trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
 315         /* need more data still */
 316         return TRUE;
 317     }
 318
 319     object_ref(OBJECT(task));
 320     trace_qio_channel_websock_handshake_reply(ioc);
 321     qio_channel_add_watch(
 322         wioc->master,
 323         G_IO_OUT,
 324         qio_channel_websock_handshake_send,
 325         task,
 326         (GDestroyNotify)object_unref);
 327     return FALSE;
 328 }
 329
 330
 331 static void qio_channel_websock_encode(QIOChannelWebsock *ioc)
 332 {
 333     size_t header_size;
 334     union {
 335         char buf[QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT];
 336         QIOChannelWebsockHeader ws;
 337     } header;
 338
 339     if (!ioc->rawoutput.offset) {
 340         return;
 341     }
 342
 343     header.ws.b0 = (1 << QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_FIN) |
 344         (QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME &
 345          QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE);
 346     if (ioc->rawoutput.offset <
 347         QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT) {
 348         header.ws.b1 = (uint8_t)ioc->rawoutput.offset;
 349         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
 350     } else if (ioc->rawoutput.offset <
 351                QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT) {
 352         header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT;
 353         header.ws.u.s16.l16 = cpu_to_be16((uint16_t)ioc->rawoutput.offset);
 354         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
 355     } else {
 356         header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT;
 357         header.ws.u.s64.l64 = cpu_to_be64(ioc->rawoutput.offset);
 358         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
 359     }
 360     header_size -= QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK;
 361
 362     buffer_reserve(&ioc->encoutput, header_size + ioc->rawoutput.offset);
 363     buffer_append(&ioc->encoutput, header.buf, header_size);
 364     buffer_append(&ioc->encoutput, ioc->rawoutput.buffer,
 365                   ioc->rawoutput.offset);
 366     buffer_reset(&ioc->rawoutput);
 367 }
 368
 369
 370 static ssize_t qio_channel_websock_decode_header(QIOChannelWebsock *ioc,
 371                                                  Error **errp)
 372 {
 373     unsigned char opcode, fin, has_mask;
 374     size_t header_size;
 375     size_t payload_len;
 376     QIOChannelWebsockHeader *header =
 377         (QIOChannelWebsockHeader *)ioc->encinput.buffer;
 378
 379     if (ioc->payload_remain) {
 380         error_setg(errp,
 381                    "Decoding header but %zu bytes of payload remain",
 382                    ioc->payload_remain);
 383         return -1;
 384     }
 385     if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT) {
 386         /* header not complete */
 387         return QIO_CHANNEL_ERR_BLOCK;
 388     }
 389
 390     fin = (header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN) >>
 391         QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_FIN;
 392     opcode = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE;
 393     has_mask = (header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_HAS_MASK) >>
 394         QIO_CHANNEL_WEBSOCK_HEADER_SHIFT_HAS_MASK;
 395     payload_len = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_PAYLOAD_LEN;
 396
 397     if (opcode == QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE) {
 398         /* disconnect */
 399         return 0;
 400     }
 401
 402     /* Websocket frame sanity check:
 403      * * Websocket fragmentation is not supported.
 404      * * All  websockets frames sent by a client have to be masked.
 405      * * Only binary encoding is supported.
 406      */
 407     if (!fin) {
 408         error_setg(errp, "websocket fragmentation is not supported");
 409         return -1;
 410     }
 411     if (!has_mask) {
 412         error_setg(errp, "websocket frames must be masked");
 413         return -1;
 414     }
 415     if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
 416         error_setg(errp, "only binary websocket frames are supported");
 417         return -1;
 418     }
 419
 420     if (payload_len < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT) {
 421         ioc->payload_remain = payload_len;
 422         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
 423         ioc->mask = header->u.m;
 424     } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT &&
 425                ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT) {
 426         ioc->payload_remain = be16_to_cpu(header->u.s16.l16);
 427         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
 428         ioc->mask = header->u.s16.m16;
 429     } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT &&
 430                ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT) {
 431         ioc->payload_remain = be64_to_cpu(header->u.s64.l64);
 432         header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
 433         ioc->mask = header->u.s64.m64;
 434     } else {
 435         /* header not complete */
 436         return QIO_CHANNEL_ERR_BLOCK;
 437     }
 438
 439     buffer_advance(&ioc->encinput, header_size);
 440     return 1;
 441 }
 442
 443
 444 static ssize_t qio_channel_websock_decode_payload(QIOChannelWebsock *ioc,
 445                                                   Error **errp)
 446 {
 447     size_t i;
 448     size_t payload_len;
 449     uint32_t *payload32;
 450
 451     if (!ioc->payload_remain) {
 452         error_setg(errp,
 453                    "Decoding payload but no bytes of payload remain");
 454         return -1;
 455     }
 456
 457     /* If we aren't at the end of the payload, then drop
 458      * off the last bytes, so we're always multiple of 4
 459      * for purpose of unmasking, except at end of payload
 460      */
 461     if (ioc->encinput.offset < ioc->payload_remain) {
 462         payload_len = ioc->encinput.offset - (ioc->encinput.offset % 4);
 463     } else {
 464         payload_len = ioc->payload_remain;
 465     }
 466     if (payload_len == 0) {
 467         return QIO_CHANNEL_ERR_BLOCK;
 468     }
 469
 470     ioc->payload_remain -= payload_len;
 471
 472     /* unmask frame */
 473     /* process 1 frame (32 bit op) */
 474     payload32 = (uint32_t *)ioc->encinput.buffer;
 475     for (i = 0; i < payload_len / 4; i++) {
 476         payload32[i] ^= ioc->mask.u;
 477     }
 478     /* process the remaining bytes (if any) */
 479     for (i *= 4; i < payload_len; i++) {
 480         ioc->encinput.buffer[i] ^= ioc->mask.c[i % 4];
 481     }
 482
 483     buffer_reserve(&ioc->rawinput, payload_len);
 484     buffer_append(&ioc->rawinput, ioc->encinput.buffer, payload_len);
 485     buffer_advance(&ioc->encinput, payload_len);
 486     return payload_len;
 487 }
 488
 489
 490 QIOChannelWebsock *
 491 qio_channel_websock_new_server(QIOChannel *master)
 492 {
 493     QIOChannelWebsock *wioc;
 494     QIOChannel *ioc;
 495
 496     wioc = QIO_CHANNEL_WEBSOCK(object_new(TYPE_QIO_CHANNEL_WEBSOCK));
 497     ioc = QIO_CHANNEL(wioc);
 498
 499     wioc->master = master;
 500     if (master->features & (1 << QIO_CHANNEL_FEATURE_SHUTDOWN)) {
 501         ioc->features |= (1 << QIO_CHANNEL_FEATURE_SHUTDOWN);
 502     }
 503     object_ref(OBJECT(master));
 504
 505     trace_qio_channel_websock_new_server(wioc, master);
 506     return wioc;
 507 }
 508
 509 void qio_channel_websock_handshake(QIOChannelWebsock *ioc,
 510                                    QIOTaskFunc func,
 511                                    gpointer opaque,
 512                                    GDestroyNotify destroy)
 513 {
 514     QIOTask *task;
 515
 516     task = qio_task_new(OBJECT(ioc),
 517                         func,
 518                         opaque,
 519                         destroy);
 520
 521     trace_qio_channel_websock_handshake_start(ioc);
 522     trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
 523     qio_channel_add_watch(ioc->master,
 524                           G_IO_IN,
 525                           qio_channel_websock_handshake_io,
 526                           task,
 527                           NULL);
 528 }
 529
 530
 531 static void qio_channel_websock_finalize(Object *obj)
 532 {
 533     QIOChannelWebsock *ioc = QIO_CHANNEL_WEBSOCK(obj);
 534
 535     buffer_free(&ioc->encinput);
 536     buffer_free(&ioc->encoutput);
 537     buffer_free(&ioc->rawinput);
 538     buffer_free(&ioc->rawoutput);
 539     object_unref(OBJECT(ioc->master));
 540     if (ioc->io_tag) {
 541         g_source_remove(ioc->io_tag);
 542     }
 543     if (ioc->io_err) {
 544         error_free(ioc->io_err);
 545     }
 546 }
 547
 548
 549 static ssize_t qio_channel_websock_read_wire(QIOChannelWebsock *ioc,
 550                                              Error **errp)
 551 {
 552     ssize_t ret;
 553
 554     if (ioc->encinput.offset < 4096) {
 555         size_t want = 4096 - ioc->encinput.offset;
 556
 557         buffer_reserve(&ioc->encinput, want);
 558         ret = qio_channel_read(ioc->master,
 559                                (char *)ioc->encinput.buffer +
 560                                ioc->encinput.offset,
 561                                want,
 562                                errp);
 563         if (ret < 0) {
 564             return ret;
 565         }
 566         if (ret == 0 &&
 567             ioc->encinput.offset == 0) {
 568             return 0;
 569         }
 570         ioc->encinput.offset += ret;
 571     }
 572
 573     if (ioc->payload_remain == 0) {
 574         ret = qio_channel_websock_decode_header(ioc, errp);
 575         if (ret < 0) {
 576             return ret;
 577         }
 578         if (ret == 0) {
 579             return 0;
 580         }
 581     }
 582
 583     ret = qio_channel_websock_decode_payload(ioc, errp);
 584     if (ret < 0) {
 585         return ret;
 586     }
 587     return ret;
 588 }
 589
 590
 591 static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *ioc,
 592                                               Error **errp)
 593 {
 594     ssize_t ret;
 595     ssize_t done = 0;
 596     qio_channel_websock_encode(ioc);
 597
 598     while (ioc->encoutput.offset > 0) {
 599         ret = qio_channel_write(ioc->master,
 600                                 (char *)ioc->encoutput.buffer,
 601                                 ioc->encoutput.offset,
 602                                 errp);
 603         if (ret < 0) {
 604             if (ret == QIO_CHANNEL_ERR_BLOCK &&
 605                 done > 0) {
 606                 return done;
 607             } else {
 608                 return ret;
 609             }
 610         }
 611         buffer_advance(&ioc->encoutput, ret);
 612         done += ret;
 613     }
 614     return done;
 615 }
 616
 617
 618 static void qio_channel_websock_flush_free(gpointer user_data)
 619 {
 620     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
 621     object_unref(OBJECT(wioc));
 622 }
 623
 624 static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc);
 625
 626 static gboolean qio_channel_websock_flush(QIOChannel *ioc,
 627                                           GIOCondition condition,
 628                                           gpointer user_data)
 629 {
 630     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
 631     ssize_t ret;
 632
 633     if (condition & G_IO_OUT) {
 634         ret = qio_channel_websock_write_wire(wioc, &wioc->io_err);
 635         if (ret < 0) {
 636             goto cleanup;
 637         }
 638     }
 639
 640     if (condition & G_IO_IN) {
 641         ret = qio_channel_websock_read_wire(wioc, &wioc->io_err);
 642         if (ret < 0) {
 643             goto cleanup;
 644         }
 645         if (ret == 0) {
 646             wioc->io_eof = TRUE;
 647         }
 648     }
 649
 650  cleanup:
 651     qio_channel_websock_set_watch(wioc);
 652     return FALSE;
 653 }
 654
 655
 656 static void qio_channel_websock_unset_watch(QIOChannelWebsock *ioc)
 657 {
 658     if (ioc->io_tag) {
 659         g_source_remove(ioc->io_tag);
 660         ioc->io_tag = 0;
 661     }
 662 }
 663
 664 static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc)
 665 {
 666     GIOCondition cond = 0;
 667
 668     qio_channel_websock_unset_watch(ioc);
 669
 670     if (ioc->io_err) {
 671         return;
 672     }
 673
 674     if (ioc->encoutput.offset) {
 675         cond |= G_IO_OUT;
 676     }
 677     if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER &&
 678         !ioc->io_eof) {
 679         cond |= G_IO_IN;
 680     }
 681
 682     if (cond) {
 683         object_ref(OBJECT(ioc));
 684         ioc->io_tag =
 685             qio_channel_add_watch(ioc->master,
 686                                   cond,
 687                                   qio_channel_websock_flush,
 688                                   ioc,
 689                                   qio_channel_websock_flush_free);
 690     }
 691 }
 692
 693
 694 static ssize_t qio_channel_websock_readv(QIOChannel *ioc,
 695                                          const struct iovec *iov,
 696                                          size_t niov,
 697                                          int **fds,
 698                                          size_t *nfds,
 699                                          Error **errp)
 700 {
 701     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
 702     size_t i;
 703     ssize_t got = 0;
 704     ssize_t ret;
 705
 706     if (wioc->io_err) {
 707         *errp = error_copy(wioc->io_err);
 708         return -1;
 709     }
 710
 711     if (!wioc->rawinput.offset) {
 712         ret = qio_channel_websock_read_wire(QIO_CHANNEL_WEBSOCK(ioc), errp);
 713         if (ret < 0) {
 714             return ret;
 715         }
 716     }
 717
 718     for (i = 0 ; i < niov ; i++) {
 719         size_t want = iov[i].iov_len;
 720         if (want > (wioc->rawinput.offset - got)) {
 721             want = (wioc->rawinput.offset - got);
 722         }
 723
 724         memcpy(iov[i].iov_base,
 725                wioc->rawinput.buffer + got,
 726                want);
 727         got += want;
 728
 729         if (want < iov[i].iov_len) {
 730             break;
 731         }
 732     }
 733
 734     buffer_advance(&wioc->rawinput, got);
 735     qio_channel_websock_set_watch(wioc);
 736     return got;
 737 }
 738
 739
 740 static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
 741                                           const struct iovec *iov,
 742                                           size_t niov,
 743                                           int *fds,
 744                                           size_t nfds,
 745                                           Error **errp)
 746 {
 747     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
 748     size_t i;
 749     ssize_t done = 0;
 750     ssize_t ret;
 751
 752     if (wioc->io_err) {
 753         *errp = error_copy(wioc->io_err);
 754         return -1;
 755     }
 756
 757     if (wioc->io_eof) {
 758         error_setg(errp, "%s", "Broken pipe");
 759         return -1;
 760     }
 761
 762     for (i = 0; i < niov; i++) {
 763         size_t want = iov[i].iov_len;
 764         if ((want + wioc->rawoutput.offset) > QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
 765             want = (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->rawoutput.offset);
 766         }
 767         if (want == 0) {
 768             goto done;
 769         }
 770
 771         buffer_reserve(&wioc->rawoutput, want);
 772         buffer_append(&wioc->rawoutput, iov[i].iov_base, want);
 773         done += want;
 774         if (want < iov[i].iov_len) {
 775             break;
 776         }
 777     }
 778
 779  done:
 780     ret = qio_channel_websock_write_wire(wioc, errp);
 781     if (ret < 0 &&
 782         ret != QIO_CHANNEL_ERR_BLOCK) {
 783         qio_channel_websock_unset_watch(wioc);
 784         return -1;
 785     }
 786
 787     qio_channel_websock_set_watch(wioc);
 788
 789     if (done == 0) {
 790         return QIO_CHANNEL_ERR_BLOCK;
 791     }
 792
 793     return done;
 794 }
 795
 796 static int qio_channel_websock_set_blocking(QIOChannel *ioc,
 797                                             bool enabled,
 798                                             Error **errp)
 799 {
 800     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
 801
 802     qio_channel_set_blocking(wioc->master, enabled, errp);
 803     return 0;
 804 }
 805
 806 static void qio_channel_websock_set_delay(QIOChannel *ioc,
 807                                           bool enabled)
 808 {
 809     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
 810
 811     qio_channel_set_delay(tioc->master, enabled);
 812 }
 813
 814 static void qio_channel_websock_set_cork(QIOChannel *ioc,
 815                                          bool enabled)
 816 {
 817     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
 818
 819     qio_channel_set_cork(tioc->master, enabled);
 820 }
 821
 822 static int qio_channel_websock_shutdown(QIOChannel *ioc,
 823                                         QIOChannelShutdown how,
 824                                         Error **errp)
 825 {
 826     QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
 827
 828     return qio_channel_shutdown(tioc->master, how, errp);
 829 }
 830
 831 static int qio_channel_websock_close(QIOChannel *ioc,
 832                                      Error **errp)
 833 {
 834     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
 835
 836     return qio_channel_close(wioc->master, errp);
 837 }
 838
 839 typedef struct QIOChannelWebsockSource QIOChannelWebsockSource;
 840 struct QIOChannelWebsockSource {
 841     GSource parent;
 842     QIOChannelWebsock *wioc;
 843     GIOCondition condition;
 844 };
 845
 846 static gboolean
 847 qio_channel_websock_source_prepare(GSource *source,
 848                                    gint *timeout)
 849 {
 850     QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
 851     GIOCondition cond = 0;
 852     *timeout = -1;
 853
 854     if (wsource->wioc->rawinput.offset) {
 855         cond |= G_IO_IN;
 856     }
 857     if (wsource->wioc->rawoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
 858         cond |= G_IO_OUT;
 859     }
 860
 861     return cond & wsource->condition;
 862 }
 863
 864 static gboolean
 865 qio_channel_websock_source_check(GSource *source)
 866 {
 867     QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
 868     GIOCondition cond = 0;
 869
 870     if (wsource->wioc->rawinput.offset) {
 871         cond |= G_IO_IN;
 872     }
 873     if (wsource->wioc->rawoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
 874         cond |= G_IO_OUT;
 875     }
 876
 877     return cond & wsource->condition;
 878 }
 879
 880 static gboolean
 881 qio_channel_websock_source_dispatch(GSource *source,
 882                                     GSourceFunc callback,
 883                                     gpointer user_data)
 884 {
 885     QIOChannelFunc func = (QIOChannelFunc)callback;
 886     QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
 887     GIOCondition cond = 0;
 888
 889     if (wsource->wioc->rawinput.offset) {
 890         cond |= G_IO_IN;
 891     }
 892     if (wsource->wioc->rawoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
 893         cond |= G_IO_OUT;
 894     }
 895
 896     return (*func)(QIO_CHANNEL(wsource->wioc),
 897                    (cond & wsource->condition),
 898                    user_data);
 899 }
 900
 901 static void
 902 qio_channel_websock_source_finalize(GSource *source)
 903 {
 904     QIOChannelWebsockSource *ssource = (QIOChannelWebsockSource *)source;
 905
 906     object_unref(OBJECT(ssource->wioc));
 907 }
 908
 909 GSourceFuncs qio_channel_websock_source_funcs = {
 910     qio_channel_websock_source_prepare,
 911     qio_channel_websock_source_check,
 912     qio_channel_websock_source_dispatch,
 913     qio_channel_websock_source_finalize
 914 };
 915
 916 static GSource *qio_channel_websock_create_watch(QIOChannel *ioc,
 917                                                  GIOCondition condition)
 918 {
 919     QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
 920     QIOChannelWebsockSource *ssource;
 921     GSource *source;
 922
 923     source = g_source_new(&qio_channel_websock_source_funcs,
 924                           sizeof(QIOChannelWebsockSource));
 925     ssource = (QIOChannelWebsockSource *)source;
 926
 927     ssource->wioc = wioc;
 928     object_ref(OBJECT(wioc));
 929
 930     ssource->condition = condition;
 931
 932     qio_channel_websock_set_watch(wioc);
 933     return source;
 934 }
 935
 936 static void qio_channel_websock_class_init(ObjectClass *klass,
 937                                            void *class_data G_GNUC_UNUSED)
 938 {
 939     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
 940
 941     ioc_klass->io_writev = qio_channel_websock_writev;
 942     ioc_klass->io_readv = qio_channel_websock_readv;
 943     ioc_klass->io_set_blocking = qio_channel_websock_set_blocking;
 944     ioc_klass->io_set_cork = qio_channel_websock_set_cork;
 945     ioc_klass->io_set_delay = qio_channel_websock_set_delay;
 946     ioc_klass->io_close = qio_channel_websock_close;
 947     ioc_klass->io_shutdown = qio_channel_websock_shutdown;
 948     ioc_klass->io_create_watch = qio_channel_websock_create_watch;
 949 }
 950
 951 static const TypeInfo qio_channel_websock_info = {
 952     .parent = TYPE_QIO_CHANNEL,
 953     .name = TYPE_QIO_CHANNEL_WEBSOCK,
 954     .instance_size = sizeof(QIOChannelWebsock),
 955     .instance_finalize = qio_channel_websock_finalize,
 956     .class_init = qio_channel_websock_class_init,
 957 };
 958
 959 static void qio_channel_websock_register_types(void)
 960 {
 961     type_register_static(&qio_channel_websock_info);
 962 }
 963
 964 type_init(qio_channel_websock_register_types);