io/channel-socket.c

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