qemu

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 (sizeof(QIO_CHANNEL_WEBSOCK_GUID) - 1)
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 G_GNUC_PRINTF(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
    g_autoptr(GDateTime) now = g_date_time_new_now_utc();
181

182
    return g_date_time_format(now, "%a, %d %b %Y %H:%M:%S GMT");
183
}
184

185
static void qio_channel_websock_handshake_send_res_err(QIOChannelWebsock *ioc,
186
                                                       const char *resdata)
187
{
188
    char *date = qio_channel_websock_date_str();
189
    qio_channel_websock_handshake_send_res(ioc, resdata, date);
190
    g_free(date);
191
}
192

193
enum {
194
    QIO_CHANNEL_WEBSOCK_STATUS_NORMAL = 1000,
195
    QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR = 1002,
196
    QIO_CHANNEL_WEBSOCK_STATUS_INVALID_DATA = 1003,
197
    QIO_CHANNEL_WEBSOCK_STATUS_POLICY = 1008,
198
    QIO_CHANNEL_WEBSOCK_STATUS_TOO_LARGE = 1009,
199
    QIO_CHANNEL_WEBSOCK_STATUS_SERVER_ERR = 1011,
200
};
201

202
static size_t
203
qio_channel_websock_extract_headers(QIOChannelWebsock *ioc,
204
                                    char *buffer,
205
                                    QIOChannelWebsockHTTPHeader *hdrs,
206
                                    size_t nhdrsalloc,
207
                                    Error **errp)
208
{
209
    char *nl, *sep, *tmp;
210
    size_t nhdrs = 0;
211

212
    /*
213
     * First parse the HTTP protocol greeting of format:
214
     *
215
     *   $METHOD $PATH $VERSION
216
     *
217
     * e.g.
218
     *
219
     *   GET / HTTP/1.1
220
     */
221

222
    nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
223
    if (!nl) {
224
        error_setg(errp, "Missing HTTP header delimiter");
225
        goto bad_request;
226
    }
227
    *nl = '\0';
228
    trace_qio_channel_websock_http_greeting(ioc, buffer);
229

230
    tmp = strchr(buffer, ' ');
231
    if (!tmp) {
232
        error_setg(errp, "Missing HTTP path delimiter");
233
        return 0;
234
    }
235
    *tmp = '\0';
236

237
    if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_METHOD)) {
238
        error_setg(errp, "Unsupported HTTP method %s", buffer);
239
        goto bad_request;
240
    }
241

242
    buffer = tmp + 1;
243
    tmp = strchr(buffer, ' ');
244
    if (!tmp) {
245
        error_setg(errp, "Missing HTTP version delimiter");
246
        goto bad_request;
247
    }
248
    *tmp = '\0';
249

250
    if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_PATH)) {
251
        qio_channel_websock_handshake_send_res_err(
252
            ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_NOT_FOUND);
253
        error_setg(errp, "Unexpected HTTP path %s", buffer);
254
        return 0;
255
    }
256

257
    buffer = tmp + 1;
258

259
    if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_VERSION)) {
260
        error_setg(errp, "Unsupported HTTP version %s", buffer);
261
        goto bad_request;
262
    }
263

264
    buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
265

266
    /*
267
     * Now parse all the header fields of format
268
     *
269
     *   $NAME: $VALUE
270
     *
271
     * e.g.
272
     *
273
     *   Cache-control: no-cache
274
     */
275
    do {
276
        QIOChannelWebsockHTTPHeader *hdr;
277

278
        nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
279
        if (nl) {
280
            *nl = '\0';
281
        }
282

283
        sep = strchr(buffer, ':');
284
        if (!sep) {
285
            error_setg(errp, "Malformed HTTP header");
286
            goto bad_request;
287
        }
288
        *sep = '\0';
289
        sep++;
290
        while (*sep == ' ') {
291
            sep++;
292
        }
293

294
        if (nhdrs >= nhdrsalloc) {
295
            error_setg(errp, "Too many HTTP headers");
296
            goto bad_request;
297
        }
298

299
        hdr = &hdrs[nhdrs++];
300
        hdr->name = buffer;
301
        hdr->value = sep;
302

303
        /* Canonicalize header name for easier identification later */
304
        for (tmp = hdr->name; *tmp; tmp++) {
305
            *tmp = g_ascii_tolower(*tmp);
306
        }
307

308
        if (nl) {
309
            buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
310
        }
311
    } while (nl != NULL);
312

313
    return nhdrs;
314

315
 bad_request:
316
    qio_channel_websock_handshake_send_res_err(
317
        ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_BAD_REQUEST);
318
    return 0;
319
}
320

321
static const char *
322
qio_channel_websock_find_header(QIOChannelWebsockHTTPHeader *hdrs,
323
                                size_t nhdrs,
324
                                const char *name)
325
{
326
    size_t i;
327

328
    for (i = 0; i < nhdrs; i++) {
329
        if (g_str_equal(hdrs[i].name, name)) {
330
            return hdrs[i].value;
331
        }
332
    }
333

334
    return NULL;
335
}
336

