xref: /qemu/io/channel-socket.c (revision 20daa90a) 
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, NULL, NULL);
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(object_new(TYPE_QIO_CHANNEL_SOCKET));
335     cioc->fd = -1;
336     cioc->remoteAddrLen = sizeof(ioc->remoteAddr);
337     cioc->localAddrLen = sizeof(ioc->localAddr);
338 
339 #ifdef WIN32
340     QIO_CHANNEL(cioc)->event = CreateEvent(NULL, FALSE, FALSE, NULL);
341 #endif
342 
343 
344  retry:
345     trace_qio_channel_socket_accept(ioc);
346     cioc->fd = qemu_accept(ioc->fd, (struct sockaddr *)&cioc->remoteAddr,
347                            &cioc->remoteAddrLen);
348     if (cioc->fd < 0) {
349         trace_qio_channel_socket_accept_fail(ioc);
350         if (errno == EINTR) {
351             goto retry;
352         }
353         goto error;
354     }
355 
356     if (getsockname(cioc->fd, (struct sockaddr *)&cioc->localAddr,
357                     &cioc->localAddrLen) < 0) {
358         error_setg_errno(errp, errno,
359                          "Unable to query local socket address");
360         goto error;
361     }
362 
363 #ifndef WIN32
364     if (cioc->localAddr.ss_family == AF_UNIX) {
365         QIOChannel *ioc_local = QIO_CHANNEL(cioc);
366         qio_channel_set_feature(ioc_local, QIO_CHANNEL_FEATURE_FD_PASS);
367     }
368 #endif /* WIN32 */
369 
370     trace_qio_channel_socket_accept_complete(ioc, cioc, cioc->fd);
371     return cioc;
372 
373  error:
374     object_unref(OBJECT(cioc));
375     return NULL;
376 }
377 
378 static void qio_channel_socket_init(Object *obj)
379 {
380     QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(obj);
381     ioc->fd = -1;
382 }
383 
384 static void qio_channel_socket_finalize(Object *obj)
385 {
386     QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(obj);
387 
388     if (ioc->fd != -1) {
389         QIOChannel *ioc_local = QIO_CHANNEL(ioc);
390         if (qio_channel_has_feature(ioc_local, QIO_CHANNEL_FEATURE_LISTEN)) {
391             Error *err = NULL;
392 
393             socket_listen_cleanup(ioc->fd, &err);
394             if (err) {
395                 error_report_err(err);
396                 err = NULL;
397             }
398         }
399 #ifdef WIN32
400         WSAEventSelect(ioc->fd, NULL, 0);
401 #endif
402         closesocket(ioc->fd);
403         ioc->fd = -1;
404     }
405 }
406 
407 
408 #ifndef WIN32
409 static void qio_channel_socket_copy_fds(struct msghdr *msg,
410                                         int **fds, size_t *nfds)
411 {
412     struct cmsghdr *cmsg;
413 
414     *nfds = 0;
415     *fds = NULL;
416 
417     for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
418         int fd_size, i;
419         int gotfds;
420 
421         if (cmsg->cmsg_len < CMSG_LEN(sizeof(int)) ||
422             cmsg->cmsg_level != SOL_SOCKET ||
423             cmsg->cmsg_type != SCM_RIGHTS) {
424             continue;
425         }
426 
427         fd_size = cmsg->cmsg_len - CMSG_LEN(0);
428 
429         if (!fd_size) {
430             continue;
431         }
432 
433         gotfds = fd_size / sizeof(int);
434         *fds = g_renew(int, *fds, *nfds + gotfds);
435         memcpy(*fds + *nfds, CMSG_DATA(cmsg), fd_size);
436 
437         for (i = 0; i < gotfds; i++) {
438             int fd = (*fds)[*nfds + i];
439             if (fd < 0) {
440                 continue;
441             }
442 
443             /* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */
444             qemu_set_block(fd);
445 
446 #ifndef MSG_CMSG_CLOEXEC
447             qemu_set_cloexec(fd);
448 #endif
449         }
450         *nfds += gotfds;
451     }
452 }
453 
454 
455 static ssize_t qio_channel_socket_readv(QIOChannel *ioc,
456                                         const struct iovec *iov,
457                                         size_t niov,
458                                         int **fds,
459                                         size_t *nfds,
460                                         Error **errp)
461 {
462     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
463     ssize_t ret;
464     struct msghdr msg = { NULL, };
465     char control[CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)];
466     int sflags = 0;
467 
468     memset(control, 0, CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS));
469 
470 #ifdef MSG_CMSG_CLOEXEC
471     sflags |= MSG_CMSG_CLOEXEC;
472 #endif
473 
474     msg.msg_iov = (struct iovec *)iov;
475     msg.msg_iovlen = niov;
476     if (fds && nfds) {
477         msg.msg_control = control;
478         msg.msg_controllen = sizeof(control);
479     }
480 
481  retry:
482     ret = recvmsg(sioc->fd, &msg, sflags);
483     if (ret < 0) {
484         if (errno == EAGAIN) {
485             return QIO_CHANNEL_ERR_BLOCK;
486         }
487         if (errno == EINTR) {
488             goto retry;
489         }
490 
491         error_setg_errno(errp, errno,
492                          "Unable to read from socket");
493         return -1;
494     }
495 
496     if (fds && nfds) {
497         qio_channel_socket_copy_fds(&msg, fds, nfds);
498     }
499 
500     return ret;
501 }
502 
503 static ssize_t qio_channel_socket_writev(QIOChannel *ioc,
504                                          const struct iovec *iov,
505                                          size_t niov,
506                                          int *fds,
507                                          size_t nfds,
508                                          Error **errp)
509 {
510     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
511     ssize_t ret;
512     struct msghdr msg = { NULL, };
513     char control[CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)];
514     size_t fdsize = sizeof(int) * nfds;
515     struct cmsghdr *cmsg;
516 
517     memset(control, 0, CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS));
518 
519     msg.msg_iov = (struct iovec *)iov;
520     msg.msg_iovlen = niov;
521 
522     if (nfds) {
523         if (nfds > SOCKET_MAX_FDS) {
524             error_setg_errno(errp, EINVAL,
525                              "Only %d FDs can be sent, got %zu",
526                              SOCKET_MAX_FDS, nfds);
527             return -1;
528         }
529 
530         msg.msg_control = control;
531         msg.msg_controllen = CMSG_SPACE(sizeof(int) * nfds);
532 
533         cmsg = CMSG_FIRSTHDR(&msg);
534         cmsg->cmsg_len = CMSG_LEN(fdsize);
535         cmsg->cmsg_level = SOL_SOCKET;
536         cmsg->cmsg_type = SCM_RIGHTS;
537         memcpy(CMSG_DATA(cmsg), fds, fdsize);
538     }
539 
540  retry:
541     ret = sendmsg(sioc->fd, &msg, 0);
542     if (ret <= 0) {
543         if (errno == EAGAIN) {
544             return QIO_CHANNEL_ERR_BLOCK;
545         }
546         if (errno == EINTR) {
547             goto retry;
548         }
549         error_setg_errno(errp, errno,
550                          "Unable to write to socket");
551         return -1;
552     }
553     return ret;
554 }
555 #else /* WIN32 */
556 static ssize_t qio_channel_socket_readv(QIOChannel *ioc,
557                                         const struct iovec *iov,
558                                         size_t niov,
559                                         int **fds,
560                                         size_t *nfds,
561                                         Error **errp)
562 {
563     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
564     ssize_t done = 0;
565     ssize_t i;
566 
567     for (i = 0; i < niov; i++) {
568         ssize_t ret;
569     retry:
570         ret = recv(sioc->fd,
571                    iov[i].iov_base,
572                    iov[i].iov_len,
573                    0);
574         if (ret < 0) {
575             if (errno == EAGAIN) {
576                 if (done) {
577                     return done;
578                 } else {
579                     return QIO_CHANNEL_ERR_BLOCK;
580                 }
581             } else if (errno == EINTR) {
582                 goto retry;
583             } else {
584                 error_setg_errno(errp, errno,
585                                  "Unable to read from socket");
586                 return -1;
587             }
588         }
589         done += ret;
590         if (ret < iov[i].iov_len) {
591             return done;
592         }
593     }
594 
595     return done;
596 }
597 
598 static ssize_t qio_channel_socket_writev(QIOChannel *ioc,
599                                          const struct iovec *iov,
600                                          size_t niov,
601                                          int *fds,
602                                          size_t nfds,
603                                          Error **errp)
604 {
605     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
606     ssize_t done = 0;
607     ssize_t i;
608 
609     for (i = 0; i < niov; i++) {
610         ssize_t ret;
611     retry:
612         ret = send(sioc->fd,
613                    iov[i].iov_base,
614                    iov[i].iov_len,
615                    0);
616         if (ret < 0) {
617             if (errno == EAGAIN) {
618                 if (done) {
619                     return done;
620                 } else {
621                     return QIO_CHANNEL_ERR_BLOCK;
622                 }
623             } else if (errno == EINTR) {
624                 goto retry;
625             } else {
626                 error_setg_errno(errp, errno,
627                                  "Unable to write to socket");
628                 return -1;
629             }
630         }
631         done += ret;
632         if (ret < iov[i].iov_len) {
633             return done;
634         }
635     }
636 
637     return done;
638 }
639 #endif /* WIN32 */
640 
641 static int
642 qio_channel_socket_set_blocking(QIOChannel *ioc,
643                                 bool enabled,
644                                 Error **errp)
645 {
646     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
647 
648     if (enabled) {
649         qemu_set_block(sioc->fd);
650     } else {
651         qemu_set_nonblock(sioc->fd);
652 #ifdef WIN32
653         WSAEventSelect(sioc->fd, ioc->event,
654                        FD_READ | FD_ACCEPT | FD_CLOSE |
655                        FD_CONNECT | FD_WRITE | FD_OOB);
656 #endif
657     }
658     return 0;
659 }
660 
661 
662 static void
663 qio_channel_socket_set_delay(QIOChannel *ioc,
664                              bool enabled)
665 {
666     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
667     int v = enabled ? 0 : 1;
668 
669     qemu_setsockopt(sioc->fd,
670                     IPPROTO_TCP, TCP_NODELAY,
671                     &v, sizeof(v));
672 }
673 
674 
675 static void
676 qio_channel_socket_set_cork(QIOChannel *ioc,
677                             bool enabled)
678 {
679     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
680     int v = enabled ? 1 : 0;
681 
682     socket_set_cork(sioc->fd, v);
683 }
684 
685 
686 static int
687 qio_channel_socket_close(QIOChannel *ioc,
688                          Error **errp)
689 {
690     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
691 
692     if (sioc->fd != -1) {
693 #ifdef WIN32
694         WSAEventSelect(sioc->fd, NULL, 0);
695 #endif
696         if (closesocket(sioc->fd) < 0) {
697             sioc->fd = -1;
698             error_setg_errno(errp, errno,
699                              "Unable to close socket");
700             return -1;
701         }
702         sioc->fd = -1;
703     }
704     return 0;
705 }
706 
707 static int
708 qio_channel_socket_shutdown(QIOChannel *ioc,
709                             QIOChannelShutdown how,
710                             Error **errp)
711 {
712     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
713     int sockhow;
714 
715     switch (how) {
716     case QIO_CHANNEL_SHUTDOWN_READ:
717         sockhow = SHUT_RD;
718         break;
719     case QIO_CHANNEL_SHUTDOWN_WRITE:
720         sockhow = SHUT_WR;
721         break;
722     case QIO_CHANNEL_SHUTDOWN_BOTH:
723     default:
724         sockhow = SHUT_RDWR;
725         break;
726     }
727 
728     if (shutdown(sioc->fd, sockhow) < 0) {
729         error_setg_errno(errp, errno,
730                          "Unable to shutdown socket");
731         return -1;
732     }
733     return 0;
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 }
759 
760 static const TypeInfo qio_channel_socket_info = {
761     .parent = TYPE_QIO_CHANNEL,
762     .name = TYPE_QIO_CHANNEL_SOCKET,
763     .instance_size = sizeof(QIOChannelSocket),
764     .instance_init = qio_channel_socket_init,
765     .instance_finalize = qio_channel_socket_finalize,
766     .class_init = qio_channel_socket_class_init,
767 };
768 
769 static void qio_channel_socket_register_types(void)
770 {
771     type_register_static(&qio_channel_socket_info);
772 }
773 
774 type_init(qio_channel_socket_register_types);
775