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