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