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