337

338
static void qio_channel_websock_handshake_send_res_ok(QIOChannelWebsock *ioc,
339
                                                      const char *key,
340
                                                      const bool use_protocols,
341
                                                      Error **errp)
342
{
343
    char combined_key[QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
344
                      QIO_CHANNEL_WEBSOCK_GUID_LEN + 1];
345
    char *accept = NULL;
346
    char *date = NULL;
347

348
    g_strlcpy(combined_key, key, QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN + 1);
349
    g_strlcat(combined_key, QIO_CHANNEL_WEBSOCK_GUID,
350
              QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
351
              QIO_CHANNEL_WEBSOCK_GUID_LEN + 1);
352

353
    /* hash and encode it */
354
    if (qcrypto_hash_base64(QCRYPTO_HASH_ALG_SHA1,
355
                            combined_key,
356
                            QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
357
                            QIO_CHANNEL_WEBSOCK_GUID_LEN,
358
                            &accept,
359
                            errp) < 0) {
360
        qio_channel_websock_handshake_send_res_err(
361
            ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_SERVER_ERR);
362
        return;
363
    }
364

365
    date = qio_channel_websock_date_str();
366
    if (use_protocols) {
367
            qio_channel_websock_handshake_send_res(
368
                ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_WITH_PROTO_RES_OK,
369
                date, accept);
370
    } else {
371
            qio_channel_websock_handshake_send_res(
372
                ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_OK, date, accept);
373
    }
374

375
    g_free(date);
376
    g_free(accept);
377
}
378

379
static void qio_channel_websock_handshake_process(QIOChannelWebsock *ioc,
380
                                                  char *buffer,
381
                                                  Error **errp)
382
{
383
    QIOChannelWebsockHTTPHeader hdrs[32];
384
    size_t nhdrs = G_N_ELEMENTS(hdrs);
385
    const char *protocols = NULL, *version = NULL, *key = NULL,
386
        *host = NULL, *connection = NULL, *upgrade = NULL;
387
    char **connectionv;
388
    bool upgraded = false;
389
    size_t i;
390

391
    nhdrs = qio_channel_websock_extract_headers(ioc, buffer, hdrs, nhdrs, errp);
392
    if (!nhdrs) {
393
        return;
394
    }
395

396
    protocols = qio_channel_websock_find_header(
397
        hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_PROTOCOL);
398

399
    version = qio_channel_websock_find_header(
400
        hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_VERSION);
401
    if (!version) {
402
        error_setg(errp, "Missing websocket version header data");
403
        goto bad_request;
404
    }
405

406
    key = qio_channel_websock_find_header(
407
        hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_KEY);
408
    if (!key) {
409
        error_setg(errp, "Missing websocket key header data");
410
        goto bad_request;
411
    }
412

413
    host = qio_channel_websock_find_header(
414
        hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_HOST);
415
    if (!host) {
416
        error_setg(errp, "Missing websocket host header data");
417
        goto bad_request;
418
    }
419

420
    connection = qio_channel_websock_find_header(
421
        hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_CONNECTION);
422
    if (!connection) {
423
        error_setg(errp, "Missing websocket connection header data");
424
        goto bad_request;
425
    }
426

427
    upgrade = qio_channel_websock_find_header(
428
        hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_UPGRADE);
429
    if (!upgrade) {
430
        error_setg(errp, "Missing websocket upgrade header data");
431
        goto bad_request;
432
    }
433

434
    trace_qio_channel_websock_http_request(ioc, protocols, version,
435
                                           host, connection, upgrade, key);
436

437
    if (protocols) {
438
            if (!g_strrstr(protocols, QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY)) {
439
                error_setg(errp, "No '%s' protocol is supported by client '%s'",
440
                           QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY, protocols);
441
                goto bad_request;
442
            }
443
    }
444

445
    if (!g_str_equal(version, QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION)) {
446
        error_setg(errp, "Version '%s' is not supported by client '%s'",
447
                   QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION, version);
448
        goto bad_request;
449
    }
450

451
    if (strlen(key) != QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN) {
452
        error_setg(errp, "Key length '%zu' was not as expected '%d'",
453
                   strlen(key), QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN);
454
        goto bad_request;
455
    }
456

457
    connectionv = g_strsplit(connection, ",", 0);
458
    for (i = 0; connectionv != NULL && connectionv[i] != NULL; i++) {
459
        g_strstrip(connectionv[i]);
460
        if (strcasecmp(connectionv[i],
461
                       QIO_CHANNEL_WEBSOCK_CONNECTION_UPGRADE) == 0) {
462
            upgraded = true;
463
        }
464
    }
465
    g_strfreev(connectionv);
466
    if (!upgraded) {
467
        error_setg(errp, "No connection upgrade requested '%s'", connection);
468
        goto bad_request;
469
    }
470

471
    if (strcasecmp(upgrade, QIO_CHANNEL_WEBSOCK_UPGRADE_WEBSOCKET) != 0) {
472
        error_setg(errp, "Incorrect upgrade method '%s'", upgrade);
473
        goto bad_request;
474
    }
475

476
    qio_channel_websock_handshake_send_res_ok(ioc, key, !!protocols, errp);
477
    return;
478

479
 bad_request:
480
    qio_channel_websock_handshake_send_res_err(
481
        ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_BAD_REQUEST);
482
}
483

