1 /* 2 * QEMU I/O channels sockets driver 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 "io/channel-socket.h" 24 #include "io/channel-watch.h" 25 #include "trace.h" 26 #include "qapi/clone-visitor.h" 27 28 #define SOCKET_MAX_FDS 16 29 30 SocketAddress * 31 qio_channel_socket_get_local_address(QIOChannelSocket *ioc, 32 Error **errp) 33 { 34 return socket_sockaddr_to_address(&ioc->localAddr, 35 ioc->localAddrLen, 36 errp); 37 } 38 39 SocketAddress * 40 qio_channel_socket_get_remote_address(QIOChannelSocket *ioc, 41 Error **errp) 42 { 43 return socket_sockaddr_to_address(&ioc->remoteAddr, 44 ioc->remoteAddrLen, 45 errp); 46 } 47 48 QIOChannelSocket * 49 qio_channel_socket_new(void) 50 { 51 QIOChannelSocket *sioc; 52 QIOChannel *ioc; 53 54 sioc = QIO_CHANNEL_SOCKET(object_new(TYPE_QIO_CHANNEL_SOCKET)); 55 sioc->fd = -1; 56 57 ioc = QIO_CHANNEL(sioc); 58 qio_channel_set_feature(ioc, QIO_CHANNEL_FEATURE_SHUTDOWN); 59 60 #ifdef WIN32 61 ioc->event = CreateEvent(NULL, FALSE, FALSE, NULL); 62 #endif 63 64 trace_qio_channel_socket_new(sioc); 65 66 return sioc; 67 } 68 69 70 static int 71 qio_channel_socket_set_fd(QIOChannelSocket *sioc, 72 int fd, 73 Error **errp) 74 { 75 if (sioc->fd != -1) { 76 error_setg(errp, "Socket is already open"); 77 return -1; 78 } 79 80 sioc->fd = fd; 81 sioc->remoteAddrLen = sizeof(sioc->remoteAddr); 82 sioc->localAddrLen = sizeof(sioc->localAddr); 83 84 85 if (getpeername(fd, (struct sockaddr *)&sioc->remoteAddr, 86 &sioc->remoteAddrLen) < 0) { 87 if (errno == ENOTCONN) { 88 memset(&sioc->remoteAddr, 0, sizeof(sioc->remoteAddr)); 89 sioc->remoteAddrLen = sizeof(sioc->remoteAddr); 90 } else { 91 error_setg_errno(errp, errno, 92 "Unable to query remote socket address"); 93 goto error; 94 } 95 } 96 97 if (getsockname(fd, (struct sockaddr *)&sioc->localAddr, 98 &sioc->localAddrLen) < 0) { 99 error_setg_errno(errp, errno, 100 "Unable to query local socket address"); 101 goto error; 102 } 103 104 #ifndef WIN32 105 if (sioc->localAddr.ss_family == AF_UNIX) { 106 QIOChannel *ioc = QIO_CHANNEL(sioc); 107 qio_channel_set_feature(ioc, QIO_CHANNEL_FEATURE_FD_PASS); 108 } 109 #endif /* WIN32 */ 110 111 return 0; 112 113 error: 114 sioc->fd = -1; /* Let the caller close FD on failure */ 115 return -1; 116 } 117 118 QIOChannelSocket * 119 qio_channel_socket_new_fd(int fd, 120 Error **errp) 121 { 122 QIOChannelSocket *ioc; 123 124 ioc = qio_channel_socket_new(); 125 if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) { 126 object_unref(OBJECT(ioc)); 127 return NULL; 128 } 129 130 trace_qio_channel_socket_new_fd(ioc, fd); 131 132 return ioc; 133 } 134 135 136 int qio_channel_socket_connect_sync(QIOChannelSocket *ioc, 137 SocketAddress *addr, 138 Error **errp) 139 { 140 int fd; 141 142 trace_qio_channel_socket_connect_sync(ioc, addr); 143 fd = socket_connect(addr, errp); 144 if (fd < 0) { 145 trace_qio_channel_socket_connect_fail(ioc); 146 return -1; 147 } 148 149 trace_qio_channel_socket_connect_complete(ioc, fd); 150 if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) { 151 close(fd); 152 return -1; 153 } 154 155 return 0; 156 } 157 158 159 static void qio_channel_socket_connect_worker(QIOTask *task, 160 gpointer opaque) 161 { 162 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); 163 SocketAddress *addr = opaque; 164 Error *err = NULL; 165 166 qio_channel_socket_connect_sync(ioc, addr, &err); 167 168 qio_task_set_error(task, err); 169 } 170 171 172 void qio_channel_socket_connect_async(QIOChannelSocket *ioc, 173 SocketAddress *addr, 174 QIOTaskFunc callback, 175 gpointer opaque, 176 GDestroyNotify destroy) 177 { 178 QIOTask *task = qio_task_new( 179 OBJECT(ioc), callback, opaque, destroy); 180 SocketAddress *addrCopy; 181 182 addrCopy = QAPI_CLONE(SocketAddress, addr); 183 184 /* socket_connect() does a non-blocking connect(), but it 185 * still blocks in DNS lookups, so we must use a thread */ 186 trace_qio_channel_socket_connect_async(ioc, addr); 187 qio_task_run_in_thread(task, 188 qio_channel_socket_connect_worker, 189 addrCopy, 190 (GDestroyNotify)qapi_free_SocketAddress); 191 } 192 193 194 int qio_channel_socket_listen_sync(QIOChannelSocket *ioc, 195 SocketAddress *addr, 196 Error **errp) 197 { 198 int fd; 199 200 trace_qio_channel_socket_listen_sync(ioc, addr); 201 fd = socket_listen(addr, errp); 202 if (fd < 0) { 203 trace_qio_channel_socket_listen_fail(ioc); 204 return -1; 205 } 206 207 trace_qio_channel_socket_listen_complete(ioc, fd); 208 if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) { 209 close(fd); 210 return -1; 211 } 212 qio_channel_set_feature(QIO_CHANNEL(ioc), QIO_CHANNEL_FEATURE_LISTEN); 213 214 return 0; 215 } 216 217 218 static void qio_channel_socket_listen_worker(QIOTask *task, 219 gpointer opaque) 220 { 221 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); 222 SocketAddress *addr = opaque; 223 Error *err = NULL; 224 225 qio_channel_socket_listen_sync(ioc, addr, &err); 226 227 qio_task_set_error(task, err); 228 } 229 230 231 void qio_channel_socket_listen_async(QIOChannelSocket *ioc, 232 SocketAddress *addr, 233 QIOTaskFunc callback, 234 gpointer opaque, 235 GDestroyNotify destroy) 236 { 237 QIOTask *task = qio_task_new( 238 OBJECT(ioc), callback, opaque, destroy); 239 SocketAddress *addrCopy; 240 241 addrCopy = QAPI_CLONE(SocketAddress, addr); 242 243 /* socket_listen() blocks in DNS lookups, so we must use a thread */ 244 trace_qio_channel_socket_listen_async(ioc, addr); 245 qio_task_run_in_thread(task, 246 qio_channel_socket_listen_worker, 247 addrCopy, 248 (GDestroyNotify)qapi_free_SocketAddress); 249 } 250 251 252 int qio_channel_socket_dgram_sync(QIOChannelSocket *ioc, 253 SocketAddress *localAddr, 254 SocketAddress *remoteAddr, 255 Error **errp) 256 { 257 int fd; 258 259 trace_qio_channel_socket_dgram_sync(ioc, localAddr, remoteAddr); 260 fd = socket_dgram(remoteAddr, localAddr, errp); 261 if (fd < 0) { 262 trace_qio_channel_socket_dgram_fail(ioc); 263 return -1; 264 } 265 266 trace_qio_channel_socket_dgram_complete(ioc, fd); 267 if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) { 268 close(fd); 269 return -1; 270 } 271 272 return 0; 273 } 274 275 276 struct QIOChannelSocketDGramWorkerData { 277 SocketAddress *localAddr; 278 SocketAddress *remoteAddr; 279 }; 280 281 282 static void qio_channel_socket_dgram_worker_free(gpointer opaque) 283 { 284 struct QIOChannelSocketDGramWorkerData *data = opaque; 285 qapi_free_SocketAddress(data->localAddr); 286 qapi_free_SocketAddress(data->remoteAddr); 287 g_free(data); 288 } 289 290 static void qio_channel_socket_dgram_worker(QIOTask *task, 291 gpointer opaque) 292 { 293 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); 294 struct QIOChannelSocketDGramWorkerData *data = opaque; 295 Error *err = NULL; 296 297 /* socket_dgram() blocks in DNS lookups, so we must use a thread */ 298 qio_channel_socket_dgram_sync(ioc, data->localAddr, 299 data->remoteAddr, &err); 300 301 qio_task_set_error(task, err); 302 } 303 304 305 void qio_channel_socket_dgram_async(QIOChannelSocket *ioc, 306 SocketAddress *localAddr, 307 SocketAddress *remoteAddr, 308 QIOTaskFunc callback, 309 gpointer opaque, 310 GDestroyNotify destroy) 311 { 312 QIOTask *task = qio_task_new( 313 OBJECT(ioc), callback, opaque, destroy); 314 struct QIOChannelSocketDGramWorkerData *data = g_new0( 315 struct QIOChannelSocketDGramWorkerData, 1); 316 317 data->localAddr = QAPI_CLONE(SocketAddress, localAddr); 318 data->remoteAddr = QAPI_CLONE(SocketAddress, remoteAddr); 319 320 trace_qio_channel_socket_dgram_async(ioc, localAddr, remoteAddr); 321 qio_task_run_in_thread(task, 322 qio_channel_socket_dgram_worker, 323 data, 324 qio_channel_socket_dgram_worker_free); 325 } 326 327 328 QIOChannelSocket * 329 qio_channel_socket_accept(QIOChannelSocket *ioc, 330 Error **errp) 331 { 332 QIOChannelSocket *cioc; 333 334 cioc = qio_channel_socket_new(); 335 cioc->remoteAddrLen = sizeof(ioc->remoteAddr); 336 cioc->localAddrLen = sizeof(ioc->localAddr); 337 338 retry: 339 trace_qio_channel_socket_accept(ioc); 340 cioc->fd = qemu_accept(ioc->fd, (struct sockaddr *)&cioc->remoteAddr, 341 &cioc->remoteAddrLen); 342 if (cioc->fd < 0) { 343 if (errno == EINTR) { 344 goto retry; 345 } 346 error_setg_errno(errp, errno, "Unable to accept connection"); 347 trace_qio_channel_socket_accept_fail(ioc); 348 goto error; 349 } 350 351 if (getsockname(cioc->fd, (struct sockaddr *)&cioc->localAddr, 352 &cioc->localAddrLen) < 0) { 353 error_setg_errno(errp, errno, 354 "Unable to query local socket address"); 355 goto error; 356 } 357 358 #ifndef WIN32 359 if (cioc->localAddr.ss_family == AF_UNIX) { 360 QIOChannel *ioc_local = QIO_CHANNEL(cioc); 361 qio_channel_set_feature(ioc_local, QIO_CHANNEL_FEATURE_FD_PASS); 362 } 363 #endif /* WIN32 */ 364 365 trace_qio_channel_socket_accept_complete(ioc, cioc, cioc->fd); 366 return cioc; 367 368 error: 369 object_unref(OBJECT(cioc)); 370 return NULL; 371 } 372 373 static void qio_channel_socket_init(Object *obj) 374 { 375 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(obj); 376 ioc->fd = -1; 377 } 378 379 static void qio_channel_socket_finalize(Object *obj) 380 { 381 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(obj); 382 383 if (ioc->fd != -1) { 384 QIOChannel *ioc_local = QIO_CHANNEL(ioc); 385 if (qio_channel_has_feature(ioc_local, QIO_CHANNEL_FEATURE_LISTEN)) { 386 Error *err = NULL; 387 388 socket_listen_cleanup(ioc->fd, &err); 389 if (err) { 390 error_report_err(err); 391 err = NULL; 392 } 393 } 394 #ifdef WIN32 395 WSAEventSelect(ioc->fd, NULL, 0); 396 #endif 397 closesocket(ioc->fd); 398 ioc->fd = -1; 399 } 400 } 401 402 403 #ifndef WIN32 404 static void qio_channel_socket_copy_fds(struct msghdr *msg, 405 int **fds, size_t *nfds) 406 { 407 struct cmsghdr *cmsg; 408 409 *nfds = 0; 410 *fds = NULL; 411 412 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) { 413 int fd_size, i; 414 int gotfds; 415 416 if (cmsg->cmsg_len < CMSG_LEN(sizeof(int)) || 417 cmsg->cmsg_level != SOL_SOCKET || 418 cmsg->cmsg_type != SCM_RIGHTS) { 419 continue; 420 } 421 422 fd_size = cmsg->cmsg_len - CMSG_LEN(0); 423 424 if (!fd_size) { 425 continue; 426 } 427 428 gotfds = fd_size / sizeof(int); 429 *fds = g_renew(int, *fds, *nfds + gotfds); 430 memcpy(*fds + *nfds, CMSG_DATA(cmsg), fd_size); 431 432 for (i = 0; i < gotfds; i++) { 433 int fd = (*fds)[*nfds + i]; 434 if (fd < 0) { 435 continue; 436 } 437 438 /* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */ 439 qemu_set_block(fd); 440 441 #ifndef MSG_CMSG_CLOEXEC 442 qemu_set_cloexec(fd); 443 #endif 444 } 445 *nfds += gotfds; 446 } 447 } 448 449 450 static ssize_t qio_channel_socket_readv(QIOChannel *ioc, 451 const struct iovec *iov, 452 size_t niov, 453 int **fds, 454 size_t *nfds, 455 Error **errp) 456 { 457 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 458 ssize_t ret; 459 struct msghdr msg = { NULL, }; 460 char control[CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)]; 461 int sflags = 0; 462 463 memset(control, 0, CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)); 464 465 #ifdef MSG_CMSG_CLOEXEC 466 sflags |= MSG_CMSG_CLOEXEC; 467 #endif 468 469 msg.msg_iov = (struct iovec *)iov; 470 msg.msg_iovlen = niov; 471 if (fds && nfds) { 472 msg.msg_control = control; 473 msg.msg_controllen = sizeof(control); 474 } 475 476 retry: 477 ret = recvmsg(sioc->fd, &msg, sflags); 478 if (ret < 0) { 479 if (errno == EAGAIN) { 480 return QIO_CHANNEL_ERR_BLOCK; 481 } 482 if (errno == EINTR) { 483 goto retry; 484 } 485 486 error_setg_errno(errp, errno, 487 "Unable to read from socket"); 488 return -1; 489 } 490 491 if (fds && nfds) { 492 qio_channel_socket_copy_fds(&msg, fds, nfds); 493 } 494 495 return ret; 496 } 497 498 static ssize_t qio_channel_socket_writev(QIOChannel *ioc, 499 const struct iovec *iov, 500 size_t niov, 501 int *fds, 502 size_t nfds, 503 Error **errp) 504 { 505 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 506 ssize_t ret; 507 struct msghdr msg = { NULL, }; 508 char control[CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)]; 509 size_t fdsize = sizeof(int) * nfds; 510 struct cmsghdr *cmsg; 511 512 memset(control, 0, CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)); 513 514 msg.msg_iov = (struct iovec *)iov; 515 msg.msg_iovlen = niov; 516 517 if (nfds) { 518 if (nfds > SOCKET_MAX_FDS) { 519 error_setg_errno(errp, EINVAL, 520 "Only %d FDs can be sent, got %zu", 521 SOCKET_MAX_FDS, nfds); 522 return -1; 523 } 524 525 msg.msg_control = control; 526 msg.msg_controllen = CMSG_SPACE(sizeof(int) * nfds); 527 528 cmsg = CMSG_FIRSTHDR(&msg); 529 cmsg->cmsg_len = CMSG_LEN(fdsize); 530 cmsg->cmsg_level = SOL_SOCKET; 531 cmsg->cmsg_type = SCM_RIGHTS; 532 memcpy(CMSG_DATA(cmsg), fds, fdsize); 533 } 534 535 retry: 536 ret = sendmsg(sioc->fd, &msg, 0); 537 if (ret <= 0) { 538 if (errno == EAGAIN) { 539 return QIO_CHANNEL_ERR_BLOCK; 540 } 541 if (errno == EINTR) { 542 goto retry; 543 } 544 error_setg_errno(errp, errno, 545 "Unable to write to socket"); 546 return -1; 547 } 548 return ret; 549 } 550 #else /* WIN32 */ 551 static ssize_t qio_channel_socket_readv(QIOChannel *ioc, 552 const struct iovec *iov, 553 size_t niov, 554 int **fds, 555 size_t *nfds, 556 Error **errp) 557 { 558 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 559 ssize_t done = 0; 560 ssize_t i; 561 562 for (i = 0; i < niov; i++) { 563 ssize_t ret; 564 retry: 565 ret = recv(sioc->fd, 566 iov[i].iov_base, 567 iov[i].iov_len, 568 0); 569 if (ret < 0) { 570 if (errno == EAGAIN) { 571 if (done) { 572 return done; 573 } else { 574 return QIO_CHANNEL_ERR_BLOCK; 575 } 576 } else if (errno == EINTR) { 577 goto retry; 578 } else { 579 error_setg_errno(errp, errno, 580 "Unable to read from socket"); 581 return -1; 582 } 583 } 584 done += ret; 585 if (ret < iov[i].iov_len) { 586 return done; 587 } 588 } 589 590 return done; 591 } 592 593 static ssize_t qio_channel_socket_writev(QIOChannel *ioc, 594 const struct iovec *iov, 595 size_t niov, 596 int *fds, 597 size_t nfds, 598 Error **errp) 599 { 600 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 601 ssize_t done = 0; 602 ssize_t i; 603 604 for (i = 0; i < niov; i++) { 605 ssize_t ret; 606 retry: 607 ret = send(sioc->fd, 608 iov[i].iov_base, 609 iov[i].iov_len, 610 0); 611 if (ret < 0) { 612 if (errno == EAGAIN) { 613 if (done) { 614 return done; 615 } else { 616 return QIO_CHANNEL_ERR_BLOCK; 617 } 618 } else if (errno == EINTR) { 619 goto retry; 620 } else { 621 error_setg_errno(errp, errno, 622 "Unable to write to socket"); 623 return -1; 624 } 625 } 626 done += ret; 627 if (ret < iov[i].iov_len) { 628 return done; 629 } 630 } 631 632 return done; 633 } 634 #endif /* WIN32 */ 635 636 static int 637 qio_channel_socket_set_blocking(QIOChannel *ioc, 638 bool enabled, 639 Error **errp) 640 { 641 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 642 643 if (enabled) { 644 qemu_set_block(sioc->fd); 645 } else { 646 qemu_set_nonblock(sioc->fd); 647 } 648 return 0; 649 } 650 651 652 static void 653 qio_channel_socket_set_delay(QIOChannel *ioc, 654 bool enabled) 655 { 656 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 657 int v = enabled ? 0 : 1; 658 659 qemu_setsockopt(sioc->fd, 660 IPPROTO_TCP, TCP_NODELAY, 661 &v, sizeof(v)); 662 } 663 664 665 static void 666 qio_channel_socket_set_cork(QIOChannel *ioc, 667 bool enabled) 668 { 669 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 670 int v = enabled ? 1 : 0; 671 672 socket_set_cork(sioc->fd, v); 673 } 674 675 676 static int 677 qio_channel_socket_close(QIOChannel *ioc, 678 Error **errp) 679 { 680 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 681 682 if (sioc->fd != -1) { 683 #ifdef WIN32 684 WSAEventSelect(sioc->fd, NULL, 0); 685 #endif 686 if (closesocket(sioc->fd) < 0) { 687 sioc->fd = -1; 688 error_setg_errno(errp, errno, 689 "Unable to close socket"); 690 return -1; 691 } 692 sioc->fd = -1; 693 } 694 return 0; 695 } 696 697 static int 698 qio_channel_socket_shutdown(QIOChannel *ioc, 699 QIOChannelShutdown how, 700 Error **errp) 701 { 702 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 703 int sockhow; 704 705 switch (how) { 706 case QIO_CHANNEL_SHUTDOWN_READ: 707 sockhow = SHUT_RD; 708 break; 709 case QIO_CHANNEL_SHUTDOWN_WRITE: 710 sockhow = SHUT_WR; 711 break; 712 case QIO_CHANNEL_SHUTDOWN_BOTH: 713 default: 714 sockhow = SHUT_RDWR; 715 break; 716 } 717 718 if (shutdown(sioc->fd, sockhow) < 0) { 719 error_setg_errno(errp, errno, 720 "Unable to shutdown socket"); 721 return -1; 722 } 723 return 0; 724 } 725 726 static void qio_channel_socket_set_aio_fd_handler(QIOChannel *ioc, 727 AioContext *ctx, 728 IOHandler *io_read, 729 IOHandler *io_write, 730 void *opaque) 731 { 732 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 733 aio_set_fd_handler(ctx, sioc->fd, false, io_read, io_write, NULL, opaque); 734 } 735 736 static GSource *qio_channel_socket_create_watch(QIOChannel *ioc, 737 GIOCondition condition) 738 { 739 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 740 return qio_channel_create_socket_watch(ioc, 741 sioc->fd, 742 condition); 743 } 744 745 static void qio_channel_socket_class_init(ObjectClass *klass, 746 void *class_data G_GNUC_UNUSED) 747 { 748 QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass); 749 750 ioc_klass->io_writev = qio_channel_socket_writev; 751 ioc_klass->io_readv = qio_channel_socket_readv; 752 ioc_klass->io_set_blocking = qio_channel_socket_set_blocking; 753 ioc_klass->io_close = qio_channel_socket_close; 754 ioc_klass->io_shutdown = qio_channel_socket_shutdown; 755 ioc_klass->io_set_cork = qio_channel_socket_set_cork; 756 ioc_klass->io_set_delay = qio_channel_socket_set_delay; 757 ioc_klass->io_create_watch = qio_channel_socket_create_watch; 758 ioc_klass->io_set_aio_fd_handler = qio_channel_socket_set_aio_fd_handler; 759 } 760 761 static const TypeInfo qio_channel_socket_info = { 762 .parent = TYPE_QIO_CHANNEL, 763 .name = TYPE_QIO_CHANNEL_SOCKET, 764 .instance_size = sizeof(QIOChannelSocket), 765 .instance_init = qio_channel_socket_init, 766 .instance_finalize = qio_channel_socket_finalize, 767 .class_init = qio_channel_socket_class_init, 768 }; 769 770 static void qio_channel_socket_register_types(void) 771 { 772 type_register_static(&qio_channel_socket_info); 773 } 774 775 type_init(qio_channel_socket_register_types); 776