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