484
static int qio_channel_websock_handshake_read(QIOChannelWebsock *ioc,
485
                                              Error **errp)
486
{
487
    char *handshake_end;
488
    ssize_t ret;
489
    /* Typical HTTP headers from novnc are 512 bytes, so limiting
490
     * total header size to 4096 is easily enough. */
491
    size_t want = 4096 - ioc->encinput.offset;
492
    buffer_reserve(&ioc->encinput, want);
493
    ret = qio_channel_read(ioc->master,
494
                           (char *)buffer_end(&ioc->encinput), want, errp);
495
    if (ret < 0) {
496
        return -1;
497
    }
498
    ioc->encinput.offset += ret;
499

500
    handshake_end = g_strstr_len((char *)ioc->encinput.buffer,
501
                                 ioc->encinput.offset,
502
                                 QIO_CHANNEL_WEBSOCK_HANDSHAKE_END);
503
    if (!handshake_end) {
504
        if (ioc->encinput.offset >= 4096) {
505
            qio_channel_websock_handshake_send_res_err(
506
                ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_TOO_LARGE);
507
            error_setg(errp,
508
                       "End of headers not found in first 4096 bytes");
509
            return 1;
510
        } else if (ret == 0) {
511
            error_setg(errp,
512
                       "End of headers not found before connection closed");
513
            return -1;
514
        }
515
        return 0;
516
    }
517
    *handshake_end = '\0';
518

519
    qio_channel_websock_handshake_process(ioc,
520
                                          (char *)ioc->encinput.buffer,
521
                                          errp);
522

523
    buffer_advance(&ioc->encinput,
524
                   handshake_end - (char *)ioc->encinput.buffer +
525
                   strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_END));
526
    return 1;
527
}
528

529
static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,
530
                                                   GIOCondition condition,
531
                                                   gpointer user_data)
532
{
533
    QIOTask *task = user_data;
534
    QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
535
        qio_task_get_source(task));
536
    Error *err = NULL;
537
    ssize_t ret;
538

539
    ret = qio_channel_write(wioc->master,
540
                            (char *)wioc->encoutput.buffer,
541
                            wioc->encoutput.offset,
542
                            &err);
543

544
    if (ret < 0) {
545
        trace_qio_channel_websock_handshake_fail(ioc, error_get_pretty(err));
546
        qio_task_set_error(task, err);
547
        qio_task_complete(task);
548
        return FALSE;
549
    }
550

551
    buffer_advance(&wioc->encoutput, ret);
552
    if (wioc->encoutput.offset == 0) {
553
        if (wioc->io_err) {
554
            trace_qio_channel_websock_handshake_fail(
555
                ioc, error_get_pretty(wioc->io_err));
556
            qio_task_set_error(task, wioc->io_err);
557
            wioc->io_err = NULL;
558
            qio_task_complete(task);
559
        } else {
560
            trace_qio_channel_websock_handshake_complete(ioc);
561
            qio_task_complete(task);
562
        }
563
        return FALSE;
564
    }
565
    trace_qio_channel_websock_handshake_pending(ioc, G_IO_OUT);
566
    return TRUE;
567
}
568

569
static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc,
570
                                                 GIOCondition condition,
571
                                                 gpointer user_data)
572
{
573
    QIOTask *task = user_data;
574
    QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(
575
        qio_task_get_source(task));
576
    Error *err = NULL;
577
    int ret;
578

579
    ret = qio_channel_websock_handshake_read(wioc, &err);
580
    if (ret < 0) {
581
        /*
582
         * We only take this path on a fatal I/O error reading from
583
         * client connection, as most of the time we have an
584
         * HTTP 4xx err response to send instead
585
         */
586
        trace_qio_channel_websock_handshake_fail(ioc, error_get_pretty(err));
587
        qio_task_set_error(task, err);
588
        qio_task_complete(task);
589
        return FALSE;
590
    }
591
    if (ret == 0) {
592
        trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
593
        /* need more data still */
594
        return TRUE;
595
    }
596

597
    error_propagate(&wioc->io_err, err);
598

599
    trace_qio_channel_websock_handshake_reply(ioc);
600
    qio_channel_add_watch(
601
        wioc->master,
602
        G_IO_OUT,
603
        qio_channel_websock_handshake_send,
604
        task,
605
        NULL);
606
    return FALSE;
607
}
608

609

610
static void qio_channel_websock_encode(QIOChannelWebsock *ioc,
611
                                       uint8_t opcode,
612
                                       const struct iovec *iov,
613
                                       size_t niov,
614
                                       size_t size)
