blob: 9619906ac36b282fb86484615e90738328e64d36 [file] [log] [blame]
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001/*
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
Chetan Pante0622ae2020-10-14 13:40:33 +00009 * version 2.1 of the License, or (at your option) any later version.
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000010 *
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
Peter Maydellcae9fc52016-01-29 17:50:03 +000021#include "qemu/osdep.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010022#include "qapi/error.h"
Paolo Bonzini58369e22016-03-15 17:22:36 +010023#include "qemu/bswap.h"
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000024#include "io/channel-websock.h"
25#include "crypto/hash.h"
26#include "trace.h"
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +010027#include "qemu/iov.h"
Markus Armbruster0b8fa322019-05-23 16:35:07 +020028#include "qemu/module.h"
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000029
Daniel P. Berrangea7b20a82017-10-09 14:43:42 +010030/* Max amount to allow in rawinput/encoutput buffers */
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000031#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
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +000037#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"
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000043
44#define QIO_CHANNEL_WEBSOCK_PROTOCOL_BINARY "binary"
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +000045#define QIO_CHANNEL_WEBSOCK_CONNECTION_UPGRADE "Upgrade"
46#define QIO_CHANNEL_WEBSOCK_UPGRADE_WEBSOCKET "websocket"
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000047
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +010048#define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_COMMON \
49 "Server: QEMU VNC\r\n" \
50 "Date: %s\r\n"
51
Yu-Chen Linc64e1e72019-11-23 11:43:06 +080052#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"
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +010060#define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_OK \
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000061 "HTTP/1.1 101 Switching Protocols\r\n" \
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +010062 QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_COMMON \
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000063 "Upgrade: websocket\r\n" \
64 "Connection: Upgrade\r\n" \
65 "Sec-WebSocket-Accept: %s\r\n" \
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000066 "\r\n"
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +010067#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"
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000089#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"
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +000092#define QIO_CHANNEL_WEBSOCK_HTTP_METHOD "GET"
93#define QIO_CHANNEL_WEBSOCK_HTTP_PATH "/"
94#define QIO_CHANNEL_WEBSOCK_HTTP_VERSION "HTTP/1.1"
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +000095
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
Brandon Carpentereefa3d82017-09-12 08:21:48 -0700119/* Bitmasks for accessing header fields */
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000120#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
Brandon Carpenter01af17f2017-09-12 08:21:51 -0700124#define QIO_CHANNEL_WEBSOCK_CONTROL_OPCODE_MASK 0x8
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000125
126typedef struct QIOChannelWebsockHeader QIOChannelWebsockHeader;
127
128struct 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
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000144typedef struct QIOChannelWebsockHTTPHeader QIOChannelWebsockHTTPHeader;
145
146struct QIOChannelWebsockHTTPHeader {
147 char *name;
148 char *value;
149};
150
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000151enum {
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
Marc-André Lureau9edc6312022-02-20 20:39:25 +0400160static void G_GNUC_PRINTF(2, 3)
Stefan Weil52aa5642017-10-07 16:56:09 +0200161qio_channel_websock_handshake_send_res(QIOChannelWebsock *ioc,
162 const char *resmsg,
163 ...)
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100164{
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);
Marc-André Lureauad824bd2018-10-19 14:12:14 +0400174 g_free(response);
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100175 va_end(vargs);
176}
177
178static gchar *qio_channel_websock_date_str(void)
179{
Daniel P. Berrangécfb47f22021-04-30 12:59:06 +0100180 g_autoptr(GDateTime) now = g_date_time_new_now_utc();
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100181
Daniel P. Berrangécfb47f22021-04-30 12:59:06 +0100182 return g_date_time_format(now, "%a, %d %b %Y %H:%M:%S GMT");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100183}
184
185static 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
Brandon Carpenter530ca602017-09-12 08:21:53 -0700193enum {
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
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000202static size_t
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100203qio_channel_websock_extract_headers(QIOChannelWebsock *ioc,
204 char *buffer,
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000205 QIOChannelWebsockHTTPHeader *hdrs,
206 size_t nhdrsalloc,
207 Error **errp)
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000208{
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000209 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");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100225 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000226 }
227 *nl = '\0';
Daniel P. Berrange0efd6c92017-10-10 13:28:03 +0100228 trace_qio_channel_websock_http_greeting(ioc, buffer);
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000229
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);
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100239 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000240 }
241
242 buffer = tmp + 1;
243 tmp = strchr(buffer, ' ');
244 if (!tmp) {
245 error_setg(errp, "Missing HTTP version delimiter");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100246 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000247 }
248 *tmp = '\0';
249
250 if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_PATH)) {
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100251 qio_channel_websock_handshake_send_res_err(
252 ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_NOT_FOUND);
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000253 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);
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100261 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000262 }
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");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100286 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000287 }
288 *sep = '\0';
289 sep++;
290 while (*sep == ' ') {
291 sep++;
292 }
293
294 if (nhdrs >= nhdrsalloc) {
295 error_setg(errp, "Too many HTTP headers");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100296 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000297 }
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;
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100314
315 bad_request:
316 qio_channel_websock_handshake_send_res_err(
317 ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_BAD_REQUEST);
318 return 0;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000319}
320
321static const char *
322qio_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;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000331 }
332 }
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000333
334 return NULL;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000335}
336
337
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100338static void qio_channel_websock_handshake_send_res_ok(QIOChannelWebsock *ioc,
339 const char *key,
Yu-Chen Linc64e1e72019-11-23 11:43:06 +0800340 const bool use_protocols,
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100341 Error **errp)
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000342{
343 char combined_key[QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +
344 QIO_CHANNEL_WEBSOCK_GUID_LEN + 1];
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100345 char *accept = NULL;
Daniel P. Berrange7fc3fce2017-10-11 16:38:10 +0100346 char *date = NULL;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000347
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) {
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100360 qio_channel_websock_handshake_send_res_err(
361 ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_SERVER_ERR);
362 return;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000363 }
364
Daniel P. Berrange7fc3fce2017-10-11 16:38:10 +0100365 date = qio_channel_websock_date_str();
Yu-Chen Linc64e1e72019-11-23 11:43:06 +0800366 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 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000374
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100375 g_free(date);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000376 g_free(accept);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000377}
378
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100379static void qio_channel_websock_handshake_process(QIOChannelWebsock *ioc,
380 char *buffer,
381 Error **errp)
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000382{
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000383 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;
Daniel P. Berrange6d5d23b2017-10-09 17:52:28 +0100387 char **connectionv;
388 bool upgraded = false;
389 size_t i;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000390
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100391 nhdrs = qio_channel_websock_extract_headers(ioc, buffer, hdrs, nhdrs, errp);
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000392 if (!nhdrs) {
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100393 return;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000394 }
395
396 protocols = qio_channel_websock_find_header(
397 hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_PROTOCOL);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000398
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000399 version = qio_channel_websock_find_header(
400 hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_VERSION);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000401 if (!version) {
402 error_setg(errp, "Missing websocket version header data");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100403 goto bad_request;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000404 }
405
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000406 key = qio_channel_websock_find_header(
407 hdrs, nhdrs, QIO_CHANNEL_WEBSOCK_HEADER_KEY);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000408 if (!key) {
409 error_setg(errp, "Missing websocket key header data");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100410 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000411 }
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");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100417 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000418 }
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");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100424 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000425 }
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");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100431 goto bad_request;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000432 }
433
Daniel P. Berrange0efd6c92017-10-10 13:28:03 +0100434 trace_qio_channel_websock_http_request(ioc, protocols, version,
435 host, connection, upgrade, key);
436
Yu-Chen Linc64e1e72019-11-23 11:43:06 +0800437 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 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000443 }
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);
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100448 goto bad_request;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000449 }
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);
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100454 goto bad_request;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000455 }
456
Daniel P. Berrange6d5d23b2017-10-09 17:52:28 +0100457 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) {
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000467 error_setg(errp, "No connection upgrade requested '%s'", connection);
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100468 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000469 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000470
Daniel P. Berrange33badfd2017-09-06 14:49:41 +0100471 if (strcasecmp(upgrade, QIO_CHANNEL_WEBSOCK_UPGRADE_WEBSOCKET) != 0) {
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000472 error_setg(errp, "Incorrect upgrade method '%s'", upgrade);
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100473 goto bad_request;
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000474 }
475
Yu-Chen Linc64e1e72019-11-23 11:43:06 +0800476 qio_channel_websock_handshake_send_res_ok(ioc, key, !!protocols, errp);
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100477 return;
478
479 bad_request:
480 qio_channel_websock_handshake_send_res_err(
481 ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_BAD_REQUEST);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000482}
483
484static 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) {
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100505 qio_channel_websock_handshake_send_res_err(
506 ioc, QIO_CHANNEL_WEBSOCK_HANDSHAKE_RES_TOO_LARGE);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000507 error_setg(errp,
508 "End of headers not found in first 4096 bytes");
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100509 return 1;
Edgar Kaziakhmedova46ded12018-01-10 18:39:24 +0300510 } else if (ret == 0) {
511 error_setg(errp,
512 "End of headers not found before connection closed");
513 return -1;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000514 }
Edgar Kaziakhmedova46ded12018-01-10 18:39:24 +0300515 return 0;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000516 }
Daniel P. Berrange07e95cd2017-02-28 10:37:24 +0000517 *handshake_end = '\0';
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000518
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100519 qio_channel_websock_handshake_process(ioc,
520 (char *)ioc->encinput.buffer,
521 errp);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000522
523 buffer_advance(&ioc->encinput,
524 handshake_end - (char *)ioc->encinput.buffer +
525 strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_END));
526 return 1;
527}
528
529static 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) {
Daniel P. Berrange3a3f8702017-09-06 11:38:36 +0100545 trace_qio_channel_websock_handshake_fail(ioc, error_get_pretty(err));
Daniel P. Berrange60e705c2016-08-11 15:20:58 +0100546 qio_task_set_error(task, err);
547 qio_task_complete(task);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000548 return FALSE;
549 }
550
551 buffer_advance(&wioc->encoutput, ret);
552 if (wioc->encoutput.offset == 0) {
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100553 if (wioc->io_err) {
Daniel P. Berrange3a3f8702017-09-06 11:38:36 +0100554 trace_qio_channel_websock_handshake_fail(
555 ioc, error_get_pretty(wioc->io_err));
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100556 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 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000563 return FALSE;
564 }
565 trace_qio_channel_websock_handshake_pending(ioc, G_IO_OUT);
566 return TRUE;
567}
568
569static 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) {
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100581 /*
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 */
Daniel P. Berrange3a3f8702017-09-06 11:38:36 +0100586 trace_qio_channel_websock_handshake_fail(ioc, error_get_pretty(err));
Daniel P. Berrange60e705c2016-08-11 15:20:58 +0100587 qio_task_set_error(task, err);
588 qio_task_complete(task);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000589 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
Laurent Vivier710c2632018-03-23 15:32:00 +0100597 error_propagate(&wioc->io_err, err);
Daniel P. Berrangef69a8bd2017-09-06 11:33:17 +0100598
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000599 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,
Daniel P. Berrangebc35d512016-06-07 12:27:51 +0100605 NULL);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000606 return FALSE;
607}
608
609
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100610static void qio_channel_websock_encode(QIOChannelWebsock *ioc,
611 uint8_t opcode,
612 const struct iovec *iov,
613 size_t niov,
614 size_t size)
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000615{
616 size_t header_size;
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100617 size_t i;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000618 union {
619 char buf[QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT];
620 QIOChannelWebsockHeader ws;
621 } header;
622
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100623 assert(size <= iov_size(iov, niov));
624
Brandon Carpentereefa3d82017-09-12 08:21:48 -0700625 header.ws.b0 = QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN |
Brandon Carpenter268a53f2017-09-12 08:21:52 -0700626 (opcode & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE);
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100627 if (size < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_7_BIT) {
628 header.ws.b1 = (uint8_t)size;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000629 header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_7_BIT;
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100630 } else if (size < QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_THRESHOLD_16_BIT) {
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000631 header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_16_BIT;
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100632 header.ws.u.s16.l16 = cpu_to_be16((uint16_t)size);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000633 header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_16_BIT;
634 } else {
635 header.ws.b1 = QIO_CHANNEL_WEBSOCK_PAYLOAD_LEN_MAGIC_64_BIT;
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100636 header.ws.u.s64.l64 = cpu_to_be64(size);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000637 header_size = QIO_CHANNEL_WEBSOCK_HEADER_LEN_64_BIT;
638 }
639 header_size -= QIO_CHANNEL_WEBSOCK_HEADER_LEN_MASK;
640
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100641 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 }
Brandon Carpenter268a53f2017-09-12 08:21:52 -0700652}
653
654
Brandon Carpenter530ca602017-09-12 08:21:53 -0700655static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *, Error **);
656
657
658static void qio_channel_websock_write_close(QIOChannelWebsock *ioc,
659 uint16_t code, const char *reason)
660{
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +0100661 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
Brandon Carpenter530ca602017-09-12 08:21:53 -0700669 if (reason) {
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +0100670 iov[1].iov_base = (void *)reason;
671 iov[1].iov_len = strlen(reason);
672 size += iov[1].iov_len;
673 niov++;
Brandon Carpenter530ca602017-09-12 08:21:53 -0700674 }
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100675 qio_channel_websock_encode(ioc, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +0100676 iov, niov, size);
Brandon Carpenter530ca602017-09-12 08:21:53 -0700677 qio_channel_websock_write_wire(ioc, NULL);
678 qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
679}
680
681
Brandon Carpentereefa3d82017-09-12 08:21:48 -0700682static int qio_channel_websock_decode_header(QIOChannelWebsock *ioc,
683 Error **errp)
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000684{
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);
Brandon Carpenter530ca602017-09-12 08:21:53 -0700695 qio_channel_websock_write_close(
696 ioc, QIO_CHANNEL_WEBSOCK_STATUS_SERVER_ERR,
697 "internal server error");
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000698 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
Brandon Carpentereefa3d82017-09-12 08:21:48 -0700705 fin = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_FIN;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000706 opcode = header->b0 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_OPCODE;
Brandon Carpentereefa3d82017-09-12 08:21:48 -0700707 has_mask = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_HAS_MASK;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000708 payload_len = header->b1 & QIO_CHANNEL_WEBSOCK_HEADER_FIELD_PAYLOAD_LEN;
709
Brandon Carpenterff1300e2017-09-12 08:21:49 -0700710 /* Save or restore opcode. */
711 if (opcode) {
712 ioc->opcode = opcode;
713 } else {
714 opcode = ioc->opcode;
715 }
716
Daniel P. Berrange59f183b2017-09-21 11:00:47 +0100717 trace_qio_channel_websock_header_partial_decode(ioc, payload_len,
718 fin, opcode, (int)has_mask);
719
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000720 if (opcode == QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE) {
721 /* disconnect */
722 return 0;
723 }
724
725 /* Websocket frame sanity check:
Brandon Carpenterff1300e2017-09-12 08:21:49 -0700726 * * Fragmentation is only supported for binary frames.
727 * * All frames sent by a client MUST be masked.
Brandon Carpenter268a53f2017-09-12 08:21:52 -0700728 * * Only binary and ping/pong encoding is supported.
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000729 */
730 if (!fin) {
Brandon Carpenterff1300e2017-09-12 08:21:49 -0700731 if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
732 error_setg(errp, "only binary websocket frames may be fragmented");
Brandon Carpenter530ca602017-09-12 08:21:53 -0700733 qio_channel_websock_write_close(
734 ioc, QIO_CHANNEL_WEBSOCK_STATUS_POLICY ,
735 "only binary frames may be fragmented");
Brandon Carpenterff1300e2017-09-12 08:21:49 -0700736 return -1;
737 }
738 } else {
Brandon Carpenter01af17f2017-09-12 08:21:51 -0700739 if (opcode != QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME &&
Brandon Carpenter530ca602017-09-12 08:21:53 -0700740 opcode != QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE &&
Brandon Carpenter01af17f2017-09-12 08:21:51 -0700741 opcode != QIO_CHANNEL_WEBSOCK_OPCODE_PING &&
742 opcode != QIO_CHANNEL_WEBSOCK_OPCODE_PONG) {
AlexChen77b78292020-10-19 20:12:02 +0800743 error_setg(errp, "unsupported opcode: 0x%04x; only binary, close, "
Brandon Carpenter530ca602017-09-12 08:21:53 -0700744 "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");
Brandon Carpenterff1300e2017-09-12 08:21:49 -0700748 return -1;
749 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000750 }
751 if (!has_mask) {
Brandon Carpentereefa3d82017-09-12 08:21:48 -0700752 error_setg(errp, "client websocket frames must be masked");
Brandon Carpenter530ca602017-09-12 08:21:53 -0700753 qio_channel_websock_write_close(
754 ioc, QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR,
755 "client frames must be masked");
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000756 return -1;
757 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000758
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;
Brandon Carpenter01af17f2017-09-12 08:21:51 -0700763 } else if (opcode & QIO_CHANNEL_WEBSOCK_CONTROL_OPCODE_MASK) {
764 error_setg(errp, "websocket control frame is too large");
Brandon Carpenter530ca602017-09-12 08:21:53 -0700765 qio_channel_websock_write_close(
766 ioc, QIO_CHANNEL_WEBSOCK_STATUS_PROTOCOL_ERR,
767 "control frame is too large");
Brandon Carpenter01af17f2017-09-12 08:21:51 -0700768 return -1;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000769 } 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
Daniel P. Berrange59f183b2017-09-21 11:00:47 +0100784 trace_qio_channel_websock_header_full_decode(
785 ioc, header_size, ioc->payload_remain, ioc->mask.u);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000786 buffer_advance(&ioc->encinput, header_size);
Brandon Carpenter530ca602017-09-12 08:21:53 -0700787 return 0;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000788}
789
790
Brandon Carpentereefa3d82017-09-12 08:21:48 -0700791static int qio_channel_websock_decode_payload(QIOChannelWebsock *ioc,
792 Error **errp)
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000793{
794 size_t i;
Brandon Carpenter3a296402017-09-12 08:21:50 -0700795 size_t payload_len = 0;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000796 uint32_t *payload32;
797
Brandon Carpenter3a296402017-09-12 08:21:50 -0700798 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) {
Brandon Carpenter268a53f2017-09-12 08:21:52 -0700804 /* 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 }
Brandon Carpenter3a296402017-09-12 08:21:50 -0700809 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 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000829 }
830
Daniel P. Berrange59f183b2017-09-21 11:00:47 +0100831 trace_qio_channel_websock_payload_decode(
832 ioc, ioc->opcode, ioc->payload_remain);
833
Brandon Carpenter01af17f2017-09-12 08:21:51 -0700834 if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME) {
835 if (payload_len) {
Brandon Carpenter268a53f2017-09-12 08:21:52 -0700836 /* binary frames are passed on */
Brandon Carpenter01af17f2017-09-12 08:21:51 -0700837 buffer_reserve(&ioc->rawinput, payload_len);
838 buffer_append(&ioc->rawinput, ioc->encinput.buffer, payload_len);
839 }
Brandon Carpenter530ca602017-09-12 08:21:53 -0700840 } 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 */
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100845 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);
Brandon Carpenter530ca602017-09-12 08:21:53 -0700849 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;
Brandon Carpenter268a53f2017-09-12 08:21:52 -0700857 } else if (ioc->opcode == QIO_CHANNEL_WEBSOCK_OPCODE_PING) {
Daniel P. Berrange57b0cdf2017-10-09 15:34:06 +0100858 /* 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) {
Daniel P. Berrangefb74e592017-10-09 16:33:20 +0100861 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);
Daniel P. Berrange57b0cdf2017-10-09 15:34:06 +0100865 ioc->pong_remain = ioc->encoutput.offset;
866 }
Brandon Carpenter268a53f2017-09-12 08:21:52 -0700867 } /* pong frames are ignored */
Brandon Carpenter01af17f2017-09-12 08:21:51 -0700868
Brandon Carpenter3a296402017-09-12 08:21:50 -0700869 if (payload_len) {
Brandon Carpenter3a296402017-09-12 08:21:50 -0700870 buffer_advance(&ioc->encinput, payload_len);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000871 }
Brandon Carpentereefa3d82017-09-12 08:21:48 -0700872 return 0;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000873}
874
875
876QIOChannelWebsock *
877qio_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;
Felipe Franciosie413ae02016-09-29 08:52:36 -0700886 if (qio_channel_has_feature(master, QIO_CHANNEL_FEATURE_SHUTDOWN)) {
Felipe Franciosid8d3c7c2016-09-29 08:52:37 -0700887 qio_channel_set_feature(ioc, QIO_CHANNEL_FEATURE_SHUTDOWN);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000888 }
889 object_ref(OBJECT(master));
890
891 trace_qio_channel_websock_new_server(wioc, master);
892 return wioc;
893}
894
895void qio_channel_websock_handshake(QIOChannelWebsock *ioc,
896 QIOTaskFunc func,
897 gpointer opaque,
898 GDestroyNotify destroy)
899{
900 QIOTask *task;
901
902 task = qio_task_new(OBJECT(ioc),
903 func,
904 opaque,
905 destroy);
906
907 trace_qio_channel_websock_handshake_start(ioc);
908 trace_qio_channel_websock_handshake_pending(ioc, G_IO_IN);
909 qio_channel_add_watch(ioc->master,
910 G_IO_IN,
911 qio_channel_websock_handshake_io,
912 task,
913 NULL);
914}
915
916
917static void qio_channel_websock_finalize(Object *obj)
918{
919 QIOChannelWebsock *ioc = QIO_CHANNEL_WEBSOCK(obj);
920
921 buffer_free(&ioc->encinput);
922 buffer_free(&ioc->encoutput);
923 buffer_free(&ioc->rawinput);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000924 object_unref(OBJECT(ioc->master));
925 if (ioc->io_tag) {
926 g_source_remove(ioc->io_tag);
927 }
928 if (ioc->io_err) {
929 error_free(ioc->io_err);
930 }
931}
932
933
934static ssize_t qio_channel_websock_read_wire(QIOChannelWebsock *ioc,
935 Error **errp)
936{
937 ssize_t ret;
938
939 if (ioc->encinput.offset < 4096) {
940 size_t want = 4096 - ioc->encinput.offset;
941
942 buffer_reserve(&ioc->encinput, want);
943 ret = qio_channel_read(ioc->master,
944 (char *)ioc->encinput.buffer +
945 ioc->encinput.offset,
946 want,
947 errp);
948 if (ret < 0) {
949 return ret;
950 }
Brandon Carpentereefa3d82017-09-12 08:21:48 -0700951 if (ret == 0 && ioc->encinput.offset == 0) {
952 ioc->io_eof = TRUE;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000953 return 0;
954 }
955 ioc->encinput.offset += ret;
956 }
957
Daniel P. Berrangecd892a22017-01-27 18:11:32 +0000958 while (ioc->encinput.offset != 0) {
959 if (ioc->payload_remain == 0) {
960 ret = qio_channel_websock_decode_header(ioc, errp);
961 if (ret < 0) {
962 return ret;
963 }
Daniel P. Berrangecd892a22017-01-27 18:11:32 +0000964 }
965
966 ret = qio_channel_websock_decode_payload(ioc, errp);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000967 if (ret < 0) {
968 return ret;
969 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000970 }
Daniel P. Berrangecd892a22017-01-27 18:11:32 +0000971 return 1;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000972}
973
974
975static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *ioc,
976 Error **errp)
977{
978 ssize_t ret;
979 ssize_t done = 0;
Brandon Carpenter268a53f2017-09-12 08:21:52 -0700980
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +0000981 while (ioc->encoutput.offset > 0) {
982 ret = qio_channel_write(ioc->master,
983 (char *)ioc->encoutput.buffer,
984 ioc->encoutput.offset,
985 errp);
986 if (ret < 0) {
987 if (ret == QIO_CHANNEL_ERR_BLOCK &&
988 done > 0) {
989 return done;
990 } else {
991 return ret;
992 }
993 }
994 buffer_advance(&ioc->encoutput, ret);
995 done += ret;
Daniel P. Berrange57b0cdf2017-10-09 15:34:06 +0100996 if (ioc->pong_remain < ret) {
997 ioc->pong_remain = 0;
998 } else {
999 ioc->pong_remain -= ret;
1000 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001001 }
1002 return done;
1003}
1004
1005
1006static void qio_channel_websock_flush_free(gpointer user_data)
1007{
1008 QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
1009 object_unref(OBJECT(wioc));
1010}
1011
1012static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc);
1013
1014static gboolean qio_channel_websock_flush(QIOChannel *ioc,
1015 GIOCondition condition,
1016 gpointer user_data)
1017{
1018 QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(user_data);
1019 ssize_t ret;
1020
1021 if (condition & G_IO_OUT) {
1022 ret = qio_channel_websock_write_wire(wioc, &wioc->io_err);
1023 if (ret < 0) {
1024 goto cleanup;
1025 }
1026 }
1027
1028 if (condition & G_IO_IN) {
1029 ret = qio_channel_websock_read_wire(wioc, &wioc->io_err);
1030 if (ret < 0) {
1031 goto cleanup;
1032 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001033 }
1034
1035 cleanup:
1036 qio_channel_websock_set_watch(wioc);
1037 return FALSE;
1038}
1039
1040
1041static void qio_channel_websock_unset_watch(QIOChannelWebsock *ioc)
1042{
1043 if (ioc->io_tag) {
1044 g_source_remove(ioc->io_tag);
1045 ioc->io_tag = 0;
1046 }
1047}
1048
1049static void qio_channel_websock_set_watch(QIOChannelWebsock *ioc)
1050{
1051 GIOCondition cond = 0;
1052
1053 qio_channel_websock_unset_watch(ioc);
1054
1055 if (ioc->io_err) {
1056 return;
1057 }
1058
Daniel P. Berrange57b0cdf2017-10-09 15:34:06 +01001059 if (ioc->encoutput.offset) {
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001060 cond |= G_IO_OUT;
1061 }
1062 if (ioc->encinput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER &&
1063 !ioc->io_eof) {
1064 cond |= G_IO_IN;
1065 }
1066
1067 if (cond) {
1068 object_ref(OBJECT(ioc));
1069 ioc->io_tag =
1070 qio_channel_add_watch(ioc->master,
1071 cond,
1072 qio_channel_websock_flush,
1073 ioc,
1074 qio_channel_websock_flush_free);
1075 }
1076}
1077
1078
1079static ssize_t qio_channel_websock_readv(QIOChannel *ioc,
1080 const struct iovec *iov,
1081 size_t niov,
1082 int **fds,
1083 size_t *nfds,
1084 Error **errp)
1085{
1086 QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1087 size_t i;
1088 ssize_t got = 0;
1089 ssize_t ret;
1090
1091 if (wioc->io_err) {
Eduardo Habkoste79ea672017-06-08 10:39:04 -03001092 error_propagate(errp, error_copy(wioc->io_err));
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001093 return -1;
1094 }
1095
1096 if (!wioc->rawinput.offset) {
1097 ret = qio_channel_websock_read_wire(QIO_CHANNEL_WEBSOCK(ioc), errp);
1098 if (ret < 0) {
1099 return ret;
1100 }
1101 }
1102
1103 for (i = 0 ; i < niov ; i++) {
1104 size_t want = iov[i].iov_len;
1105 if (want > (wioc->rawinput.offset - got)) {
1106 want = (wioc->rawinput.offset - got);
1107 }
1108
1109 memcpy(iov[i].iov_base,
1110 wioc->rawinput.buffer + got,
1111 want);
1112 got += want;
1113
1114 if (want < iov[i].iov_len) {
1115 break;
1116 }
1117 }
1118
1119 buffer_advance(&wioc->rawinput, got);
1120 qio_channel_websock_set_watch(wioc);
1121 return got;
1122}
1123
1124
1125static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
1126 const struct iovec *iov,
1127 size_t niov,
1128 int *fds,
1129 size_t nfds,
Leonardo Brasb88651c2022-05-13 03:28:31 -03001130 int flags,
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001131 Error **errp)
1132{
1133 QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +01001134 ssize_t want = iov_size(iov, niov);
1135 ssize_t avail;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001136 ssize_t ret;
1137
1138 if (wioc->io_err) {
Eduardo Habkoste79ea672017-06-08 10:39:04 -03001139 error_propagate(errp, error_copy(wioc->io_err));
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001140 return -1;
1141 }
1142
1143 if (wioc->io_eof) {
1144 error_setg(errp, "%s", "Broken pipe");
1145 return -1;
1146 }
1147
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +01001148 avail = wioc->encoutput.offset >= QIO_CHANNEL_WEBSOCK_MAX_BUFFER ?
1149 0 : (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->encoutput.offset);
1150 if (want > avail) {
1151 want = avail;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001152 }
1153
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +01001154 if (want) {
Daniel P. Berrangefb74e592017-10-09 16:33:20 +01001155 qio_channel_websock_encode(wioc,
1156 QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME,
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +01001157 iov, niov, want);
Daniel P. Berrangebac6c952017-10-09 14:39:17 +01001158 }
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +01001159
1160 /* Even if want == 0, we'll try write_wire in case there's
1161 * pending data we could usefully flush out
1162 */
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001163 ret = qio_channel_websock_write_wire(wioc, errp);
1164 if (ret < 0 &&
1165 ret != QIO_CHANNEL_ERR_BLOCK) {
1166 qio_channel_websock_unset_watch(wioc);
1167 return -1;
1168 }
1169
1170 qio_channel_websock_set_watch(wioc);
1171
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +01001172 if (want == 0) {
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001173 return QIO_CHANNEL_ERR_BLOCK;
1174 }
1175
Daniel P. Berrange8dfd5f92017-10-09 16:54:07 +01001176 return want;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001177}
1178
1179static int qio_channel_websock_set_blocking(QIOChannel *ioc,
1180 bool enabled,
1181 Error **errp)
1182{
1183 QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1184
1185 qio_channel_set_blocking(wioc->master, enabled, errp);
1186 return 0;
1187}
1188
1189static void qio_channel_websock_set_delay(QIOChannel *ioc,
1190 bool enabled)
1191{
1192 QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1193
1194 qio_channel_set_delay(tioc->master, enabled);
1195}
1196
1197static void qio_channel_websock_set_cork(QIOChannel *ioc,
1198 bool enabled)
1199{
1200 QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1201
1202 qio_channel_set_cork(tioc->master, enabled);
1203}
1204
1205static int qio_channel_websock_shutdown(QIOChannel *ioc,
1206 QIOChannelShutdown how,
1207 Error **errp)
1208{
1209 QIOChannelWebsock *tioc = QIO_CHANNEL_WEBSOCK(ioc);
1210
1211 return qio_channel_shutdown(tioc->master, how, errp);
1212}
1213
1214static int qio_channel_websock_close(QIOChannel *ioc,
1215 Error **errp)
1216{
1217 QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1218
Daniel P. Berrange59f183b2017-09-21 11:00:47 +01001219 trace_qio_channel_websock_close(ioc);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001220 return qio_channel_close(wioc->master, errp);
1221}
1222
1223typedef struct QIOChannelWebsockSource QIOChannelWebsockSource;
1224struct QIOChannelWebsockSource {
1225 GSource parent;
1226 QIOChannelWebsock *wioc;
1227 GIOCondition condition;
1228};
1229
1230static gboolean
Brandon Carpentereefa3d82017-09-12 08:21:48 -07001231qio_channel_websock_source_check(GSource *source)
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001232{
1233 QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
1234 GIOCondition cond = 0;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001235
Daniel P. Berrangédd154c42019-02-20 18:22:39 +00001236 if (wsource->wioc->rawinput.offset) {
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001237 cond |= G_IO_IN;
1238 }
Daniel P. Berrangea7b20a82017-10-09 14:43:42 +01001239 if (wsource->wioc->encoutput.offset < QIO_CHANNEL_WEBSOCK_MAX_BUFFER) {
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001240 cond |= G_IO_OUT;
1241 }
Daniel P. Berrangédd154c42019-02-20 18:22:39 +00001242 if (wsource->wioc->io_eof) {
1243 cond |= G_IO_HUP;
1244 }
1245 if (wsource->wioc->io_err) {
1246 cond |= G_IO_ERR;
1247 }
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001248
1249 return cond & wsource->condition;
1250}
1251
1252static gboolean
Brandon Carpentereefa3d82017-09-12 08:21:48 -07001253qio_channel_websock_source_prepare(GSource *source,
1254 gint *timeout)
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001255{
Brandon Carpentereefa3d82017-09-12 08:21:48 -07001256 *timeout = -1;
1257 return qio_channel_websock_source_check(source);
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001258}
1259
1260static gboolean
1261qio_channel_websock_source_dispatch(GSource *source,
1262 GSourceFunc callback,
1263 gpointer user_data)
1264{
1265 QIOChannelFunc func = (QIOChannelFunc)callback;
1266 QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source;
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001267
1268 return (*func)(QIO_CHANNEL(wsource->wioc),
Brandon Carpentereefa3d82017-09-12 08:21:48 -07001269 qio_channel_websock_source_check(source),
Daniel P. Berrange2d1d0e72015-03-04 15:57:41 +00001270 user_data);
1271}
1272
1273static void
1274qio_channel_websock_source_finalize(GSource *source)
1275{
1276 QIOChannelWebsockSource *ssource = (QIOChannelWebsockSource *)source;
1277
1278 object_unref(OBJECT(ssource->wioc));
1279}
1280
1281GSourceFuncs qio_channel_websock_source_funcs = {
1282 qio_channel_websock_source_prepare,
1283 qio_channel_websock_source_check,
1284 qio_channel_websock_source_dispatch,
1285 qio_channel_websock_source_finalize
1286};
1287
1288static GSource *qio_channel_websock_create_watch(QIOChannel *ioc,
1289 GIOCondition condition)
1290{
1291 QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
1292 QIOChannelWebsockSource *ssource;
1293 GSource *source;
1294
1295 source = g_source_new(&qio_channel_websock_source_funcs,
1296 sizeof(QIOChannelWebsockSource));
1297 ssource = (QIOChannelWebsockSource *)source;
1298
1299 ssource->wioc = wioc;
1300 object_ref(OBJECT(wioc));
1301
1302 ssource->condition = condition;
1303
1304 qio_channel_websock_set_watch(wioc);
1305 return source;
1306}
1307
1308static void qio_channel_websock_class_init(ObjectClass *klass,
1309 void *class_data G_GNUC_UNUSED)
1310{
1311 QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
1312
1313 ioc_klass->io_writev = qio_channel_websock_writev;
1314 ioc_klass->io_readv = qio_channel_websock_readv;
1315 ioc_klass->io_set_blocking = qio_channel_websock_set_blocking;
1316 ioc_klass->io_set_cork = qio_channel_websock_set_cork;
1317 ioc_klass->io_set_delay = qio_channel_websock_set_delay;
1318 ioc_klass->io_close = qio_channel_websock_close;
1319 ioc_klass->io_shutdown = qio_channel_websock_shutdown;
1320 ioc_klass->io_create_watch = qio_channel_websock_create_watch;
1321}
1322
1323static const TypeInfo qio_channel_websock_info = {
1324 .parent = TYPE_QIO_CHANNEL,
1325 .name = TYPE_QIO_CHANNEL_WEBSOCK,
1326 .instance_size = sizeof(QIOChannelWebsock),
1327 .instance_finalize = qio_channel_websock_finalize,
1328 .class_init = qio_channel_websock_class_init,
1329};
1330
1331static void qio_channel_websock_register_types(void)
1332{
1333 type_register_static(&qio_channel_websock_info);
1334}
1335
1336type_init(qio_channel_websock_register_types);