615
{
616
    size_t header_size;
617
    size_t i;
618
    union {
619
        char buf[QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT];
620
        QIOChannelWebsockHeader ws;
621
    } header;
622

623
    assert(size <= iov_size(iov, niov));
624

625
    header.ws.b0 = QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN |
626
        (opcode & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE);
627
    if (size < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT) {
628
        header.ws.b1 = (uint8_t)size;
629
        header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
630
    } else if (size < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT) {
631
        header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT;
632
        header.ws.u.s16.l16 = cpu_to_be16((uint16_t)size);
633
        header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
634
    } else {
635
        header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT;
636
        header.ws.u.s64.l64 = cpu_to_be64(size);
637
        header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
638
    }
639
    header_size -= QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK;
640

641
    trace_qio_channel_websock_encode(ioc, opcode, header_size, size);
642
    buffer_reserve(&ioc->encoutput, header_size + size);
643
    buffer_append(&ioc->encoutput, header.buf, header_size);
644
    for (i = 0; i < niov && size != 0; i++) {
645
        size_t want = iov[i].iov_len;
646
        if (want > size) {
647
            want = size;
648
        }
649
        buffer_append(&ioc->encoutput, iov[i].iov_base, want);
650
        size -= want;
651
    }
652
}
653

654

655
static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *, Error **);
656

657

658
static void qio_channel_websock_write_close(QIOChannelWebsock *ioc,
659
                                            uint16_t code, const char *reason)
660
{
661
    struct iovec iov[2] = {
662
        { .iov_base = &code, .iov_len = sizeof(code) },
663
    };
664
    size_t niov = 1;
665
    size_t size = iov[0].iov_len;
666

667
    cpu_to_be16s(&code);
668

669
    if (reason) {
670
        iov[1].iov_base = (void *)reason;
671
        iov[1].iov_len = strlen(reason);
672
        size += iov[1].iov_len;
673
        niov++;
674
    }
675
    qio_channel_websock_encode(ioc, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
676
                               iov, niov, size);
677
    qio_channel_websock_write_wire(ioc, NULL);
678
    qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
679
}
680

681

682
static int qio_channel_websock_decode_header(QIOChannelWebsock *ioc,
683
                                             Error **errp)
684
{
685
    unsigned char opcode, fin, has_mask;
686
    size_t header_size;
687
    size_t payload_len;
688
    QIOChannelWebsockHeader *header =
689
        (QIOChannelWebsockHeader *)ioc->encinput.buffer;
690

691
    if (ioc->payload_remain) {
692
        error_setg(errp,
693
                   "Decoding header but %zu bytes of payload remain",
694
                   ioc->payload_remain);
695
        qio_channel_websock_write_close(
696
            ioc, QIO_CHANNEL_WEBSOCK_STATUS_SERVER_ERR,
697
            "internal server error");
698
        return -1;
699
    }
700
    if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT) {
701
        /* header not complete */
702
        return QIO_CHANNEL_ERR_BLOCK;
703
    }
704

705
    fin = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN;
706
    opcode = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE;
707
    has_mask = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_HAS_MASK;
708
    payload_len = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_PAYLOAD_LEN;
709

710
    /* Save or restore opcode. */
711
    if (opcode) {
712
        ioc->opcode = opcode;
713
    } else {
714
        opcode = ioc->opcode;
715
    }
716

717
    trace_qio_channel_websock_header_partial_decode(ioc, payload_len,
718
                                                    fin, opcode, (int)has_mask);
719

720
    if (opcode == QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE) {
721
        /* disconnect */
722
        return 0;
723
    }
724

725
    /* Websocket frame sanity check:
726
     * * Fragmentation is only supported for binary frames.
727
     * * All frames sent by a client MUST be masked.
728
     * * Only binary and ping/pong encoding is supported.
729
     */
730
    if (!fin) {
731
        if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
732
            error_setg(errp, "only binary websocket frames may be fragmented");
733
            qio_channel_websock_write_close(
734
                ioc, QIO_CHANNEL_WEBSOCK_STATUS_POLICY ,
735
                "only binary frames may be fragmented");
736
            return -1;
737
        }
738
    } else {
739
        if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME &&
740
            opcode != QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE &&
741
            opcode != QIO_CHANNEL_WEBSOCK_OPCODE_PING &&
742
            opcode != QIO_CHANNEL_WEBSOCK_OPCODE_PONG) {
743
            error_setg(errp, "unsupported opcode: 0x%04x; only binary, close, "
744
                       "ping, and pong websocket frames are supported", opcode);
745
            qio_channel_websock_write_close(
746
                ioc, QIO_CHANNEL_WEBSOCK_STATUS_INVALID_DATA ,
747
                "only binary, close, ping, and pong frames are supported");
748
            return -1;
749
        }
750
    }
751
    if (!has_mask) {
752
        error_setg(errp, "client websocket frames must be masked");
753
        qio_channel_websock_write_close(
754
            ioc, QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR,
755
            "client frames must be masked");
756
        return -1;
757
    }
758

759
    if (payload_len < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT) {
760
        ioc->payload_remain = payload_len;
761
        header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
762
        ioc->mask = header->u.m;
763
    } else if (opcode & QIO_CHANNEL_WEBSOCK_CONTROL_OPCODE_MASK) {
764
        error_setg(errp, "websocket control frame is too large");
765
        qio_channel_websock_write_close(
766
            ioc, QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR,
767
            "control frame is too large");
768
        return -1;
769
    } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT &&
770
               ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT) {
771
        ioc->payload_remain = be16_to_cpu(header->u.s16.l16);
772
        header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
773
        ioc->mask = header->u.s16.m16;
774
    } else if (payload_len == QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT &&
775
               ioc->encinput.offset >= QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT) {
776
        ioc->payload_remain = be64_to_cpu(header->u.s64.l64);
777
        header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
778
        ioc->mask = header->u.s64.m64;
779
    } else {
780
        /* header not complete */
781
        return QIO_CHANNEL_ERR_BLOCK;
782
    }
783

784
    trace_qio_channel_websock_header_full_decode(
785
        ioc, header_size, ioc->payload_remain, ioc->mask.u);
786
    buffer_advance(&ioc->encinput, header_size);
787
    return 0;
788
}
789

790

791
static int qio_channel_websock_decode_payload(QIOChannelWebsock *ioc,
792
                                              Error **errp)
793
{
794
    size_t i;
795
    size_t payload_len = 0;
796
    uint32_t *payload32;
797

798
    if (ioc->payload_remain) {
799
        /* If we aren't at the end of the payload, then drop
800
         * off the last bytes, so we're always multiple of 4
801
         * for purpose of unmasking, except at end of payload
802
         */
803
        if (ioc->encinput.offset < ioc->payload_remain) {
804
            /* Wait for the entire payload before processing control frames
805
             * because the payload will most likely be echoed back. */
806
            if (ioc->opcode & QIO_CHANNEL_WEBSOCK_CONTROL_OPCODE_MASK) {
807
                return QIO_CHANNEL_ERR_BLOCK;
808
            }
809
            payload_len = ioc->encinput.offset - (ioc->encinput.offset % 4);
810
        } else {
811
            payload_len = ioc->payload_remain;
812
        }
813
        if (payload_len == 0) {
814
            return QIO_CHANNEL_ERR_BLOCK;
815
        }
816

817
        ioc->payload_remain -= payload_len;
818

819
        /* unmask frame */
820
        /* process 1 frame (32 bit op) */
821
        payload32 = (uint32_t *)ioc->encinput.buffer;
822
        for (i = 0; i < payload_len / 4; i++) {
823
            payload32[i] ^= ioc->mask.u;
824
        }
825
        /* process the remaining bytes (if any) */
826
        for (i *= 4; i < payload_len; i++) {
827
            ioc->encinput.buffer[i] ^= ioc->mask.c[i % 4];
828
        }
829
    }
830

831
    trace_qio_channel_websock_payload_decode(
832
        ioc, ioc->opcode, ioc->payload_remain);
833

834
    if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
835
        if (payload_len) {
836
            /* binary frames are passed on */
837
            buffer_reserve(&ioc->rawinput, payload_len);
838
            buffer_append(&ioc->rawinput, ioc->encinput.buffer, payload_len);
839
        }
840
    } else if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE) {
841
        /* close frames are echoed back */
842
        error_setg(errp, "websocket closed by peer");
843
        if (payload_len) {
844
            /* echo client status */
845
            struct iovec iov = { .iov_base = ioc->encinput.buffer,
846
                                 .iov_len = ioc->encinput.offset };
847
            qio_channel_websock_encode(ioc, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
848
                                       &iov, 1, iov.iov_len);
849
            qio_channel_websock_write_wire(ioc, NULL);
850
            qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
851
        } else {
852
            /* send our own status */
853
            qio_channel_websock_write_close(
854
                ioc, QIO_CHANNEL_WEBSOCK_STATUS_NORMAL, "peer requested close");
855
        }
856
        return -1;
857
    } else if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_PING) {
858
        /* ping frames produce an immediate reply, as long as we've not still
859
         * got a previous pong queued, in which case we drop the new pong */
860
        if (ioc->pong_remain == 0) {
861
            struct iovec iov = { .iov_base = ioc->encinput.buffer,
862
                                 .iov_len = ioc->encinput.offset };
863
            qio_channel_websock_encode(ioc, QIO_CHANNEL_WEBSOCK_OPCODE_PONG,
864
                                       &iov, 1, iov.iov_len);
865
            ioc->pong_remain = ioc->encoutput.offset;
866
        }
867
    }   /* pong frames are ignored */
868

869
    if (payload_len) {
870
        buffer_advance(&ioc->encinput, payload_len);
871
    }
872
    return 0;
873
}
874

875

876
QIOChannelWebsock *
877
qio_channel_websock_new_server(QIOChannel *master)
878
{
879
    QIOChannelWebsock *wioc;
880
    QIOChannel *ioc;
881

882
    wioc = QIO_CHANNEL_WEBSOCK(object_new(TYPE_QIO_CHANNEL_WEBSOCK));
883
    ioc = QIO_CHANNEL(wioc);
884

885
    wioc->master = master;
886
    ioc->follow_coroutine_ctx = master->follow_coroutine_ctx;
887
    if (qio_channel_has_feature(master, QIO_CHANNEL_FEATURE_SHUTDOWN)) {
888
        qio_channel_set_feature(ioc, QIO_CHANNEL_FEATURE_SHUTDOWN);
889
    }
890
    object_ref(OBJECT(master));
891

892
    trace_qio_channel_websock_new_server(wioc, master);
893
    return wioc;
894
}
895

896
void qio_channel_websock_handshake(QIOChannelWebsock *ioc,
897
                                   QIOTaskFunc func,
898
                                   gpointer opaque,
899
                                   GDestroyNotify destroy)
900
{
901
    QIOTask *task;
902

903
    task = qio_task_new(OBJECT(ioc),
904
                        func,
905
                        opaque,
906
                        destroy);
907

908
    trace_qio_channel_websock_handshake_start(ioc);
909
    trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
910
    qio_channel_add_watch(ioc->master,
911
                          G_IO_IN,
912
                          qio_channel_websock_handshake_io,
913
                          task,
914
                          NULL);
915
}
916

917

918
static void qio_channel_websock_finalize(Object *obj)
919
{
920
    QIOChannelWebsock *ioc = QIO_CHANNEL_WEBSOCK(obj);
921

922
    buffer_free(&ioc->encinput);
923
    buffer_free(&ioc->encoutput);
924
    buffer_free(&ioc->rawinput);
925
    object_unref(OBJECT(ioc->master));
926
    if (ioc->io_tag) {
927
        g_source_remove(ioc->io_tag);
928
    }
929
    if (ioc->io_err) {
930
        error_free(ioc->io_err);
931
    }
932
}
933

934

935
static ssize_t qio_channel_websock_read_wire(QIOChannelWebsock *ioc,
936
                                             Error **errp)
937
{
938
    ssize_t ret;
939

940
    if (ioc->encinput.offset < 4096) {
941
        size_t want = 4096 - ioc->encinput.offset;
942

943
        buffer_reserve(&ioc->encinput, want);
944
        ret = qio_channel_read(ioc->master,
945
                               (char *)ioc->encinput.buffer +
946
                               ioc->encinput.offset,
947
                               want,
948
                               errp);
949
        if (ret < 0) {
950
            return ret;
951
        }
952
        if (ret == 0 && ioc->encinput.offset == 0) {
953
            ioc->io_eof = TRUE;
954
            return 0;
955
        }
956
        ioc->encinput.offset += ret;
957
    }
958

959
    while (ioc->encinput.offset != 0) {
960
        if (ioc->payload_remain == 0) {
961
            ret = qio_channel_websock_decode_header(ioc, errp);
962
            if (ret < 0) {
963
                return ret;
964
            }
965
        }
966

967
        ret = qio_channel_websock_decode_payload(ioc, errp);
968
        if (ret < 0) {
969
            return ret;
970
        }
971
    }
972
    return 1;
973
}
974

975

976
static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *ioc,
977
                                              Error **errp)
978
{
979
    ssize_t ret;
980
    ssize_t done = 0;
981

982
    while (ioc->encoutput.offset > 0) {
983
        ret = qio_channel_write(ioc->master,
984
                                (char *)ioc->encoutput.buffer,
985
                                ioc->encoutput.offset,
986
                                errp);
987
        if (ret < 0) {
988
            if (ret == QIO_CHANNEL_ERR_BLOCK &&
989
                done > 0) {
990
                return done;
991
            } else {
992
                return ret;
993
            }
994
        }
995
        buffer_advance(&ioc->encoutput, ret);
996
        done += ret;
997
        if (ioc->pong_remain < ret) {
998
            ioc->pong_remain = 0;
999
        } else {
1000
            ioc->pong_remain -= ret;
1001
        }
1002
    }
1003
    return done;
1004
}
1005

1006

1007
static void qio_channel_websock_flush_free(gpointer user_data)
1008
{
1009
    QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
1010
    object_unref(OBJECT(wioc));
1011
}
1012

1013
static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc);
1014

1015
static gboolean qio_channel_websock_flush(QIOChannel *ioc,
1016
                                          GIOCondition condition,
1017
                                          gpointer user_data)
1018
{
1019
    QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
1020
    ssize_t ret;
1021

1022
    if (condition & G_IO_OUT) {
1023
        ret = qio_channel_websock_write_wire(wioc, &wioc->io_err);
1024
        if (ret < 0) {
1025
            goto cleanup;
1026
        }
1027
    }
1028

1029
    if (condition & G_IO_IN) {
1030
        ret = qio_channel_websock_read_wire(wioc, &wioc->io_err);
1031
        if (ret < 0) {
1032
            goto cleanup;
1033
        }
1034
    }
1035

1036
 cleanup:
1037
    qio_channel_websock_set_watch(wioc);
1038
    return FALSE;
1039
}
1040

1041

1042
static void qio_channel_websock_unset_watch(QIOChannelWebsock *ioc)
1043
{
1044
    if (ioc->io_tag) {
1045
        g_source_remove(ioc->io_tag);
1046
        ioc->io_tag = 0;
1047
    }
1048
}
1049

1050
static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc)
1051
{
1052
    GIOCondition cond = 0;
1053

1054
    qio_channel_websock_unset_watch(ioc);
1055

1056
    if (ioc->io_err) {
1057
        return;
1058
    }
1059

1060
    if (ioc->encoutput.offset) {
1061
        cond |= G_IO_OUT;
1062
    }
1063
    if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER &&
1064
        !ioc->io_eof) {
1065
        cond |= G_IO_IN;
1066
    }
1067

1068
    if (cond) {
1069
        object_ref(OBJECT(ioc));
1070
        ioc->io_tag =
1071
            qio_channel_add_watch(ioc->master,
1072
                                  cond,
1073
                                  qio_channel_websock_flush,
1074
                                  ioc,
1075
                                  qio_channel_websock_flush_free);
1076
    }
1077
}
1078

1079

1080
static ssize_t qio_channel_websock_readv(QIOChannel *ioc,
1081
                                         const struct iovec *iov,
1082
                                         size_t niov,
1083
                                         int **fds,
1084
                                         size_t *nfds,
1085
                                         int flags,
1086
                                         Error **errp)
1087
{
1088
    QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1089
    size_t i;
1090
    ssize_t got = 0;
1091
    ssize_t ret;
1092

1093
    if (wioc->io_err) {
1094
        error_propagate(errp, error_copy(wioc->io_err));
1095
        return -1;
1096
    }
1097

1098
    if (!wioc->rawinput.offset) {
1099
        ret = qio_channel_websock_read_wire(QIO_CHANNEL_WEBSOCK(ioc), errp);
1100
        if (ret < 0) {
1101
            return ret;
1102
        }
1103
    }
1104

1105
    for (i = 0 ; i < niov ; i++) {
1106
        size_t want = iov[i].iov_len;
1107
        if (want > (wioc->rawinput.offset - got)) {
1108
            want = (wioc->rawinput.offset - got);
1109
        }
1110

1111
        memcpy(iov[i].iov_base,
1112
               wioc->rawinput.buffer + got,
1113
               want);
1114
        got += want;
1115

1116
        if (want < iov[i].iov_len) {
1117
            break;
1118
        }
1119
    }
1120

1121
    buffer_advance(&wioc->rawinput, got);
1122
    qio_channel_websock_set_watch(wioc);
1123
    return got;
1124
}
1125

1126

1127
static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
1128
                                          const struct iovec *iov,
1129
                                          size_t niov,
1130
                                          int *fds,
1131
                                          size_t nfds,
1132
                                          int flags,
1133
                                          Error **errp)
1134
{
1135
    QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1136
    ssize_t want = iov_size(iov, niov);
1137
    ssize_t avail;
1138
    ssize_t ret;
1139

1140
    if (wioc->io_err) {
1141
        error_propagate(errp, error_copy(wioc->io_err));
1142
        return -1;
1143
    }
1144

1145
    if (wioc->io_eof) {
1146
        error_setg(errp, "%s", "Broken pipe");
1147
        return -1;
1148
    }
1149

1150
    avail = wioc->encoutput.offset >= QIO_CHANNEL_WEBSOCK_MAX_BUFFER ?
1151
        0 : (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->encoutput.offset);
1152
    if (want > avail) {
1153
        want = avail;
1154
    }
1155

1156
    if (want) {
1157
        qio_channel_websock_encode(wioc,
1158
                                   QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME,
1159
                                   iov, niov, want);
1160
    }
1161

1162
    /* Even if want == 0, we'll try write_wire in case there's
1163
     * pending data we could usefully flush out
1164
     */
1165
    ret = qio_channel_websock_write_wire(wioc, errp);
1166
    if (ret < 0 &&
1167
        ret != QIO_CHANNEL_ERR_BLOCK) {
1168
        qio_channel_websock_unset_watch(wioc);
1169
        return -1;
1170
    }
1171

1172
    qio_channel_websock_set_watch(wioc);
1173

1174
    if (want == 0) {
1175
        return QIO_CHANNEL_ERR_BLOCK;
1176
    }
1177

1178
    return want;
1179
}
1180

1181
static int qio_channel_websock_set_blocking(QIOChannel *ioc,
1182
                                            bool enabled,
1183
                                            Error **errp)
1184
{
1185
    QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1186

1187
    qio_channel_set_blocking(wioc->master, enabled, errp);
1188
    return 0;
1189
}
1190

1191
static void qio_channel_websock_set_delay(QIOChannel *ioc,
1192
                                          bool enabled)
1193
{
1194
    QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1195

1196
    qio_channel_set_delay(tioc->master, enabled);
1197
}
1198

1199
static void qio_channel_websock_set_cork(QIOChannel *ioc,
1200
                                         bool enabled)
1201
{
1202
    QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1203

1204
    qio_channel_set_cork(tioc->master, enabled);
1205
}
1206

1207
static int qio_channel_websock_shutdown(QIOChannel *ioc,
1208
                                        QIOChannelShutdown how,
1209
                                        Error **errp)
1210
{
1211
    QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1212

1213
    return qio_channel_shutdown(tioc->master, how, errp);
1214
}
1215

1216
static int qio_channel_websock_close(QIOChannel *ioc,
1217
                                     Error **errp)
1218
{
1219
    QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1220

1221
    trace_qio_channel_websock_close(ioc);
1222
    return qio_channel_close(wioc->master, errp);
1223
}
1224

1225
typedef struct QIOChannelWebsockSource QIOChannelWebsockSource;
1226
struct QIOChannelWebsockSource {
1227
    GSource parent;
1228
    QIOChannelWebsock *wioc;
1229
    GIOCondition condition;
1230
};
1231

1232
static gboolean
1233
qio_channel_websock_source_check(GSource *source)
1234
{
1235
    QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
1236
    GIOCondition cond = 0;
1237

1238
    if (wsource->wioc->rawinput.offset) {
1239
        cond |= G_IO_IN;
1240
    }
1241
    if (wsource->wioc->encoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
1242
        cond |= G_IO_OUT;
1243
    }
1244
    if (wsource->wioc->io_eof) {
1245
        cond |= G_IO_HUP;
1246
    }
1247
    if (wsource->wioc->io_err) {
1248
        cond |= G_IO_ERR;
1249
    }
1250

1251
    return cond & wsource->condition;
1252
}
1253

1254
static gboolean
1255
qio_channel_websock_source_prepare(GSource *source,
1256
                                   gint *timeout)
1257
{
1258
    *timeout = -1;
1259
    return qio_channel_websock_source_check(source);
1260
}
1261

1262
static gboolean
1263
qio_channel_websock_source_dispatch(GSource *source,
1264
                                    GSourceFunc callback,
1265
                                    gpointer user_data)
1266
{
1267
    QIOChannelFunc func = (QIOChannelFunc)callback;
1268
    QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
1269

1270
    return (*func)(QIO_CHANNEL(wsource->wioc),
1271
                   qio_channel_websock_source_check(source),
1272
                   user_data);
1273
}
1274

1275
static void
1276
qio_channel_websock_source_finalize(GSource *source)
1277
{
1278
    QIOChannelWebsockSource *ssource = (QIOChannelWebsockSource *)source;
1279

1280
    object_unref(OBJECT(ssource->wioc));
1281
}
1282

1283
GSourceFuncs qio_channel_websock_source_funcs = {
1284
    qio_channel_websock_source_prepare,
1285
    qio_channel_websock_source_check,
1286
    qio_channel_websock_source_dispatch,
1287
    qio_channel_websock_source_finalize
1288
};
1289

1290
static GSource *qio_channel_websock_create_watch(QIOChannel *ioc,
1291
                                                 GIOCondition condition)
1292
{
1293
    QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1294
    QIOChannelWebsockSource *ssource;
1295
    GSource *source;
1296

1297
    source = g_source_new(&qio_channel_websock_source_funcs,
1298
                          sizeof(QIOChannelWebsockSource));
1299
    ssource = (QIOChannelWebsockSource *)source;
1300

1301
    ssource->wioc = wioc;
1302
    object_ref(OBJECT(wioc));
1303

1304
    ssource->condition = condition;
1305

1306
    qio_channel_websock_set_watch(wioc);
1307
    return source;
1308
}
1309

1310
static void qio_channel_websock_class_init(ObjectClass *klass,
1311
                                           void *class_data G_GNUC_UNUSED)
1312
{
1313
    QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
1314

1315
    ioc_klass->io_writev = qio_channel_websock_writev;
1316
    ioc_klass->io_readv = qio_channel_websock_readv;
1317
    ioc_klass->io_set_blocking = qio_channel_websock_set_blocking;
1318
    ioc_klass->io_set_cork = qio_channel_websock_set_cork;
1319
    ioc_klass->io_set_delay = qio_channel_websock_set_delay;
1320
    ioc_klass->io_close = qio_channel_websock_close;
1321
    ioc_klass->io_shutdown = qio_channel_websock_shutdown;
1322
    ioc_klass->io_create_watch = qio_channel_websock_create_watch;
1323
}
1324

1325
static const TypeInfo qio_channel_websock_info = {
1326
    .parent = TYPE_QIO_CHANNEL,
1327
    .name = TYPE_QIO_CHANNEL_WEBSOCK,
1328
    .instance_size = sizeof(QIOChannelWebsock),
1329
    .instance_finalize = qio_channel_websock_finalize,
1330
    .class_init = qio_channel_websock_class_init,
1331
};
1332

1333
static void qio_channel_websock_register_types(void)
1334
{
1335
    type_register_static(&qio_channel_websock_info);
1336
}
1337

1338
type_init(qio_channel_websock_register_types);
1339