gio/gsocket.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2008 Christian Kellner, Samuel Cormier-Iijima
   4  * Copyright © 2009 Codethink Limited
   5  * Copyright © 2009 Red Hat, Inc
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General
  18  * Public License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  * Authors: Christian Kellner <gicmo@gnome.org>
  23  *          Samuel Cormier-Iijima <sciyoshi@gmail.com>
  24  *          Ryan Lortie <desrt@desrt.ca>
  25  *          Alexander Larsson <alexl@redhat.com>
  26  */
  27
  28 #include "config.h"
  29
  30 #include "gsocket.h"
  31
  32 #ifdef G_OS_UNIX
  33 #include "glib-unix.h"
  34 #endif
  35
  36 #include <errno.h>
  37 #include <signal.h>
  38 #include <string.h>
  39 #include <stdlib.h>
  40
  41 #ifndef G_OS_WIN32
  42 # include <fcntl.h>
  43 # include <unistd.h>
  44 # include <sys/ioctl.h>
  45 #endif
  46
  47 #ifdef HAVE_SYS_UIO_H
  48 #include <sys/uio.h>
  49 #endif
  50
  51 #include "gcancellable.h"
  52 #include "gioenumtypes.h"
  53 #include "ginetaddress.h"
  54 #include "ginitable.h"
  55 #include "gioerror.h"
  56 #include "gioenums.h"
  57 #include "gioerror.h"
  58 #include "gnetworkingprivate.h"
  59 #include "gsocketaddress.h"
  60 #include "gsocketcontrolmessage.h"
  61 #include "gcredentials.h"
  62 #include "glibintl.h"
  63
  64 /**
  65  * SECTION:gsocket
  66  * @short_description: Low-level socket object
  67  * @include: gio/gio.h
  68  * @see_also: #GInitable
  69  *
  70  * A #GSocket is a low-level networking primitive. It is a more or less
  71  * direct mapping of the BSD socket API in a portable GObject based API.
  72  * It supports both the UNIX socket implementations and winsock2 on Windows.
  73  *
  74  * #GSocket is the platform independent base upon which the higher level
  75  * network primitives are based. Applications are not typically meant to
  76  * use it directly, but rather through classes like #GSocketClient,
  77  * #GSocketService and #GSocketConnection. However there may be cases where
  78  * direct use of #GSocket is useful.
  79  *
  80  * #GSocket implements the #GInitable interface, so if it is manually constructed
  81  * by e.g. g_object_new() you must call g_initable_init() and check the
  82  * results before using the object. This is done automatically in
  83  * g_socket_new() and g_socket_new_from_fd(), so these functions can return
  84  * %NULL.
  85  *
  86  * Sockets operate in two general modes, blocking or non-blocking. When
  87  * in blocking mode all operations block until the requested operation
  88  * is finished or there is an error. In non-blocking mode all calls that
  89  * would block return immediately with a %G_IO_ERROR_WOULD_BLOCK error.
  90  * To know when a call would successfully run you can call g_socket_condition_check(),
  91  * or g_socket_condition_wait(). You can also use g_socket_create_source() and
  92  * attach it to a #GMainContext to get callbacks when I/O is possible.
  93  * Note that all sockets are always set to non blocking mode in the system, and
  94  * blocking mode is emulated in GSocket.
  95  *
  96  * When working in non-blocking mode applications should always be able to
  97  * handle getting a %G_IO_ERROR_WOULD_BLOCK error even when some other
  98  * function said that I/O was possible. This can easily happen in case
  99  * of a race condition in the application, but it can also happen for other
 100  * reasons. For instance, on Windows a socket is always seen as writable
 101  * until a write returns %G_IO_ERROR_WOULD_BLOCK.
 102  *
 103  * #GSocket<!-- -->s can be either connection oriented or datagram based.
 104  * For connection oriented types you must first establish a connection by
 105  * either connecting to an address or accepting a connection from another
 106  * address. For connectionless socket types the target/source address is
 107  * specified or received in each I/O operation.
 108  *
 109  * All socket file descriptors are set to be close-on-exec.
 110  *
 111  * Note that creating a #GSocket causes the signal %SIGPIPE to be
 112  * ignored for the remainder of the program. If you are writing a
 113  * command-line utility that uses #GSocket, you may need to take into
 114  * account the fact that your program will not automatically be killed
 115  * if it tries to write to %stdout after it has been closed.
 116  *
 117  * Since: 2.22
 118  */
 119
 120 static void     g_socket_initable_iface_init (GInitableIface  *iface);
 121 static gboolean g_socket_initable_init       (GInitable       *initable,
 122                                               GCancellable    *cancellable,
 123                                               GError         **error);
 124
 125 G_DEFINE_TYPE_WITH_CODE (GSocket, g_socket, G_TYPE_OBJECT,
 126                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
 127                                                 g_socket_initable_iface_init));
 128
 129 enum
 130 {
 131   PROP_0,
 132   PROP_FAMILY,
 133   PROP_TYPE,
 134   PROP_PROTOCOL,
 135   PROP_FD,
 136   PROP_BLOCKING,
 137   PROP_LISTEN_BACKLOG,
 138   PROP_KEEPALIVE,
 139   PROP_LOCAL_ADDRESS,
 140   PROP_REMOTE_ADDRESS,
 141   PROP_TIMEOUT,
 142   PROP_TTL,
 143   PROP_BROADCAST,
 144   PROP_MULTICAST_LOOPBACK,
 145   PROP_MULTICAST_TTL
 146 };
 147
 148 struct _GSocketPrivate
 149 {
 150   GSocketFamily   family;
 151   GSocketType     type;
 152   GSocketProtocol protocol;
 153   gint            fd;
 154   gint            listen_backlog;
 155   guint           timeout;
 156   GError         *construct_error;
 157   GSocketAddress *remote_address;
 158   guint           inited : 1;
 159   guint           blocking : 1;
 160   guint           keepalive : 1;
 161   guint           closed : 1;
 162   guint           connected : 1;
 163   guint           listening : 1;
 164   guint           timed_out : 1;
 165   guint           connect_pending : 1;
 166 #ifdef G_OS_WIN32
 167   WSAEVENT        event;
 168   int             current_events;
 169   int             current_errors;
 170   int             selected_events;
 171   GList          *requested_conditions; /* list of requested GIOCondition * */
 172 #endif
 173 };
 174
 175 static int
 176 get_socket_errno (void)
 177 {
 178 #ifndef G_OS_WIN32
 179   return errno;
 180 #else
 181   return WSAGetLastError ();
 182 #endif
 183 }
 184
 185 static GIOErrorEnum
 186 socket_io_error_from_errno (int err)
 187 {
 188 #ifndef G_OS_WIN32
 189   return g_io_error_from_errno (err);
 190 #else
 191   switch (err)
 192     {
 193     case WSAEADDRINUSE:
 194       return G_IO_ERROR_ADDRESS_IN_USE;
 195     case WSAEWOULDBLOCK:
 196       return G_IO_ERROR_WOULD_BLOCK;
 197     case WSAEACCES:
 198       return G_IO_ERROR_PERMISSION_DENIED;
 199     case WSA_INVALID_HANDLE:
 200     case WSA_INVALID_PARAMETER:
 201     case WSAEBADF:
 202     case WSAENOTSOCK:
 203       return G_IO_ERROR_INVALID_ARGUMENT;
 204     case WSAEPROTONOSUPPORT:
 205       return G_IO_ERROR_NOT_SUPPORTED;
 206     case WSAECANCELLED:
 207       return G_IO_ERROR_CANCELLED;
 208     case WSAESOCKTNOSUPPORT:
 209     case WSAEOPNOTSUPP:
 210     case WSAEPFNOSUPPORT:
 211     case WSAEAFNOSUPPORT:
 212       return G_IO_ERROR_NOT_SUPPORTED;
 213     default:
 214       return G_IO_ERROR_FAILED;
 215     }
 216 #endif
 217 }
 218
 219 static const char *
 220 socket_strerror (int err)
 221 {
 222 #ifndef G_OS_WIN32
 223   return g_strerror (err);
 224 #else
 225   const char *msg_ret;
 226   char *msg;
 227
 228   msg = g_win32_error_message (err);
 229
 230   msg_ret = g_intern_string (msg);
 231   g_free (msg);
 232
 233   return msg_ret;
 234 #endif
 235 }
 236
 237 #ifdef G_OS_WIN32
 238 #define win32_unset_event_mask(_socket, _mask) _win32_unset_event_mask (_socket, _mask)
 239 static void
 240 _win32_unset_event_mask (GSocket *socket, int mask)
 241 {
 242   socket->priv->current_events &= ~mask;
 243   socket->priv->current_errors &= ~mask;
 244 }
 245 #else
 246 #define win32_unset_event_mask(_socket, _mask)
 247 #endif
 248
 249 static void
 250 set_fd_nonblocking (int fd)
 251 {
 252 #ifndef G_OS_WIN32
 253   GError *error = NULL;
 254 #else
 255   gulong arg;
 256 #endif
 257
 258 #ifndef G_OS_WIN32
 259   if (!g_unix_set_fd_nonblocking (fd, TRUE, &error))
 260     {
 261       g_warning ("Error setting socket nonblocking: %s", error->message);
 262       g_clear_error (&error);
 263     }
 264 #else
 265   arg = TRUE;
 266
 267   if (ioctlsocket (fd, FIONBIO, &arg) == SOCKET_ERROR)
 268     {
 269       int errsv = get_socket_errno ();
 270       g_warning ("Error setting socket status flags: %s", socket_strerror (errsv));
 271     }
 272 #endif
 273 }
 274
 275 static gboolean
 276 check_socket (GSocket *socket,
 277               GError **error)
 278 {
 279   if (!socket->priv->inited)
 280     {
 281       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_INITIALIZED,
 282                            _("Invalid socket, not initialized"));
 283       return FALSE;
 284     }
 285
 286   if (socket->priv->construct_error)
 287     {
 288       g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_INITIALIZED,
 289                    _("Invalid socket, initialization failed due to: %s"),
 290                    socket->priv->construct_error->message);
 291       return FALSE;
 292     }
 293
 294   if (socket->priv->closed)
 295     {
 296       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
 297                            _("Socket is already closed"));
 298       return FALSE;
 299     }
 300
 301   if (socket->priv->timed_out)
 302     {
 303       socket->priv->timed_out = FALSE;
 304       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT,
 305                            _("Socket I/O timed out"));
 306       return FALSE;
 307     }
 308
 309   return TRUE;
 310 }
 311
 312 static void
 313 g_socket_details_from_fd (GSocket *socket)
 314 {
 315   struct sockaddr_storage address;
 316   gint fd;
 317   guint addrlen;
 318   guint optlen;
 319   int value, family;
 320   int errsv;
 321 #ifdef G_OS_WIN32
 322   /* See bug #611756 */
 323   BOOL bool_val = FALSE;
 324 #else
 325   int bool_val;
 326 #endif
 327
 328   fd = socket->priv->fd;
 329   optlen = sizeof value;
 330   if (getsockopt (fd, SOL_SOCKET, SO_TYPE, (void *)&value, &optlen) != 0)
 331     {
 332       errsv = get_socket_errno ();
 333
 334       switch (errsv)
 335         {
 336 #ifdef ENOTSOCK
 337          case ENOTSOCK:
 338 #endif
 339 #ifdef WSAENOTSOCK
 340          case WSAENOTSOCK:
 341 #endif
 342          case EBADF:
 343           /* programmer error */
 344           g_error ("creating GSocket from fd %d: %s\n",
 345                    fd, socket_strerror (errsv));
 346          default:
 347            break;
 348         }
 349
 350       goto err;
 351     }
 352
 353   g_assert (optlen == sizeof value);
 354   switch (value)
 355     {
 356      case SOCK_STREAM:
 357       socket->priv->type = G_SOCKET_TYPE_STREAM;
 358       break;
 359
 360      case SOCK_DGRAM:
 361       socket->priv->type = G_SOCKET_TYPE_DATAGRAM;
 362       break;
 363
 364      case SOCK_SEQPACKET:
 365       socket->priv->type = G_SOCKET_TYPE_SEQPACKET;
 366       break;
 367
 368      default:
 369       socket->priv->type = G_SOCKET_TYPE_INVALID;
 370       break;
 371     }
 372
 373   addrlen = sizeof address;
 374   if (getsockname (fd, (struct sockaddr *) &address, &addrlen) != 0)
 375     {
 376       errsv = get_socket_errno ();
 377       goto err;
 378     }
 379
 380   if (addrlen > 0)
 381     {
 382       g_assert (G_STRUCT_OFFSET (struct sockaddr, sa_family) +
 383                 sizeof address.ss_family <= addrlen);
 384       family = address.ss_family;
 385     }
 386   else
 387     {
 388       /* On Solaris, this happens if the socket is not yet connected.
 389        * But we can use SO_DOMAIN as a workaround there.
 390        */
 391 #ifdef SO_DOMAIN
 392       optlen = sizeof family;
 393       if (getsockopt (fd, SOL_SOCKET, SO_DOMAIN, (void *)&family, &optlen) != 0)
 394         {
 395           errsv = get_socket_errno ();
 396           goto err;
 397         }
 398 #else
 399       /* This will translate to G_IO_ERROR_FAILED on either unix or windows */
 400       errsv = -1;
 401       goto err;
 402 #endif
 403     }
 404
 405   switch (family)
 406     {
 407      case G_SOCKET_FAMILY_IPV4:
 408      case G_SOCKET_FAMILY_IPV6:
 409        socket->priv->family = address.ss_family;
 410        switch (socket->priv->type)
 411          {
 412          case G_SOCKET_TYPE_STREAM:
 413            socket->priv->protocol = G_SOCKET_PROTOCOL_TCP;
 414            break;
 415
 416          case G_SOCKET_TYPE_DATAGRAM:
 417            socket->priv->protocol = G_SOCKET_PROTOCOL_UDP;
 418            break;
 419
 420          case G_SOCKET_TYPE_SEQPACKET:
 421            socket->priv->protocol = G_SOCKET_PROTOCOL_SCTP;
 422            break;
 423
 424          default:
 425            break;
 426          }
 427        break;
 428
 429      case G_SOCKET_FAMILY_UNIX:
 430        socket->priv->family = G_SOCKET_FAMILY_UNIX;
 431        socket->priv->protocol = G_SOCKET_PROTOCOL_DEFAULT;
 432        break;
 433
 434      default:
 435        socket->priv->family = G_SOCKET_FAMILY_INVALID;
 436        break;
 437     }
 438
 439   if (socket->priv->family != G_SOCKET_FAMILY_INVALID)
 440     {
 441       addrlen = sizeof address;
 442       if (getpeername (fd, (struct sockaddr *) &address, &addrlen) >= 0)
 443         socket->priv->connected = TRUE;
 444     }
 445
 446   optlen = sizeof bool_val;
 447   if (getsockopt (fd, SOL_SOCKET, SO_KEEPALIVE,
 448                   (void *)&bool_val, &optlen) == 0)
 449     {
 450 #ifndef G_OS_WIN32
 451       /* Experimentation indicates that the SO_KEEPALIVE value is
 452        * actually a char on Windows, even if documentation claims it
 453        * to be a BOOL which is a typedef for int. So this g_assert()
 454        * fails. See bug #611756.
 455        */
 456       g_assert (optlen == sizeof bool_val);
 457 #endif
 458       socket->priv->keepalive = !!bool_val;
 459     }
 460   else
 461     {
 462       /* Can't read, maybe not supported, assume FALSE */
 463       socket->priv->keepalive = FALSE;
 464     }
 465
 466   return;
 467
 468  err:
 469   g_set_error (&socket->priv->construct_error, G_IO_ERROR,
 470                socket_io_error_from_errno (errsv),
 471                _("creating GSocket from fd: %s"),
 472                socket_strerror (errsv));
 473 }
 474
 475 static gint
 476 g_socket_create_socket (GSocketFamily   family,
 477                         GSocketType     type,
 478                         int             protocol,
 479                         GError        **error)
 480 {
 481   gint native_type;
 482   gint fd;
 483
 484   switch (type)
 485     {
 486      case G_SOCKET_TYPE_STREAM:
 487       native_type = SOCK_STREAM;
 488       break;
 489
 490      case G_SOCKET_TYPE_DATAGRAM:
 491       native_type = SOCK_DGRAM;
 492       break;
 493
 494      case G_SOCKET_TYPE_SEQPACKET:
 495       native_type = SOCK_SEQPACKET;
 496       break;
 497
 498      default:
 499       g_assert_not_reached ();
 500     }
 501
 502   if (protocol == -1)
 503     {
 504       g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 505                    _("Unable to create socket: %s"), _("Unknown protocol was specified"));
 506       return -1;
 507     }
 508
 509 #ifdef SOCK_CLOEXEC
 510   fd = socket (family, native_type | SOCK_CLOEXEC, protocol);
 511   /* It's possible that libc has SOCK_CLOEXEC but the kernel does not */
 512   if (fd < 0 && errno == EINVAL)
 513 #endif
 514     fd = socket (family, native_type, protocol);
 515
 516   if (fd < 0)
 517     {
 518       int errsv = get_socket_errno ();
 519
 520       g_set_error (error, G_IO_ERROR, socket_io_error_from_errno (errsv),
 521                    _("Unable to create socket: %s"), socket_strerror (errsv));
 522     }
 523
 524 #ifndef G_OS_WIN32
 525   {
 526     int flags;
 527
 528     /* We always want to set close-on-exec to protect users. If you
 529        need to so some weird inheritance to exec you can re-enable this
 530        using lower level hacks with g_socket_get_fd(). */
 531     flags = fcntl (fd, F_GETFD, 0);
 532     if (flags != -1 &&
 533         (flags & FD_CLOEXEC) == 0)
 534       {
 535         flags |= FD_CLOEXEC;
 536         fcntl (fd, F_SETFD, flags);
 537       }
 538   }
 539 #endif
 540
 541   return fd;
 542 }
 543
 544 static void
 545 g_socket_constructed (GObject *object)
 546 {
 547   GSocket *socket = G_SOCKET (object);
 548
 549   if (socket->priv->fd >= 0)
 550     /* create socket->priv info from the fd */
 551     g_socket_details_from_fd (socket);
 552
 553   else
 554     /* create the fd from socket->priv info */
 555     socket->priv->fd = g_socket_create_socket (socket->priv->family,
 556                                                socket->priv->type,
 557                                                socket->priv->protocol,
 558                                                &socket->priv->construct_error);
 559
 560   /* Always use native nonblocking sockets, as
 561      windows sets sockets to nonblocking automatically
 562      in certain operations. This way we make things work
 563      the same on all platforms */
 564   if (socket->priv->fd != -1)
 565     set_fd_nonblocking (socket->priv->fd);
 566 }
 567
 568 static void
 569 g_socket_get_property (GObject    *object,
 570                        guint       prop_id,
 571                        GValue     *value,
 572                        GParamSpec *pspec)
 573 {
 574   GSocket *socket = G_SOCKET (object);
 575   GSocketAddress *address;
 576
 577   switch (prop_id)
 578     {
 579       case PROP_FAMILY:
 580         g_value_set_enum (value, socket->priv->family);
 581         break;
 582
 583       case PROP_TYPE:
 584         g_value_set_enum (value, socket->priv->type);
 585         break;
 586
 587       case PROP_PROTOCOL:
 588         g_value_set_enum (value, socket->priv->protocol);
 589         break;
 590
 591       case PROP_FD:
 592         g_value_set_int (value, socket->priv->fd);
 593         break;
 594
 595       case PROP_BLOCKING:
 596         g_value_set_boolean (value, socket->priv->blocking);
 597         break;
 598
 599       case PROP_LISTEN_BACKLOG:
 600         g_value_set_int (value, socket->priv->listen_backlog);
 601         break;
 602
 603       case PROP_KEEPALIVE:
 604         g_value_set_boolean (value, socket->priv->keepalive);
 605         break;
 606
 607       case PROP_LOCAL_ADDRESS:
 608         address = g_socket_get_local_address (socket, NULL);
 609         g_value_take_object (value, address);
 610         break;
 611
 612       case PROP_REMOTE_ADDRESS:
 613         address = g_socket_get_remote_address (socket, NULL);
 614         g_value_take_object (value, address);
 615         break;
 616
 617       case PROP_TIMEOUT:
 618         g_value_set_uint (value, socket->priv->timeout);
 619         break;
 620
 621       case PROP_TTL:
 622         g_value_set_uint (value, g_socket_get_ttl (socket));
 623         break;
 624
 625       case PROP_BROADCAST:
 626         g_value_set_boolean (value, g_socket_get_broadcast (socket));
 627         break;
 628
 629       case PROP_MULTICAST_LOOPBACK:
 630         g_value_set_boolean (value, g_socket_get_multicast_loopback (socket));
 631         break;
 632
 633       case PROP_MULTICAST_TTL:
 634         g_value_set_uint (value, g_socket_get_multicast_ttl (socket));
 635         break;
 636
 637       default:
 638         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 639     }
 640 }
 641
 642 static void
 643 g_socket_set_property (GObject      *object,
 644                        guint         prop_id,
 645                        const GValue *value,
 646                        GParamSpec   *pspec)
 647 {
 648   GSocket *socket = G_SOCKET (object);
 649
 650   switch (prop_id)
 651     {
 652       case PROP_FAMILY:
 653         socket->priv->family = g_value_get_enum (value);
 654         break;
 655
 656       case PROP_TYPE:
 657         socket->priv->type = g_value_get_enum (value);
 658         break;
 659
 660       case PROP_PROTOCOL:
 661         socket->priv->protocol = g_value_get_enum (value);
 662         break;
 663
 664       case PROP_FD:
 665         socket->priv->fd = g_value_get_int (value);
 666         break;
 667
 668       case PROP_BLOCKING:
 669         g_socket_set_blocking (socket, g_value_get_boolean (value));
 670         break;
 671
 672       case PROP_LISTEN_BACKLOG:
 673         g_socket_set_listen_backlog (socket, g_value_get_int (value));
 674         break;
 675
 676       case PROP_KEEPALIVE:
 677         g_socket_set_keepalive (socket, g_value_get_boolean (value));
 678         break;
 679
 680       case PROP_TIMEOUT:
 681         g_socket_set_timeout (socket, g_value_get_uint (value));
 682         break;
 683
 684       case PROP_TTL:
 685         g_socket_set_ttl (socket, g_value_get_uint (value));
 686         break;
 687
 688       case PROP_BROADCAST:
 689         g_socket_set_broadcast (socket, g_value_get_boolean (value));
 690         break;
 691
 692       case PROP_MULTICAST_LOOPBACK:
 693         g_socket_set_multicast_loopback (socket, g_value_get_boolean (value));
 694         break;
 695
 696       case PROP_MULTICAST_TTL:
 697         g_socket_set_multicast_ttl (socket, g_value_get_uint (value));
 698         break;
 699
 700       default:
 701         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 702     }
 703 }
 704
 705 static void
 706 g_socket_finalize (GObject *object)
 707 {
 708   GSocket *socket = G_SOCKET (object);
 709
 710   g_clear_error (&socket->priv->construct_error);
 711
 712   if (socket->priv->fd != -1 &&
 713       !socket->priv->closed)
 714     g_socket_close (socket, NULL);
 715
 716   if (socket->priv->remote_address)
 717     g_object_unref (socket->priv->remote_address);
 718
 719 #ifdef G_OS_WIN32
 720   if (socket->priv->event != WSA_INVALID_EVENT)
 721     {
 722       WSACloseEvent (socket->priv->event);
 723       socket->priv->event = WSA_INVALID_EVENT;
 724     }
 725
 726   g_assert (socket->priv->requested_conditions == NULL);
 727 #endif
 728
 729   if (G_OBJECT_CLASS (g_socket_parent_class)->finalize)
 730     (*G_OBJECT_CLASS (g_socket_parent_class)->finalize) (object);
 731 }
 732
 733 static void
 734 g_socket_class_init (GSocketClass *klass)
 735 {
 736   GObjectClass *gobject_class G_GNUC_UNUSED = G_OBJECT_CLASS (klass);
 737   volatile GType type;
 738
 739   /* Make sure winsock has been initialized */
 740   type = g_inet_address_get_type ();
 741   (type); /* To avoid -Wunused-but-set-variable */
 742
 743 #ifdef SIGPIPE
 744   /* There is no portable, thread-safe way to avoid having the process
 745    * be killed by SIGPIPE when calling send() or sendmsg(), so we are
 746    * forced to simply ignore the signal process-wide.
 747    */
 748   signal (SIGPIPE, SIG_IGN);
 749 #endif
 750
 751   g_type_class_add_private (klass, sizeof (GSocketPrivate));
 752
 753   gobject_class->finalize = g_socket_finalize;
 754   gobject_class->constructed = g_socket_constructed;
 755   gobject_class->set_property = g_socket_set_property;
 756   gobject_class->get_property = g_socket_get_property;
 757
 758   g_object_class_install_property (gobject_class, PROP_FAMILY,
 759                                    g_param_spec_enum ("family",
 760                                                       P_("Socket family"),
 761                                                       P_("The sockets address family"),
 762                                                       G_TYPE_SOCKET_FAMILY,
 763                                                       G_SOCKET_FAMILY_INVALID,
 764                                                       G_PARAM_CONSTRUCT_ONLY |
 765                                                       G_PARAM_READWRITE |
 766                                                       G_PARAM_STATIC_STRINGS));
 767
 768   g_object_class_install_property (gobject_class, PROP_TYPE,
 769                                    g_param_spec_enum ("type",
 770                                                       P_("Socket type"),
 771                                                       P_("The sockets type"),
 772                                                       G_TYPE_SOCKET_TYPE,
 773                                                       G_SOCKET_TYPE_STREAM,
 774                                                       G_PARAM_CONSTRUCT_ONLY |
 775                                                       G_PARAM_READWRITE |
 776                                                       G_PARAM_STATIC_STRINGS));
 777
 778   g_object_class_install_property (gobject_class, PROP_PROTOCOL,
 779                                    g_param_spec_enum ("protocol",
 780                                                       P_("Socket protocol"),
 781                                                       P_("The id of the protocol to use, or -1 for unknown"),
 782                                                       G_TYPE_SOCKET_PROTOCOL,
 783                                                       G_SOCKET_PROTOCOL_UNKNOWN,
 784                                                       G_PARAM_CONSTRUCT_ONLY |
 785                                                       G_PARAM_READWRITE |
 786                                                       G_PARAM_STATIC_STRINGS));
 787
 788   g_object_class_install_property (gobject_class, PROP_FD,
 789                                    g_param_spec_int ("fd",
 790                                                      P_("File descriptor"),
 791                                                      P_("The sockets file descriptor"),
 792                                                      G_MININT,
 793                                                      G_MAXINT,
 794                                                      -1,
 795                                                      G_PARAM_CONSTRUCT_ONLY |
 796                                                      G_PARAM_READWRITE |
 797                                                      G_PARAM_STATIC_STRINGS));
 798
 799   g_object_class_install_property (gobject_class, PROP_BLOCKING,
 800                                    g_param_spec_boolean ("blocking",
 801                                                          P_("blocking"),
 802                                                          P_("Whether or not I/O on this socket is blocking"),
 803                                                          TRUE,
 804                                                          G_PARAM_READWRITE |
 805                                                          G_PARAM_STATIC_STRINGS));
 806
 807   g_object_class_install_property (gobject_class, PROP_LISTEN_BACKLOG,
 808                                    g_param_spec_int ("listen-backlog",
 809                                                      P_("Listen backlog"),
 810                                                      P_("Outstanding connections in the listen queue"),
 811                                                      0,
 812                                                      SOMAXCONN,
 813                                                      10,
 814                                                      G_PARAM_READWRITE |
 815                                                      G_PARAM_STATIC_STRINGS));
 816
 817   g_object_class_install_property (gobject_class, PROP_KEEPALIVE,
 818                                    g_param_spec_boolean ("keepalive",
 819                                                          P_("Keep connection alive"),
 820                                                          P_("Keep connection alive by sending periodic pings"),
 821                                                          FALSE,
 822                                                          G_PARAM_READWRITE |
 823                                                          G_PARAM_STATIC_STRINGS));
 824
 825   g_object_class_install_property (gobject_class, PROP_LOCAL_ADDRESS,
 826                                    g_param_spec_object ("local-address",
 827                                                         P_("Local address"),
 828                                                         P_("The local address the socket is bound to"),
 829                                                         G_TYPE_SOCKET_ADDRESS,
 830                                                         G_PARAM_READABLE |
 831                                                         G_PARAM_STATIC_STRINGS));
 832
 833   g_object_class_install_property (gobject_class, PROP_REMOTE_ADDRESS,
 834                                    g_param_spec_object ("remote-address",
 835                                                         P_("Remote address"),
 836                                                         P_("The remote address the socket is connected to"),
 837                                                         G_TYPE_SOCKET_ADDRESS,
 838                                                         G_PARAM_READABLE |
 839                                                         G_PARAM_STATIC_STRINGS));
 840
 841   /**
 842    * GSocket:timeout:
 843    *
 844    * The timeout in seconds on socket I/O
 845    *
 846    * Since: 2.26
 847    */
 848   g_object_class_install_property (gobject_class, PROP_TIMEOUT,
 849                                    g_param_spec_uint ("timeout",
 850                                                       P_("Timeout"),
 851                                                       P_("The timeout in seconds on socket I/O"),
 852                                                       0,
 853                                                       G_MAXUINT,
 854                                                       0,
 855                                                       G_PARAM_READWRITE |
 856                                                       G_PARAM_STATIC_STRINGS));
 857
 858   /**
 859    * GSocket:broadcast:
 860    *
 861    * Whether the socket should allow sending to and receiving from broadcast addresses.
 862    *
 863    * Since: 2.32
 864    */
 865   g_object_class_install_property (gobject_class, PROP_BROADCAST,
 866                                    g_param_spec_boolean ("broadcast",
 867                                                          P_("Broadcast"),
 868                                                          P_("Whether to allow sending to and receiving from broadcast addresses"),
 869                                                          FALSE,
 870                                                          G_PARAM_READWRITE |
 871                                                          G_PARAM_STATIC_STRINGS));
 872
 873   /**
 874    * GSocket:ttl:
 875    *
 876    * Time-to-live for outgoing unicast packets
 877    *
 878    * Since: 2.32
 879    */
 880   g_object_class_install_property (gobject_class, PROP_TTL,
 881                                    g_param_spec_uint ("ttl",
 882                                                       P_("TTL"),
 883                                                       P_("Time-to-live of outgoing unicast packets"),
 884                                                       0, G_MAXUINT, 0,
 885                                                       G_PARAM_READWRITE |
 886                                                       G_PARAM_STATIC_STRINGS));
 887
 888   /**
 889    * GSocket:multicast-loopback:
 890    *
 891    * Whether outgoing multicast packets loop back to the local host.
 892    *
 893    * Since: 2.32
 894    */
 895   g_object_class_install_property (gobject_class, PROP_MULTICAST_LOOPBACK,
 896                                    g_param_spec_boolean ("multicast-loopback",
 897                                                          P_("Multicast loopback"),
 898                                                          P_("Whether outgoing multicast packets loop back to the local host"),
 899                                                          TRUE,
 900                                                          G_PARAM_READWRITE |
 901                                                          G_PARAM_STATIC_STRINGS));
 902
 903   /**
 904    * GSocket:multicast-ttl:
 905    *
 906    * Time-to-live out outgoing multicast packets
 907    *
 908    * Since: 2.32
 909    */
 910   g_object_class_install_property (gobject_class, PROP_MULTICAST_TTL,
 911                                    g_param_spec_uint ("multicast-ttl",
 912                                                       P_("Multicast TTL"),
 913                                                       P_("Time-to-live of outgoing multicast packets"),
 914                                                       0, G_MAXUINT, 1,
 915                                                       G_PARAM_READWRITE |
 916                                                       G_PARAM_STATIC_STRINGS));
 917 }
 918
 919 static void
 920 g_socket_initable_iface_init (GInitableIface *iface)
 921 {
 922   iface->init = g_socket_initable_init;
 923 }
 924
 925 static void
 926 g_socket_init (GSocket *socket)
 927 {
 928   socket->priv = G_TYPE_INSTANCE_GET_PRIVATE (socket, G_TYPE_SOCKET, GSocketPrivate);
 929
 930   socket->priv->fd = -1;
 931   socket->priv->blocking = TRUE;
 932   socket->priv->listen_backlog = 10;
 933   socket->priv->construct_error = NULL;
 934 #ifdef G_OS_WIN32
 935   socket->priv->event = WSA_INVALID_EVENT;
 936 #endif
 937 }
 938
 939 static gboolean
 940 g_socket_initable_init (GInitable *initable,
 941                         GCancellable *cancellable,
 942                         GError  **error)
 943 {
 944   GSocket  *socket;
 945
 946   g_return_val_if_fail (G_IS_SOCKET (initable), FALSE);
 947
 948   socket = G_SOCKET (initable);
 949
 950   if (cancellable != NULL)
 951     {
 952       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
 953                            _("Cancellable initialization not supported"));
 954       return FALSE;
 955     }
 956
 957   socket->priv->inited = TRUE;
 958
 959   if (socket->priv->construct_error)
 960     {
 961       if (error)
 962         *error = g_error_copy (socket->priv->construct_error);
 963       return FALSE;
 964     }
 965
 966
 967   return TRUE;
 968 }
 969
 970 /**
 971  * g_socket_new:
 972  * @family: the socket family to use, e.g. %G_SOCKET_FAMILY_IPV4.
 973  * @type: the socket type to use.
 974  * @protocol: the id of the protocol to use, or 0 for default.
 975  * @error: #GError for error reporting, or %NULL to ignore.
 976  *
 977  * Creates a new #GSocket with the defined family, type and protocol.
 978  * If @protocol is 0 (%G_SOCKET_PROTOCOL_DEFAULT) the default protocol type
 979  * for the family and type is used.
 980  *
 981  * The @protocol is a family and type specific int that specifies what
 982  * kind of protocol to use. #GSocketProtocol lists several common ones.
 983  * Many families only support one protocol, and use 0 for this, others
 984  * support several and using 0 means to use the default protocol for
 985  * the family and type.
 986  *
 987  * The protocol id is passed directly to the operating
 988  * system, so you can use protocols not listed in #GSocketProtocol if you
 989  * know the protocol number used for it.
 990  *
 991  * Returns: a #GSocket or %NULL on error.
 992  *     Free the returned object with g_object_unref().
 993  *
 994  * Since: 2.22
 995  */
 996 GSocket *
 997 g_socket_new (GSocketFamily     family,
 998               GSocketType       type,
 999               GSocketProtocol   protocol,
1000               GError          **error)
1001 {
1002   return G_SOCKET (g_initable_new (G_TYPE_SOCKET,
1003                                    NULL, error,
1004                                    "family", family,
1005                                    "type", type,
1006                                    "protocol", protocol,
1007                                    NULL));
1008 }
1009
1010 /**
1011  * g_socket_new_from_fd:
1012  * @fd: a native socket file descriptor.
1013  * @error: #GError for error reporting, or %NULL to ignore.
1014  *
1015  * Creates a new #GSocket from a native file descriptor
1016  * or winsock SOCKET handle.
1017  *
1018  * This reads all the settings from the file descriptor so that
1019  * all properties should work. Note that the file descriptor
1020  * will be set to non-blocking mode, independent on the blocking
1021  * mode of the #GSocket.
1022  *
1023  * Returns: a #GSocket or %NULL on error.
1024  *     Free the returned object with g_object_unref().
1025  *
1026  * Since: 2.22
1027  */
1028 GSocket *
1029 g_socket_new_from_fd (gint     fd,
1030                       GError **error)
1031 {
1032   return G_SOCKET (g_initable_new (G_TYPE_SOCKET,
1033                                    NULL, error,
1034                                    "fd", fd,
1035                                    NULL));
1036 }
1037
1038 /**
1039  * g_socket_set_blocking:
1040  * @socket: a #GSocket.
1041  * @blocking: Whether to use blocking I/O or not.
1042  *
1043  * Sets the blocking mode of the socket. In blocking mode
1044  * all operations block until they succeed or there is an error. In
1045  * non-blocking mode all functions return results immediately or
1046  * with a %G_IO_ERROR_WOULD_BLOCK error.
1047  *
1048  * All sockets are created in blocking mode. However, note that the
1049  * platform level socket is always non-blocking, and blocking mode
1050  * is a GSocket level feature.
1051  *
1052  * Since: 2.22
1053  */
1054 void
1055 g_socket_set_blocking (GSocket  *socket,
1056                        gboolean  blocking)
1057 {
1058   g_return_if_fail (G_IS_SOCKET (socket));
1059
1060   blocking = !!blocking;
1061
1062   if (socket->priv->blocking == blocking)
1063     return;
1064
1065   socket->priv->blocking = blocking;
1066   g_object_notify (G_OBJECT (socket), "blocking");
1067 }
1068
1069 /**
1070  * g_socket_get_blocking:
1071  * @socket: a #GSocket.
1072  *
1073  * Gets the blocking mode of the socket. For details on blocking I/O,
1074  * see g_socket_set_blocking().
1075  *
1076  * Returns: %TRUE if blocking I/O is used, %FALSE otherwise.
1077  *
1078  * Since: 2.22
1079  */
1080 gboolean
1081 g_socket_get_blocking (GSocket *socket)
1082 {
1083   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
1084
1085   return socket->priv->blocking;
1086 }
1087
1088 /**
1089  * g_socket_set_keepalive:
1090  * @socket: a #GSocket.
1091  * @keepalive: Value for the keepalive flag
1092  *
1093  * Sets or unsets the %SO_KEEPALIVE flag on the underlying socket. When
1094  * this flag is set on a socket, the system will attempt to verify that the
1095  * remote socket endpoint is still present if a sufficiently long period of
1096  * time passes with no data being exchanged. If the system is unable to
1097  * verify the presence of the remote endpoint, it will automatically close
1098  * the connection.
1099  *
1100  * This option is only functional on certain kinds of sockets. (Notably,
1101  * %G_SOCKET_PROTOCOL_TCP sockets.)
1102  *
1103  * The exact time between pings is system- and protocol-dependent, but will
1104  * normally be at least two hours. Most commonly, you would set this flag
1105  * on a server socket if you want to allow clients to remain idle for long
1106  * periods of time, but also want to ensure that connections are eventually
1107  * garbage-collected if clients crash or become unreachable.
1108  *
1109  * Since: 2.22
1110  */
1111 void
1112 g_socket_set_keepalive (GSocket  *socket,
1113                         gboolean  keepalive)
1114 {
1115   int value;
1116
1117   g_return_if_fail (G_IS_SOCKET (socket));
1118
1119   keepalive = !!keepalive;
1120   if (socket->priv->keepalive == keepalive)
1121     return;
1122
1123   value = (gint) keepalive;
1124   if (setsockopt (socket->priv->fd, SOL_SOCKET, SO_KEEPALIVE,
1125                   (gpointer) &value, sizeof (value)) < 0)
1126     {
1127       int errsv = get_socket_errno ();
1128       g_warning ("error setting keepalive: %s", socket_strerror (errsv));
1129       return;
1130     }
1131
1132   socket->priv->keepalive = keepalive;
1133   g_object_notify (G_OBJECT (socket), "keepalive");
1134 }
1135
1136 /**
1137  * g_socket_get_keepalive:
1138  * @socket: a #GSocket.
1139  *
1140  * Gets the keepalive mode of the socket. For details on this,
1141  * see g_socket_set_keepalive().
1142  *
1143  * Returns: %TRUE if keepalive is active, %FALSE otherwise.
1144  *
1145  * Since: 2.22
1146  */
1147 gboolean
1148 g_socket_get_keepalive (GSocket *socket)
1149 {
1150   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
1151
1152   return socket->priv->keepalive;
1153 }
1154
1155 /**
1156  * g_socket_get_listen_backlog:
1157  * @socket: a #GSocket.
1158  *
1159  * Gets the listen backlog setting of the socket. For details on this,
1160  * see g_socket_set_listen_backlog().
1161  *
1162  * Returns: the maximum number of pending connections.
1163  *
1164  * Since: 2.22
1165  */
1166 gint
1167 g_socket_get_listen_backlog  (GSocket *socket)
1168 {
1169   g_return_val_if_fail (G_IS_SOCKET (socket), 0);
1170
1171   return socket->priv->listen_backlog;
1172 }
1173
1174 /**
1175  * g_socket_set_listen_backlog:
1176  * @socket: a #GSocket.
1177  * @backlog: the maximum number of pending connections.
1178  *
1179  * Sets the maximum number of outstanding connections allowed
1180  * when listening on this socket. If more clients than this are
1181  * connecting to the socket and the application is not handling them
1182  * on time then the new connections will be refused.
1183  *
1184  * Note that this must be called before g_socket_listen() and has no
1185  * effect if called after that.
1186  *
1187  * Since: 2.22
1188  */
1189 void
1190 g_socket_set_listen_backlog (GSocket *socket,
1191                              gint     backlog)
1192 {
1193   g_return_if_fail (G_IS_SOCKET (socket));
1194   g_return_if_fail (!socket->priv->listening);
1195
1196   if (backlog != socket->priv->listen_backlog)
1197     {
1198       socket->priv->listen_backlog = backlog;
1199       g_object_notify (G_OBJECT (socket), "listen-backlog");
1200     }
1201 }
1202
1203 /**
1204  * g_socket_get_timeout:
1205  * @socket: a #GSocket.
1206  *
1207  * Gets the timeout setting of the socket. For details on this, see
1208  * g_socket_set_timeout().
1209  *
1210  * Returns: the timeout in seconds
1211  *
1212  * Since: 2.26
1213  */
1214 guint
1215 g_socket_get_timeout (GSocket *socket)
1216 {
1217   g_return_val_if_fail (G_IS_SOCKET (socket), 0);
1218
1219   return socket->priv->timeout;
1220 }
1221
1222 /**
1223  * g_socket_set_timeout:
1224  * @socket: a #GSocket.
1225  * @timeout: the timeout for @socket, in seconds, or 0 for none
1226  *
1227  * Sets the time in seconds after which I/O operations on @socket will
1228  * time out if they have not yet completed.
1229  *
1230  * On a blocking socket, this means that any blocking #GSocket
1231  * operation will time out after @timeout seconds of inactivity,
1232  * returning %G_IO_ERROR_TIMED_OUT.
1233  *
1234  * On a non-blocking socket, calls to g_socket_condition_wait() will
1235  * also fail with %G_IO_ERROR_TIMED_OUT after the given time. Sources
1236  * created with g_socket_create_source() will trigger after
1237  * @timeout seconds of inactivity, with the requested condition
1238  * set, at which point calling g_socket_receive(), g_socket_send(),
1239  * g_socket_check_connect_result(), etc, will fail with
1240  * %G_IO_ERROR_TIMED_OUT.
1241  *
1242  * If @timeout is 0 (the default), operations will never time out
1243  * on their own.
1244  *
1245  * Note that if an I/O operation is interrupted by a signal, this may
1246  * cause the timeout to be reset.
1247  *
1248  * Since: 2.26
1249  */
1250 void
1251 g_socket_set_timeout (GSocket *socket,
1252                       guint    timeout)
1253 {
1254   g_return_if_fail (G_IS_SOCKET (socket));
1255
1256   if (timeout != socket->priv->timeout)
1257     {
1258       socket->priv->timeout = timeout;
1259       g_object_notify (G_OBJECT (socket), "timeout");
1260     }
1261 }
1262
1263 /**
1264  * g_socket_get_ttl:
1265  * @socket: a #GSocket.
1266  *
1267  * Gets the unicast time-to-live setting on @socket; see
1268  * g_socket_set_ttl() for more details.
1269  *
1270  * Returns: the time-to-live setting on @socket
1271  *
1272  * Since: 2.32
1273  */
1274 guint
1275 g_socket_get_ttl (GSocket *socket)
1276 {
1277   int result;
1278   guint value, optlen;
1279
1280   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
1281
1282   if (socket->priv->family == G_SOCKET_FAMILY_IPV4)
1283     {
1284       guchar optval;
1285
1286       optlen = sizeof (optval);
1287       result = getsockopt (socket->priv->fd, IPPROTO_IP, IP_TTL,
1288                            &optval, &optlen);
1289       value = optval;
1290     }
1291   else if (socket->priv->family == G_SOCKET_FAMILY_IPV6)
1292     {
1293       optlen = sizeof (value);
1294       result = getsockopt (socket->priv->fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
1295                            &value, &optlen);
1296     }
1297   else
1298     g_return_val_if_reached (FALSE);
1299
1300   if (result < 0)
1301     {
1302       int errsv = get_socket_errno ();
1303       g_warning ("error getting unicast ttl: %s", socket_strerror (errsv));
1304       return FALSE;
1305     }
1306
1307   return value;
1308 }
1309
1310 /**
1311  * g_socket_set_ttl:
1312  * @socket: a #GSocket.
1313  * @ttl: the time-to-live value for all unicast packets on @socket
1314  *
1315  * Sets the time-to-live for outgoing unicast packets on @socket.
1316  * By default the platform-specific default value is used.
1317  *
1318  * Since: 2.32
1319  */
1320 void
1321 g_socket_set_ttl (GSocket  *socket,
1322                   guint     ttl)
1323 {
1324   int result;
1325
1326   g_return_if_fail (G_IS_SOCKET (socket));
1327
1328   if (socket->priv->family == G_SOCKET_FAMILY_IPV4)
1329     {
1330       guchar optval = (guchar)ttl;
1331
1332       result = setsockopt (socket->priv->fd, IPPROTO_IP, IP_TTL,
1333                            &optval, sizeof (optval));
1334     }
1335   else if (socket->priv->family == G_SOCKET_FAMILY_IPV6)
1336     {
1337       result = setsockopt (socket->priv->fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
1338                            &ttl, sizeof (ttl));
1339     }
1340   else
1341     g_return_if_reached ();
1342
1343   if (result < 0)
1344     {
1345       int errsv = get_socket_errno ();
1346       g_warning ("error setting unicast ttl: %s", socket_strerror (errsv));
1347       return;
1348     }
1349
1350   g_object_notify (G_OBJECT (socket), "ttl");
1351 }
1352
1353 /**
1354  * g_socket_get_broadcast:
1355  * @socket: a #GSocket.
1356  *
1357  * Gets the broadcast setting on @socket; if %TRUE,
1358  * it is possible to send packets to broadcast
1359  * addresses or receive from broadcast addresses.
1360  *
1361  * Returns: the broadcast setting on @socket
1362  *
1363  * Since: 2.32
1364  */
1365 gboolean
1366 g_socket_get_broadcast (GSocket *socket)
1367 {
1368   int result;
1369   guint value = 0, optlen;
1370
1371   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
1372
1373   optlen = sizeof (guchar);
1374   result = getsockopt (socket->priv->fd, SOL_SOCKET, SO_BROADCAST,
1375                        &value, &optlen);
1376
1377   if (result < 0)
1378     {
1379       int errsv = get_socket_errno ();
1380       g_warning ("error getting broadcast: %s", socket_strerror (errsv));
1381       return FALSE;
1382     }
1383
1384   return !!value;
1385 }
1386
1387 /**
1388  * g_socket_set_broadcast:
1389  * @socket: a #GSocket.
1390  * @loopback: whether @socket should allow sending to and receiving
1391  *     from broadcast addresses
1392  *
1393  * Sets whether @socket should allow sending to and receiving from
1394  * broadcast addresses. This is %FALSE by default.
1395  *
1396  * Since: 2.32
1397  */
1398 void
1399 g_socket_set_broadcast (GSocket    *socket,
1400                         gboolean    broadcast)
1401 {
1402   int result;
1403   guchar value;
1404
1405   g_return_if_fail (G_IS_SOCKET (socket));
1406
1407   broadcast = !!broadcast;
1408   value = (guchar)broadcast;
1409
1410   result = setsockopt (socket->priv->fd, SOL_SOCKET, SO_BROADCAST,
1411                        &value, sizeof (value));
1412
1413   if (result < 0)
1414     {
1415       int errsv = get_socket_errno ();
1416       g_warning ("error setting broadcast: %s", socket_strerror (errsv));
1417       return;
1418     }
1419
1420   g_object_notify (G_OBJECT (socket), "broadcast");
1421 }
1422
1423 /**
1424  * g_socket_get_multicast_loopback:
1425  * @socket: a #GSocket.
1426  *
1427  * Gets the multicast loopback setting on @socket; if %TRUE (the
1428  * default), outgoing multicast packets will be looped back to
1429  * multicast listeners on the same host.
1430  *
1431  * Returns: the multicast loopback setting on @socket
1432  *
1433  * Since: 2.32
1434  */
1435 gboolean
1436 g_socket_get_multicast_loopback (GSocket *socket)
1437 {
1438   int result;
1439   guint value = 0, optlen;
1440
1441   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
1442
1443   if (socket->priv->family == G_SOCKET_FAMILY_IPV4)
1444     {
1445       optlen = sizeof (guchar);
1446       result = getsockopt (socket->priv->fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1447                            &value, &optlen);
1448     }
1449   else if (socket->priv->family == G_SOCKET_FAMILY_IPV6)
1450     {
1451       optlen = sizeof (guint);
1452       result = getsockopt (socket->priv->fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
1453                            &value, &optlen);
1454     }
1455   else
1456     g_return_val_if_reached (FALSE);
1457
1458   if (result < 0)
1459     {
1460       int errsv = get_socket_errno ();
1461       g_warning ("error getting multicast loopback: %s", socket_strerror (errsv));
1462       return FALSE;
1463     }
1464
1465   return !!value;
1466 }
1467
1468 /**
1469  * g_socket_set_multicast_loopback:
1470  * @socket: a #GSocket.
1471  * @loopback: whether @socket should receive messages sent to its
1472  *   multicast groups from the local host
1473  *
1474  * Sets whether outgoing multicast packets will be received by sockets
1475  * listening on that multicast address on the same host. This is %TRUE
1476  * by default.
1477  *
1478  * Since: 2.32
1479  */
1480 void
1481 g_socket_set_multicast_loopback (GSocket    *socket,
1482                                  gboolean    loopback)
1483 {
1484   int result;
1485
1486   g_return_if_fail (G_IS_SOCKET (socket));
1487
1488   loopback = !!loopback;
1489
1490   if (socket->priv->family == G_SOCKET_FAMILY_IPV4)
1491     {
1492       guchar value = (guchar)loopback;
1493
1494       result = setsockopt (socket->priv->fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1495                            &value, sizeof (value));
1496     }
1497   else if (socket->priv->family == G_SOCKET_FAMILY_IPV6)
1498     {
1499       guint value = (guint)loopback;
1500
1501       result = setsockopt (socket->priv->fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
1502                            &value, sizeof (value));
1503     }
1504   else
1505     g_return_if_reached ();
1506
1507   if (result < 0)
1508     {
1509       int errsv = get_socket_errno ();
1510       g_warning ("error setting multicast loopback: %s", socket_strerror (errsv));
1511       return;
1512     }
1513
1514   g_object_notify (G_OBJECT (socket), "multicast-loopback");
1515 }
1516
1517 /**
1518  * g_socket_get_multicast_ttl:
1519  * @socket: a #GSocket.
1520  *
1521  * Gets the multicast time-to-live setting on @socket; see
1522  * g_socket_set_multicast_ttl() for more details.
1523  *
1524  * Returns: the multicast time-to-live setting on @socket
1525  *
1526  * Since: 2.32
1527  */
1528 guint
1529 g_socket_get_multicast_ttl (GSocket *socket)
1530 {
1531   int result;
1532   guint value, optlen;
1533
1534   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
1535
1536   if (socket->priv->family == G_SOCKET_FAMILY_IPV4)
1537     {
1538       guchar optval;
1539
1540       optlen = sizeof (optval);
1541       result = getsockopt (socket->priv->fd, IPPROTO_IP, IP_MULTICAST_TTL,
1542                            &optval, &optlen);
1543       value = optval;
1544     }
1545   else if (socket->priv->family == G_SOCKET_FAMILY_IPV6)
1546     {
1547       optlen = sizeof (value);
1548       result = getsockopt (socket->priv->fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
1549                            &value, &optlen);
1550     }
1551   else
1552     g_return_val_if_reached (FALSE);
1553
1554   if (result < 0)
1555     {
1556       int errsv = get_socket_errno ();
1557       g_warning ("error getting multicast ttl: %s", socket_strerror (errsv));
1558       return FALSE;
1559     }
1560
1561   return value;
1562 }
1563
1564 /**
1565  * g_socket_set_multicast_ttl:
1566  * @socket: a #GSocket.
1567  * @ttl: the time-to-live value for all multicast datagrams on @socket
1568  *
1569  * Sets the time-to-live for outgoing multicast datagrams on @socket.
1570  * By default, this is 1, meaning that multicast packets will not leave
1571  * the local network.
1572  *
1573  * Since: 2.32
1574  */
1575 void
1576 g_socket_set_multicast_ttl (GSocket  *socket,
1577                             guint     ttl)
1578 {
1579   int result;
1580
1581   g_return_if_fail (G_IS_SOCKET (socket));
1582
1583   if (socket->priv->family == G_SOCKET_FAMILY_IPV4)
1584     {
1585       guchar optval = (guchar)ttl;
1586
1587       result = setsockopt (socket->priv->fd, IPPROTO_IP, IP_MULTICAST_TTL,
1588                            &optval, sizeof (optval));
1589     }
1590   else if (socket->priv->family == G_SOCKET_FAMILY_IPV6)
1591     {
1592       result = setsockopt (socket->priv->fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
1593                            &ttl, sizeof (ttl));
1594     }
1595   else
1596     g_return_if_reached ();
1597
1598   if (result < 0)
1599     {
1600       int errsv = get_socket_errno ();
1601       g_warning ("error setting multicast ttl: %s", socket_strerror (errsv));
1602       return;
1603     }
1604
1605   g_object_notify (G_OBJECT (socket), "multicast-ttl");
1606 }
1607
1608 /**
1609  * g_socket_get_family:
1610  * @socket: a #GSocket.
1611  *
1612  * Gets the socket family of the socket.
1613  *
1614  * Returns: a #GSocketFamily
1615  *
1616  * Since: 2.22
1617  */
1618 GSocketFamily
1619 g_socket_get_family (GSocket *socket)
1620 {
1621   g_return_val_if_fail (G_IS_SOCKET (socket), G_SOCKET_FAMILY_INVALID);
1622
1623   return socket->priv->family;
1624 }
1625
1626 /**
1627  * g_socket_get_socket_type:
1628  * @socket: a #GSocket.
1629  *
1630  * Gets the socket type of the socket.
1631  *
1632  * Returns: a #GSocketType
1633  *
1634  * Since: 2.22
1635  */
1636 GSocketType
1637 g_socket_get_socket_type (GSocket *socket)
1638 {
1639   g_return_val_if_fail (G_IS_SOCKET (socket), G_SOCKET_TYPE_INVALID);
1640
1641   return socket->priv->type;
1642 }
1643
1644 /**
1645  * g_socket_get_protocol:
1646  * @socket: a #GSocket.
1647  *
1648  * Gets the socket protocol id the socket was created with.
1649  * In case the protocol is unknown, -1 is returned.
1650  *
1651  * Returns: a protocol id, or -1 if unknown
1652  *
1653  * Since: 2.22
1654  */
1655 GSocketProtocol
1656 g_socket_get_protocol (GSocket *socket)
1657 {
1658   g_return_val_if_fail (G_IS_SOCKET (socket), -1);
1659
1660   return socket->priv->protocol;
1661 }
1662
1663 /**
1664  * g_socket_get_fd:
1665  * @socket: a #GSocket.
1666  *
1667  * Returns the underlying OS socket object. On unix this
1668  * is a socket file descriptor, and on windows this is
1669  * a Winsock2 SOCKET handle. This may be useful for
1670  * doing platform specific or otherwise unusual operations
1671  * on the socket.
1672  *
1673  * Returns: the file descriptor of the socket.
1674  *
1675  * Since: 2.22
1676  */
1677 int
1678 g_socket_get_fd (GSocket *socket)
1679 {
1680   g_return_val_if_fail (G_IS_SOCKET (socket), -1);
1681
1682   return socket->priv->fd;
1683 }
1684
1685 /**
1686  * g_socket_get_local_address:
1687  * @socket: a #GSocket.
1688  * @error: #GError for error reporting, or %NULL to ignore.
1689  *
1690  * Try to get the local address of a bound socket. This is only
1691  * useful if the socket has been bound to a local address,
1692  * either explicitly or implicitly when connecting.
1693  *
1694  * Returns: (transfer full): a #GSocketAddress or %NULL on error.
1695  *     Free the returned object with g_object_unref().
1696  *
1697  * Since: 2.22
1698  */
1699 GSocketAddress *
1700 g_socket_get_local_address (GSocket  *socket,
1701                             GError  **error)
1702 {
1703   struct sockaddr_storage buffer;
1704   guint32 len = sizeof (buffer);
1705
1706   g_return_val_if_fail (G_IS_SOCKET (socket), NULL);
1707
1708   if (getsockname (socket->priv->fd, (struct sockaddr *) &buffer, &len) < 0)
1709     {
1710       int errsv = get_socket_errno ();
1711       g_set_error (error, G_IO_ERROR, socket_io_error_from_errno (errsv),
1712                    _("could not get local address: %s"), socket_strerror (errsv));
1713       return NULL;
1714     }
1715
1716   return g_socket_address_new_from_native (&buffer, len);
1717 }
1718
1719 /**
1720  * g_socket_get_remote_address:
1721  * @socket: a #GSocket.
1722  * @error: #GError for error reporting, or %NULL to ignore.
1723  *
1724  * Try to get the remove address of a connected socket. This is only
1725  * useful for connection oriented sockets that have been connected.
1726  *
1727  * Returns: (transfer full): a #GSocketAddress or %NULL on error.
1728  *     Free the returned object with g_object_unref().
1729  *
1730  * Since: 2.22
1731  */
1732 GSocketAddress *
1733 g_socket_get_remote_address (GSocket  *socket,
1734                              GError  **error)
1735 {
1736   struct sockaddr_storage buffer;
1737   guint32 len = sizeof (buffer);
1738
1739   g_return_val_if_fail (G_IS_SOCKET (socket), NULL);
1740
1741   if (socket->priv->connect_pending)
1742     {
1743       if (!g_socket_check_connect_result (socket, error))
1744         return NULL;
1745       else
1746         socket->priv->connect_pending = FALSE;
1747     }
1748
1749   if (!socket->priv->remote_address)
1750     {
1751       if (getpeername (socket->priv->fd, (struct sockaddr *) &buffer, &len) < 0)
1752         {
1753           int errsv = get_socket_errno ();
1754           g_set_error (error, G_IO_ERROR, socket_io_error_from_errno (errsv),
1755                        _("could not get remote address: %s"), socket_strerror (errsv));
1756           return NULL;
1757         }
1758
1759       socket->priv->remote_address = g_socket_address_new_from_native (&buffer, len);
1760     }
1761
1762   return g_object_ref (socket->priv->remote_address);
1763 }
1764
1765 /**
1766  * g_socket_is_connected:
1767  * @socket: a #GSocket.
1768  *
1769  * Check whether the socket is connected. This is only useful for
1770  * connection-oriented sockets.
1771  *
1772  * Returns: %TRUE if socket is connected, %FALSE otherwise.
1773  *
1774  * Since: 2.22
1775  */
1776 gboolean
1777 g_socket_is_connected (GSocket *socket)
1778 {
1779   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
1780
1781   return socket->priv->connected;
1782 }
1783
1784 /**
1785  * g_socket_listen:
1786  * @socket: a #GSocket.
1787  * @error: #GError for error reporting, or %NULL to ignore.
1788  *
1789  * Marks the socket as a server socket, i.e. a socket that is used
1790  * to accept incoming requests using g_socket_accept().
1791  *
1792  * Before calling this the socket must be bound to a local address using
1793  * g_socket_bind().
1794  *
1795  * To set the maximum amount of outstanding clients, use
1796  * g_socket_set_listen_backlog().
1797  *
1798  * Returns: %TRUE on success, %FALSE on error.
1799  *
1800  * Since: 2.22
1801  */
1802 gboolean
1803 g_socket_listen (GSocket  *socket,
1804                  GError  **error)
1805 {
1806   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
1807
1808   if (!check_socket (socket, error))
1809     return FALSE;
1810
1811   if (listen (socket->priv->fd, socket->priv->listen_backlog) < 0)
1812     {
1813       int errsv = get_socket_errno ();
1814
1815       g_set_error (error, G_IO_ERROR, socket_io_error_from_errno (errsv),
1816                    _("could not listen: %s"), socket_strerror (errsv));
1817       return FALSE;
1818     }
1819
1820   socket->priv->listening = TRUE;
1821
1822   return TRUE;
1823 }
1824
1825 /**
1826  * g_socket_bind:
1827  * @socket: a #GSocket.
1828  * @address: a #GSocketAddress specifying the local address.
1829  * @allow_reuse: whether to allow reusing this address
1830  * @error: #GError for error reporting, or %NULL to ignore.
1831  *
1832  * When a socket is created it is attached to an address family, but it
1833  * doesn't have an address in this family. g_socket_bind() assigns the
1834  * address (sometimes called name) of the socket.
1835  *
1836  * It is generally required to bind to a local address before you can
1837  * receive connections. (See g_socket_listen() and g_socket_accept() ).
1838  * In certain situations, you may also want to bind a socket that will be
1839  * used to initiate connections, though this is not normally required.
1840  *
1841  * @allow_reuse should be %TRUE for server sockets (sockets that you will
1842  * eventually call g_socket_accept() on), and %FALSE for client sockets.
1843  * (Specifically, if it is %TRUE, then g_socket_bind() will set the
1844  * %SO_REUSEADDR flag on the socket, allowing it to bind @address even if
1845  * that address was previously used by another socket that has not yet been
1846  * fully cleaned-up by the kernel. Failing to set this flag on a server
1847  * socket may cause the bind call to return %G_IO_ERROR_ADDRESS_IN_USE if
1848  * the server program is stopped and then immediately restarted.)
1849  *
1850  * Returns: %TRUE on success, %FALSE on error.
1851  *
1852  * Since: 2.22
1853  */
1854 gboolean
1855 g_socket_bind (GSocket         *socket,
1856                GSocketAddress  *address,
1857                gboolean         reuse_address,
1858                GError         **error)
1859 {
1860   struct sockaddr_storage addr;
1861
1862   g_return_val_if_fail (G_IS_SOCKET (socket) && G_IS_SOCKET_ADDRESS (address), FALSE);
1863
1864   if (!check_socket (socket, error))
1865     return FALSE;
1866
1867   /* SO_REUSEADDR on windows means something else and is not what we want.
1868      It always allows the unix variant of SO_REUSEADDR anyway */
1869 #ifndef G_OS_WIN32
1870   {
1871     int value;
1872
1873     value = (int) !!reuse_address;
1874     /* Ignore errors here, the only likely error is "not supported", and
1875        this is a "best effort" thing mainly */
1876     setsockopt (socket->priv->fd, SOL_SOCKET, SO_REUSEADDR,
1877                 (gpointer) &value, sizeof (value));
1878   }
1879 #endif
1880
1881   if (!g_socket_address_to_native (address, &addr, sizeof addr, error))
1882     return FALSE;
1883
1884   if (bind (socket->priv->fd, (struct sockaddr *) &addr,
1885             g_socket_address_get_native_size (address)) < 0)
1886     {
1887       int errsv = get_socket_errno ();
1888       g_set_error (error,
1889                    G_IO_ERROR, socket_io_error_from_errno (errsv),
1890                    _("Error binding to address: %s"), socket_strerror (errsv));
1891       return FALSE;
1892     }
1893
1894   return TRUE;
1895 }
1896
1897 static gboolean
1898 g_socket_multicast_group_operation (GSocket       *socket,
1899                                     GInetAddress  *group,
1900                                     gboolean       source_specific,
1901                                     const gchar   *interface,
1902                                     gboolean       join_group,
1903                                     GError       **error)
1904 {
1905   const guint8 *native_addr;
1906   gint optname, result;
1907
1908   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
1909   g_return_val_if_fail (socket->priv->type == G_SOCKET_TYPE_DATAGRAM, FALSE);
1910   g_return_val_if_fail (G_IS_INET_ADDRESS (group), FALSE);
1911   g_return_val_if_fail (g_inet_address_get_family (group) == socket->priv->family, FALSE);
1912
1913   if (!check_socket (socket, error))
1914     return FALSE;
1915
1916   native_addr = g_inet_address_to_bytes (group);
1917   if (socket->priv->family == G_SOCKET_FAMILY_IPV4)
1918     {
1919 #ifdef HAVE_IP_MREQN
1920       struct ip_mreqn mc_req;
1921 #else
1922       struct ip_mreq mc_req;
1923 #endif
1924
1925       memcpy (&mc_req.imr_multiaddr, native_addr, sizeof (struct in_addr));
1926
1927 #ifdef HAVE_IP_MREQN
1928       if (interface)
1929         mc_req.imr_ifindex = if_nametoindex (interface);
1930       else
1931         mc_req.imr_ifindex = 0;  /* Pick any.  */
1932 #else
1933       mc_req.imr_interface.s_addr = g_htonl (INADDR_ANY);
1934 #endif
1935
1936       if (source_specific)
1937         optname = join_group ? IP_ADD_SOURCE_MEMBERSHIP : IP_DROP_SOURCE_MEMBERSHIP;
1938       else
1939         optname = join_group ? IP_ADD_MEMBERSHIP : IP_DROP_MEMBERSHIP;
1940       result = setsockopt (socket->priv->fd, IPPROTO_IP, optname,
1941                            &mc_req, sizeof (mc_req));
1942     }
1943   else if (socket->priv->family == G_SOCKET_FAMILY_IPV6)
1944     {
1945       struct ipv6_mreq mc_req_ipv6;
1946
1947       memcpy (&mc_req_ipv6.ipv6mr_multiaddr, native_addr, sizeof (struct in6_addr));
1948       if (interface)
1949         mc_req_ipv6.ipv6mr_interface = if_nametoindex (interface);
1950       else
1951         mc_req_ipv6.ipv6mr_interface = 0;
1952
1953       optname = join_group ? IPV6_ADD_MEMBERSHIP : IPV6_DROP_MEMBERSHIP;
1954       result = setsockopt (socket->priv->fd, IPPROTO_IPV6, optname,
1955                            &mc_req_ipv6, sizeof (mc_req_ipv6));
1956     }
1957   else
1958     g_return_val_if_reached (FALSE);
1959
1960   if (result < 0)
1961     {
1962       int errsv = get_socket_errno ();
1963
1964       g_set_error (error, G_IO_ERROR, socket_io_error_from_errno (errsv),
1965                    join_group ?
1966                    _("Error joining multicast group: %s") :
1967                    _("Error leaving multicast group: %s"),
1968                    socket_strerror (errsv));
1969       return FALSE;
1970     }
1971
1972   return TRUE;
1973 }
1974
1975 /**
1976  * g_socket_join_multicast_group:
1977  * @socket: a #GSocket.
1978  * @group: a #GInetAddress specifying the group address to join.
1979  * @interface: Interface to use
1980  * @source_specific: %TRUE if source-specific multicast should be used
1981  * @error: #GError for error reporting, or %NULL to ignore.
1982  *
1983  * Registers @socket to receive multicast messages sent to @group.
1984  * @socket must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have
1985  * been bound to an appropriate interface and port with
1986  * g_socket_bind().
1987  *
1988  * If @source_specific is %TRUE, source-specific multicast as defined
1989  * in RFC 4604 is used.
1990  *
1991  * Returns: %TRUE on success, %FALSE on error.
1992  *
1993  * Since: 2.32
1994  */
1995 gboolean
1996 g_socket_join_multicast_group (GSocket       *socket,
1997                                GInetAddress  *group,
1998                                gboolean       source_specific,
1999                                const gchar   *interface,
2000                                GError       **error)
2001 {
2002   return g_socket_multicast_group_operation (socket, group, source_specific, interface, TRUE, error);
2003 }
2004
2005 /**
2006  * g_socket_leave_multicast_group:
2007  * @socket: a #GSocket.
2008  * @group: a #GInetAddress specifying the group address to leave.
2009  * @interface: Interface to use
2010  * @source_specific: %TRUE if source-specific multicast should be used
2011  * @error: #GError for error reporting, or %NULL to ignore.
2012  *
2013  * Removes @socket from the multicast group @group (while still
2014  * allowing it to receive unicast messages).
2015  *
2016  * If @source_specific is %TRUE, source-specific multicast as defined
2017  * in RFC 4604 is used.
2018  *
2019  * Returns: %TRUE on success, %FALSE on error.
2020  *
2021  * Since: 2.32
2022  */
2023 gboolean
2024 g_socket_leave_multicast_group (GSocket       *socket,
2025                                 GInetAddress  *group,
2026                                 gboolean       source_specific,
2027                                 const gchar   *interface,
2028                                 GError       **error)
2029 {
2030   return g_socket_multicast_group_operation (socket, group, source_specific, interface, FALSE, error);
2031 }
2032
2033 /**
2034  * g_socket_speaks_ipv4:
2035  * @socket: a #GSocket
2036  *
2037  * Checks if a socket is capable of speaking IPv4.
2038  *
2039  * IPv4 sockets are capable of speaking IPv4.  On some operating systems
2040  * and under some combinations of circumstances IPv6 sockets are also
2041  * capable of speaking IPv4.  See RFC 3493 section 3.7 for more
2042  * information.
2043  *
2044  * No other types of sockets are currently considered as being capable
2045  * of speaking IPv4.
2046  *
2047  * Returns: %TRUE if this socket can be used with IPv4.
2048  *
2049  * Since: 2.22
2050  **/
2051 gboolean
2052 g_socket_speaks_ipv4 (GSocket *socket)
2053 {
2054   switch (socket->priv->family)
2055     {
2056     case G_SOCKET_FAMILY_IPV4:
2057       return TRUE;
2058
2059     case G_SOCKET_FAMILY_IPV6:
2060 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
2061       {
2062         guint sizeof_int = sizeof (int);
2063         gint v6_only;
2064
2065         if (getsockopt (socket->priv->fd,
2066                         IPPROTO_IPV6, IPV6_V6ONLY,
2067                         &v6_only, &sizeof_int) != 0)
2068           return FALSE;
2069
2070         return !v6_only;
2071       }
2072 #else
2073       return FALSE;
2074 #endif
2075
2076     default:
2077       return FALSE;
2078     }
2079 }
2080
2081 /**
2082  * g_socket_accept:
2083  * @socket: a #GSocket.
2084  * @cancellable: (allow-none): a %GCancellable or %NULL
2085  * @error: #GError for error reporting, or %NULL to ignore.
2086  *
2087  * Accept incoming connections on a connection-based socket. This removes
2088  * the first outstanding connection request from the listening socket and
2089  * creates a #GSocket object for it.
2090  *
2091  * The @socket must be bound to a local address with g_socket_bind() and
2092  * must be listening for incoming connections (g_socket_listen()).
2093  *
2094  * If there are no outstanding connections then the operation will block
2095  * or return %G_IO_ERROR_WOULD_BLOCK if non-blocking I/O is enabled.
2096  * To be notified of an incoming connection, wait for the %G_IO_IN condition.
2097  *
2098  * Returns: (transfer full): a new #GSocket, or %NULL on error.
2099  *     Free the returned object with g_object_unref().
2100  *
2101  * Since: 2.22
2102  */
2103 GSocket *
2104 g_socket_accept (GSocket       *socket,
2105                  GCancellable  *cancellable,
2106                  GError       **error)
2107 {
2108   GSocket *new_socket;
2109   gint ret;
2110
2111   g_return_val_if_fail (G_IS_SOCKET (socket), NULL);
2112
2113   if (!check_socket (socket, error))
2114     return NULL;
2115
2116   while (TRUE)
2117     {
2118       if (socket->priv->blocking &&
2119           !g_socket_condition_wait (socket,
2120                                     G_IO_IN, cancellable, error))
2121         return NULL;
2122
2123       if ((ret = accept (socket->priv->fd, NULL, 0)) < 0)
2124         {
2125           int errsv = get_socket_errno ();
2126
2127           win32_unset_event_mask (socket, FD_ACCEPT);
2128
2129           if (errsv == EINTR)
2130             continue;
2131
2132           if (socket->priv->blocking)
2133             {
2134 #ifdef WSAEWOULDBLOCK
2135               if (errsv == WSAEWOULDBLOCK)
2136                 continue;
2137 #else
2138               if (errsv == EWOULDBLOCK ||
2139                   errsv == EAGAIN)
2140                 continue;
2141 #endif
2142             }
2143
2144           g_set_error (error, G_IO_ERROR,
2145                        socket_io_error_from_errno (errsv),
2146                        _("Error accepting connection: %s"), socket_strerror (errsv));
2147           return NULL;
2148         }
2149       break;
2150     }
2151
2152   win32_unset_event_mask (socket, FD_ACCEPT);
2153
2154 #ifdef G_OS_WIN32
2155   {
2156     /* The socket inherits the accepting sockets event mask and even object,
2157        we need to remove that */
2158     WSAEventSelect (ret, NULL, 0);
2159   }
2160 #else
2161   {
2162     int flags;
2163
2164     /* We always want to set close-on-exec to protect users. If you
2165        need to so some weird inheritance to exec you can re-enable this
2166        using lower level hacks with g_socket_get_fd(). */
2167     flags = fcntl (ret, F_GETFD, 0);
2168     if (flags != -1 &&
2169         (flags & FD_CLOEXEC) == 0)
2170       {
2171         flags |= FD_CLOEXEC;
2172         fcntl (ret, F_SETFD, flags);
2173       }
2174   }
2175 #endif
2176
2177   new_socket = g_socket_new_from_fd (ret, error);
2178   if (new_socket == NULL)
2179     {
2180 #ifdef G_OS_WIN32
2181       closesocket (ret);
2182 #else
2183       close (ret);
2184 #endif
2185     }
2186   else
2187     new_socket->priv->protocol = socket->priv->protocol;
2188
2189   return new_socket;
2190 }
2191
2192 /**
2193  * g_socket_connect:
2194  * @socket: a #GSocket.
2195  * @address: a #GSocketAddress specifying the remote address.
2196  * @cancellable: (allow-none): a %GCancellable or %NULL
2197  * @error: #GError for error reporting, or %NULL to ignore.
2198  *
2199  * Connect the socket to the specified remote address.
2200  *
2201  * For connection oriented socket this generally means we attempt to make
2202  * a connection to the @address. For a connection-less socket it sets
2203  * the default address for g_socket_send() and discards all incoming datagrams
2204  * from other sources.
2205  *
2206  * Generally connection oriented sockets can only connect once, but
2207  * connection-less sockets can connect multiple times to change the
2208  * default address.
2209  *
2210  * If the connect call needs to do network I/O it will block, unless
2211  * non-blocking I/O is enabled. Then %G_IO_ERROR_PENDING is returned
2212  * and the user can be notified of the connection finishing by waiting
2213  * for the G_IO_OUT condition. The result of the connection must then be
2214  * checked with g_socket_check_connect_result().
2215  *
2216  * Returns: %TRUE if connected, %FALSE on error.
2217  *
2218  * Since: 2.22
2219  */
2220 gboolean
2221 g_socket_connect (GSocket         *socket,
2222                   GSocketAddress  *address,
2223                   GCancellable    *cancellable,
2224                   GError         **error)
2225 {
2226   struct sockaddr_storage buffer;
2227
2228   g_return_val_if_fail (G_IS_SOCKET (socket) && G_IS_SOCKET_ADDRESS (address), FALSE);
2229
2230   if (!check_socket (socket, error))
2231     return FALSE;
2232
2233   if (!g_socket_address_to_native (address, &buffer, sizeof buffer, error))
2234     return FALSE;
2235
2236   if (socket->priv->remote_address)
2237     g_object_unref (socket->priv->remote_address);
2238   socket->priv->remote_address = g_object_ref (address);
2239
2240   while (1)
2241     {
2242       if (connect (socket->priv->fd, (struct sockaddr *) &buffer,
2243                    g_socket_address_get_native_size (address)) < 0)
2244         {
2245           int errsv = get_socket_errno ();
2246
2247           if (errsv == EINTR)
2248             continue;
2249
2250 #ifndef G_OS_WIN32
2251           if (errsv == EINPROGRESS)
2252 #else
2253           if (errsv == WSAEWOULDBLOCK)
2254 #endif
2255             {
2256               if (socket->priv->blocking)
2257                 {
2258                   if (g_socket_condition_wait (socket, G_IO_OUT, cancellable, error))
2259                     {
2260                       if (g_socket_check_connect_result (socket, error))
2261                         break;
2262                     }
2263                 }
2264               else
2265                 {
2266                   g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
2267                                        _("Connection in progress"));
2268                   socket->priv->connect_pending = TRUE;
2269                 }
2270             }
2271           else
2272             g_set_error_literal (error, G_IO_ERROR,
2273                                  socket_io_error_from_errno (errsv),
2274                                  socket_strerror (errsv));
2275
2276           return FALSE;
2277         }
2278       break;
2279     }
2280
2281   win32_unset_event_mask (socket, FD_CONNECT);
2282
2283   socket->priv->connected = TRUE;
2284
2285   return TRUE;
2286 }
2287
2288 /**
2289  * g_socket_check_connect_result:
2290  * @socket: a #GSocket
2291  * @error: #GError for error reporting, or %NULL to ignore.
2292  *
2293  * Checks and resets the pending connect error for the socket.
2294  * This is used to check for errors when g_socket_connect() is
2295  * used in non-blocking mode.
2296  *
2297  * Returns: %TRUE if no error, %FALSE otherwise, setting @error to the error
2298  *
2299  * Since: 2.22
2300  */
2301 gboolean
2302 g_socket_check_connect_result (GSocket  *socket,
2303                                GError  **error)
2304 {
2305   guint optlen;
2306   int value;
2307
2308   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
2309
2310   if (!check_socket (socket, error))
2311     return FALSE;
2312
2313   optlen = sizeof (value);
2314   if (getsockopt (socket->priv->fd, SOL_SOCKET, SO_ERROR, (void *)&value, &optlen) != 0)
2315     {
2316       int errsv = get_socket_errno ();
2317
2318       g_set_error (error, G_IO_ERROR, socket_io_error_from_errno (errsv),
2319                    _("Unable to get pending error: %s"), socket_strerror (errsv));
2320       return FALSE;
2321     }
2322
2323   if (value != 0)
2324     {
2325       g_set_error_literal (error, G_IO_ERROR, socket_io_error_from_errno (value),
2326                            socket_strerror (value));
2327       if (socket->priv->remote_address)
2328         {
2329           g_object_unref (socket->priv->remote_address);
2330           socket->priv->remote_address = NULL;
2331         }
2332       return FALSE;
2333     }
2334
2335   socket->priv->connected = TRUE;
2336   return TRUE;
2337 }
2338
2339 /**
2340  * g_socket_get_available_bytes:
2341  * @socket: a #GSocket
2342  *
2343  * Get the amount of data pending in the OS input buffer.
2344  *
2345  * Returns: the number of bytes that can be read from the socket
2346  * without blocking or -1 on error.
2347  *
2348  * Since: 2.32
2349  */
2350 gssize
2351 g_socket_get_available_bytes (GSocket *socket)
2352 {
2353 #ifndef G_OS_WIN32
2354   gulong avail = 0;
2355 #else
2356   gint avail = 0;
2357 #endif
2358
2359   g_return_val_if_fail (G_IS_SOCKET (socket), -1);
2360
2361 #ifndef G_OS_WIN32
2362   if (ioctl (socket->priv->fd, FIONREAD, &avail) < 0)
2363     return -1;
2364 #else
2365   if (ioctlsocket (socket->priv->fd, FIONREAD, &avail) == SOCKET_ERROR)
2366     return -1;
2367 #endif
2368
2369   return avail;
2370 }
2371
2372 /**
2373  * g_socket_receive:
2374  * @socket: a #GSocket
2375  * @buffer: a buffer to read data into (which should be at least @size
2376  *     bytes long).
2377  * @size: the number of bytes you want to read from the socket
2378  * @cancellable: (allow-none): a %GCancellable or %NULL
2379  * @error: #GError for error reporting, or %NULL to ignore.
2380  *
2381  * Receive data (up to @size bytes) from a socket. This is mainly used by
2382  * connection-oriented sockets; it is identical to g_socket_receive_from()
2383  * with @address set to %NULL.
2384  *
2385  * For %G_SOCKET_TYPE_DATAGRAM and %G_SOCKET_TYPE_SEQPACKET sockets,
2386  * g_socket_receive() will always read either 0 or 1 complete messages from
2387  * the socket. If the received message is too large to fit in @buffer, then
2388  * the data beyond @size bytes will be discarded, without any explicit
2389  * indication that this has occurred.
2390  *
2391  * For %G_SOCKET_TYPE_STREAM sockets, g_socket_receive() can return any
2392  * number of bytes, up to @size. If more than @size bytes have been
2393  * received, the additional data will be returned in future calls to
2394  * g_socket_receive().
2395  *
2396  * If the socket is in blocking mode the call will block until there
2397  * is some data to receive, the connection is closed, or there is an
2398  * error. If there is no data available and the socket is in
2399  * non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
2400  * returned. To be notified when data is available, wait for the
2401  * %G_IO_IN condition.
2402  *
2403  * On error -1 is returned and @error is set accordingly.
2404  *
2405  * Returns: Number of bytes read, or 0 if the connection was closed by
2406  * the peer, or -1 on error
2407  *
2408  * Since: 2.22
2409  */
2410 gssize
2411 g_socket_receive (GSocket       *socket,
2412                   gchar         *buffer,
2413                   gsize          size,
2414                   GCancellable  *cancellable,
2415                   GError       **error)
2416 {
2417   return g_socket_receive_with_blocking (socket, buffer, size,
2418                                          socket->priv->blocking,
2419                                          cancellable, error);
2420 }
2421
2422 /**
2423  * g_socket_receive_with_blocking:
2424  * @socket: a #GSocket
2425  * @buffer: a buffer to read data into (which should be at least @size
2426  *     bytes long).
2427  * @size: the number of bytes you want to read from the socket
2428  * @blocking: whether to do blocking or non-blocking I/O
2429  * @cancellable: (allow-none): a %GCancellable or %NULL
2430  * @error: #GError for error reporting, or %NULL to ignore.
2431  *
2432  * This behaves exactly the same as g_socket_receive(), except that
2433  * the choice of blocking or non-blocking behavior is determined by
2434  * the @blocking argument rather than by @socket's properties.
2435  *
2436  * Returns: Number of bytes read, or 0 if the connection was closed by
2437  * the peer, or -1 on error
2438  *
2439  * Since: 2.26
2440  */
2441 gssize
2442 g_socket_receive_with_blocking (GSocket       *socket,
2443                                 gchar         *buffer,
2444                                 gsize          size,
2445                                 gboolean       blocking,
2446                                 GCancellable  *cancellable,
2447                                 GError       **error)
2448 {
2449   gssize ret;
2450
2451   g_return_val_if_fail (G_IS_SOCKET (socket) && buffer != NULL, -1);
2452
2453   if (!check_socket (socket, error))
2454     return -1;
2455
2456   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2457     return -1;
2458
2459   while (1)
2460     {
2461       if (blocking &&
2462           !g_socket_condition_wait (socket,
2463                                     G_IO_IN, cancellable, error))
2464         return -1;
2465
2466       if ((ret = recv (socket->priv->fd, buffer, size, 0)) < 0)
2467         {
2468           int errsv = get_socket_errno ();
2469
2470           if (errsv == EINTR)
2471             continue;
2472
2473           if (blocking)
2474             {
2475 #ifdef WSAEWOULDBLOCK
2476               if (errsv == WSAEWOULDBLOCK)
2477                 continue;
2478 #else
2479               if (errsv == EWOULDBLOCK ||
2480                   errsv == EAGAIN)
2481                 continue;
2482 #endif
2483             }
2484
2485           win32_unset_event_mask (socket, FD_READ);
2486
2487           g_set_error (error, G_IO_ERROR,
2488                        socket_io_error_from_errno (errsv),
2489                        _("Error receiving data: %s"), socket_strerror (errsv));
2490           return -1;
2491         }
2492
2493       win32_unset_event_mask (socket, FD_READ);
2494
2495       break;
2496     }
2497
2498   return ret;
2499 }
2500
2501 /**
2502  * g_socket_receive_from:
2503  * @socket: a #GSocket
2504  * @address: (out) (allow-none): a pointer to a #GSocketAddress
2505  *     pointer, or %NULL
2506  * @buffer: (array length=size) (element-type guint8): a buffer to
2507  *     read data into (which should be at least @size bytes long).
2508  * @size: the number of bytes you want to read from the socket
2509  * @cancellable: (allow-none): a %GCancellable or %NULL
2510  * @error: #GError for error reporting, or %NULL to ignore.
2511  *
2512  * Receive data (up to @size bytes) from a socket.
2513  *
2514  * If @address is non-%NULL then @address will be set equal to the
2515  * source address of the received packet.
2516  * @address is owned by the caller.
2517  *
2518  * See g_socket_receive() for additional information.
2519  *
2520  * Returns: Number of bytes read, or 0 if the connection was closed by
2521  * the peer, or -1 on error
2522  *
2523  * Since: 2.22
2524  */
2525 gssize
2526 g_socket_receive_from (GSocket         *socket,
2527                        GSocketAddress **address,
2528                        gchar           *buffer,
2529                        gsize            size,
2530                        GCancellable    *cancellable,
2531                        GError         **error)
2532 {
2533   GInputVector v;
2534
2535   v.buffer = buffer;
2536   v.size = size;
2537
2538   return g_socket_receive_message (socket,
2539                                    address,
2540                                    &v, 1,
2541                                    NULL, 0, NULL,
2542                                    cancellable,
2543                                    error);
2544 }
2545
2546 /* Although we ignore SIGPIPE, gdb will still stop if the app receives
2547  * one, which can be confusing and annoying. So if possible, we want
2548  * to suppress the signal entirely.
2549  */
2550 #ifdef MSG_NOSIGNAL
2551 #define G_SOCKET_DEFAULT_SEND_FLAGS MSG_NOSIGNAL
2552 #else
2553 #define G_SOCKET_DEFAULT_SEND_FLAGS 0
2554 #endif
2555
2556 /**
2557  * g_socket_send:
2558  * @socket: a #GSocket
2559  * @buffer: (array length=size) (element-type guint8): the buffer
2560  *     containing the data to send.
2561  * @size: the number of bytes to send
2562  * @cancellable: (allow-none): a %GCancellable or %NULL
2563  * @error: #GError for error reporting, or %NULL to ignore.
2564  *
2565  * Tries to send @size bytes from @buffer on the socket. This is
2566  * mainly used by connection-oriented sockets; it is identical to
2567  * g_socket_send_to() with @address set to %NULL.
2568  *
2569  * If the socket is in blocking mode the call will block until there is
2570  * space for the data in the socket queue. If there is no space available
2571  * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
2572  * will be returned. To be notified when space is available, wait for the
2573  * %G_IO_OUT condition. Note though that you may still receive
2574  * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
2575  * notified of a %G_IO_OUT condition. (On Windows in particular, this is
2576  * very common due to the way the underlying APIs work.)
2577  *
2578  * On error -1 is returned and @error is set accordingly.
2579  *
2580  * Returns: Number of bytes written (which may be less than @size), or -1
2581  * on error
2582  *
2583  * Since: 2.22
2584  */
2585 gssize
2586 g_socket_send (GSocket       *socket,
2587                const gchar   *buffer,
2588                gsize          size,
2589                GCancellable  *cancellable,
2590                GError       **error)
2591 {
2592   return g_socket_send_with_blocking (socket, buffer, size,
2593                                       socket->priv->blocking,
2594                                       cancellable, error);
2595 }
2596
2597 /**
2598  * g_socket_send_with_blocking:
2599  * @socket: a #GSocket
2600  * @buffer: (array length=size) (element-type guint8): the buffer
2601  *     containing the data to send.
2602  * @size: the number of bytes to send
2603  * @blocking: whether to do blocking or non-blocking I/O
2604  * @cancellable: (allow-none): a %GCancellable or %NULL
2605  * @error: #GError for error reporting, or %NULL to ignore.
2606  *
2607  * This behaves exactly the same as g_socket_send(), except that
2608  * the choice of blocking or non-blocking behavior is determined by
2609  * the @blocking argument rather than by @socket's properties.
2610  *
2611  * Returns: Number of bytes written (which may be less than @size), or -1
2612  * on error
2613  *
2614  * Since: 2.26
2615  */
2616 gssize
2617 g_socket_send_with_blocking (GSocket       *socket,
2618                              const gchar   *buffer,
2619                              gsize          size,
2620                              gboolean       blocking,
2621                              GCancellable  *cancellable,
2622                              GError       **error)
2623 {
2624   gssize ret;
2625
2626   g_return_val_if_fail (G_IS_SOCKET (socket) && buffer != NULL, -1);
2627
2628   if (!check_socket (socket, error))
2629     return -1;
2630
2631   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2632     return -1;
2633
2634   while (1)
2635     {
2636       if (blocking &&
2637           !g_socket_condition_wait (socket,
2638                                     G_IO_OUT, cancellable, error))
2639         return -1;
2640
2641       if ((ret = send (socket->priv->fd, buffer, size, G_SOCKET_DEFAULT_SEND_FLAGS)) < 0)
2642         {
2643           int errsv = get_socket_errno ();
2644
2645           if (errsv == EINTR)
2646             continue;
2647
2648 #ifdef WSAEWOULDBLOCK
2649           if (errsv == WSAEWOULDBLOCK)
2650             win32_unset_event_mask (socket, FD_WRITE);
2651 #endif
2652
2653           if (blocking)
2654             {
2655 #ifdef WSAEWOULDBLOCK
2656               if (errsv == WSAEWOULDBLOCK)
2657                 continue;
2658 #else
2659               if (errsv == EWOULDBLOCK ||
2660                   errsv == EAGAIN)
2661                 continue;
2662 #endif
2663             }
2664
2665           g_set_error (error, G_IO_ERROR,
2666                        socket_io_error_from_errno (errsv),
2667                        _("Error sending data: %s"), socket_strerror (errsv));
2668           return -1;
2669         }
2670       break;
2671     }
2672
2673   return ret;
2674 }
2675
2676 /**
2677  * g_socket_send_to:
2678  * @socket: a #GSocket
2679  * @address: a #GSocketAddress, or %NULL
2680  * @buffer: (array length=size) (element-type guint8): the buffer
2681  *     containing the data to send.
2682  * @size: the number of bytes to send
2683  * @cancellable: (allow-none): a %GCancellable or %NULL
2684  * @error: #GError for error reporting, or %NULL to ignore.
2685  *
2686  * Tries to send @size bytes from @buffer to @address. If @address is
2687  * %NULL then the message is sent to the default receiver (set by
2688  * g_socket_connect()).
2689  *
2690  * See g_socket_send() for additional information.
2691  *
2692  * Returns: Number of bytes written (which may be less than @size), or -1
2693  * on error
2694  *
2695  * Since: 2.22
2696  */
2697 gssize
2698 g_socket_send_to (GSocket         *socket,
2699                   GSocketAddress  *address,
2700                   const gchar     *buffer,
2701                   gsize            size,
2702                   GCancellable    *cancellable,
2703                   GError         **error)
2704 {
2705   GOutputVector v;
2706
2707   v.buffer = buffer;
2708   v.size = size;
2709
2710   return g_socket_send_message (socket,
2711                                 address,
2712                                 &v, 1,
2713                                 NULL, 0,
2714                                 0,
2715                                 cancellable,
2716                                 error);
2717 }
2718
2719 /**
2720  * g_socket_shutdown:
2721  * @socket: a #GSocket
2722  * @shutdown_read: whether to shut down the read side
2723  * @shutdown_write: whether to shut down the write side
2724  * @error: #GError for error reporting, or %NULL to ignore.
2725  *
2726  * Shut down part of a full-duplex connection.
2727  *
2728  * If @shutdown_read is %TRUE then the receiving side of the connection
2729  * is shut down, and further reading is disallowed.
2730  *
2731  * If @shutdown_write is %TRUE then the sending side of the connection
2732  * is shut down, and further writing is disallowed.
2733  *
2734  * It is allowed for both @shutdown_read and @shutdown_write to be %TRUE.
2735  *
2736  * One example where this is used is graceful disconnect for TCP connections
2737  * where you close the sending side, then wait for the other side to close
2738  * the connection, thus ensuring that the other side saw all sent data.
2739  *
2740  * Returns: %TRUE on success, %FALSE on error
2741  *
2742  * Since: 2.22
2743  */
2744 gboolean
2745 g_socket_shutdown (GSocket   *socket,
2746                    gboolean   shutdown_read,
2747                    gboolean   shutdown_write,
2748                    GError   **error)
2749 {
2750   int how;
2751
2752   g_return_val_if_fail (G_IS_SOCKET (socket), TRUE);
2753
2754   if (!check_socket (socket, error))
2755     return FALSE;
2756
2757   /* Do nothing? */
2758   if (!shutdown_read && !shutdown_write)
2759     return TRUE;
2760
2761 #ifndef G_OS_WIN32
2762   if (shutdown_read && shutdown_write)
2763     how = SHUT_RDWR;
2764   else if (shutdown_read)
2765     how = SHUT_RD;
2766   else
2767     how = SHUT_WR;
2768 #else
2769   if (shutdown_read && shutdown_write)
2770     how = SD_BOTH;
2771   else if (shutdown_read)
2772     how = SD_RECEIVE;
2773   else
2774     how = SD_SEND;
2775 #endif
2776
2777   if (shutdown (socket->priv->fd, how) != 0)
2778     {
2779       int errsv = get_socket_errno ();
2780       g_set_error (error, G_IO_ERROR, socket_io_error_from_errno (errsv),
2781                    _("Unable to shutdown socket: %s"), socket_strerror (errsv));
2782       return FALSE;
2783     }
2784
2785   if (shutdown_read && shutdown_write)
2786     socket->priv->connected = FALSE;
2787
2788   return TRUE;
2789 }
2790
2791 /**
2792  * g_socket_close:
2793  * @socket: a #GSocket
2794  * @error: #GError for error reporting, or %NULL to ignore.
2795  *
2796  * Closes the socket, shutting down any active connection.
2797  *
2798  * Closing a socket does not wait for all outstanding I/O operations
2799  * to finish, so the caller should not rely on them to be guaranteed
2800  * to complete even if the close returns with no error.
2801  *
2802  * Once the socket is closed, all other operations will return
2803  * %G_IO_ERROR_CLOSED. Closing a socket multiple times will not
2804  * return an error.
2805  *
2806  * Sockets will be automatically closed when the last reference
2807  * is dropped, but you might want to call this function to make sure
2808  * resources are released as early as possible.
2809  *
2810  * Beware that due to the way that TCP works, it is possible for
2811  * recently-sent data to be lost if either you close a socket while the
2812  * %G_IO_IN condition is set, or else if the remote connection tries to
2813  * send something to you after you close the socket but before it has
2814  * finished reading all of the data you sent. There is no easy generic
2815  * way to avoid this problem; the easiest fix is to design the network
2816  * protocol such that the client will never send data "out of turn".
2817  * Another solution is for the server to half-close the connection by
2818  * calling g_socket_shutdown() with only the @shutdown_write flag set,
2819  * and then wait for the client to notice this and close its side of the
2820  * connection, after which the server can safely call g_socket_close().
2821  * (This is what #GTcpConnection does if you call
2822  * g_tcp_connection_set_graceful_disconnect(). But of course, this
2823  * only works if the client will close its connection after the server
2824  * does.)
2825  *
2826  * Returns: %TRUE on success, %FALSE on error
2827  *
2828  * Since: 2.22
2829  */
2830 gboolean
2831 g_socket_close (GSocket  *socket,
2832                 GError  **error)
2833 {
2834   int res;
2835
2836   g_return_val_if_fail (G_IS_SOCKET (socket), TRUE);
2837
2838   if (socket->priv->closed)
2839     return TRUE; /* Multiple close not an error */
2840
2841   if (!check_socket (socket, error))
2842     return FALSE;
2843
2844   while (1)
2845     {
2846 #ifdef G_OS_WIN32
2847       res = closesocket (socket->priv->fd);
2848 #else
2849       res = close (socket->priv->fd);
2850 #endif
2851       if (res == -1)
2852         {
2853           int errsv = get_socket_errno ();
2854
2855           if (errsv == EINTR)
2856             continue;
2857
2858           g_set_error (error, G_IO_ERROR,
2859                        socket_io_error_from_errno (errsv),
2860                        _("Error closing socket: %s"),
2861                        socket_strerror (errsv));
2862           return FALSE;
2863         }
2864       break;
2865     }
2866
2867   socket->priv->connected = FALSE;
2868   socket->priv->closed = TRUE;
2869   if (socket->priv->remote_address)
2870     {
2871       g_object_unref (socket->priv->remote_address);
2872       socket->priv->remote_address = NULL;
2873     }
2874
2875   return TRUE;
2876 }
2877
2878 /**
2879  * g_socket_is_closed:
2880  * @socket: a #GSocket
2881  *
2882  * Checks whether a socket is closed.
2883  *
2884  * Returns: %TRUE if socket is closed, %FALSE otherwise
2885  *
2886  * Since: 2.22
2887  */
2888 gboolean
2889 g_socket_is_closed (GSocket *socket)
2890 {
2891   return socket->priv->closed;
2892 }
2893
2894 #ifdef G_OS_WIN32
2895 /* Broken source, used on errors */
2896 static gboolean
2897 broken_prepare  (GSource *source,
2898                  gint    *timeout)
2899 {
2900   return FALSE;
2901 }
2902
2903 static gboolean
2904 broken_check (GSource *source)
2905 {
2906   return FALSE;
2907 }
2908
2909 static gboolean
2910 broken_dispatch (GSource     *source,
2911                  GSourceFunc  callback,
2912                  gpointer     user_data)
2913 {
2914   return TRUE;
2915 }
2916
2917 static GSourceFuncs broken_funcs =
2918 {
2919   broken_prepare,
2920   broken_check,
2921   broken_dispatch,
2922   NULL
2923 };
2924
2925 static gint
2926 network_events_for_condition (GIOCondition condition)
2927 {
2928   int event_mask = 0;
2929
2930   if (condition & G_IO_IN)
2931     event_mask |= (FD_READ | FD_ACCEPT);
2932   if (condition & G_IO_OUT)
2933     event_mask |= (FD_WRITE | FD_CONNECT);
2934   event_mask |= FD_CLOSE;
2935
2936   return event_mask;
2937 }
2938
2939 static void
2940 ensure_event (GSocket *socket)
2941 {
2942   if (socket->priv->event == WSA_INVALID_EVENT)
2943     socket->priv->event = WSACreateEvent();
2944 }
2945
2946 static void
2947 update_select_events (GSocket *socket)
2948 {
2949   int event_mask;
2950   GIOCondition *ptr;
2951   GList *l;
2952   WSAEVENT event;
2953
2954   ensure_event (socket);
2955
2956   event_mask = 0;
2957   for (l = socket->priv->requested_conditions; l != NULL; l = l->next)
2958     {
2959       ptr = l->data;
2960       event_mask |= network_events_for_condition (*ptr);
2961     }
2962
2963   if (event_mask != socket->priv->selected_events)
2964     {
2965       /* If no events selected, disable event so we can unset
2966          nonblocking mode */
2967
2968       if (event_mask == 0)
2969         event = NULL;
2970       else
2971         event = socket->priv->event;
2972
2973       if (WSAEventSelect (socket->priv->fd, event, event_mask) == 0)
2974         socket->priv->selected_events = event_mask;
2975     }
2976 }
2977
2978 static void
2979 add_condition_watch (GSocket      *socket,
2980                      GIOCondition *condition)
2981 {
2982   g_assert (g_list_find (socket->priv->requested_conditions, condition) == NULL);
2983
2984   socket->priv->requested_conditions =
2985     g_list_prepend (socket->priv->requested_conditions, condition);
2986
2987   update_select_events (socket);
2988 }
2989
2990 static void
2991 remove_condition_watch (GSocket      *socket,
2992                         GIOCondition *condition)
2993 {
2994   g_assert (g_list_find (socket->priv->requested_conditions, condition) != NULL);
2995
2996   socket->priv->requested_conditions =
2997     g_list_remove (socket->priv->requested_conditions, condition);
2998
2999   update_select_events (socket);
3000 }
3001
3002 static GIOCondition
3003 update_condition (GSocket *socket)
3004 {
3005   WSANETWORKEVENTS events;
3006   GIOCondition condition;
3007
3008   if (WSAEnumNetworkEvents (socket->priv->fd,
3009                             socket->priv->event,
3010                             &events) == 0)
3011     {
3012       socket->priv->current_events |= events.lNetworkEvents;
3013       if (events.lNetworkEvents & FD_WRITE &&
3014           events.iErrorCode[FD_WRITE_BIT] != 0)
3015         socket->priv->current_errors |= FD_WRITE;
3016       if (events.lNetworkEvents & FD_CONNECT &&
3017           events.iErrorCode[FD_CONNECT_BIT] != 0)
3018         socket->priv->current_errors |= FD_CONNECT;
3019     }
3020
3021   condition = 0;
3022   if (socket->priv->current_events & (FD_READ | FD_ACCEPT))
3023     condition |= G_IO_IN;
3024
3025   if (socket->priv->current_events & FD_CLOSE ||
3026       socket->priv->closed)
3027     condition |= G_IO_HUP;
3028
3029   /* Never report both G_IO_OUT and HUP, these are
3030      mutually exclusive (can't write to a closed socket) */
3031   if ((condition & G_IO_HUP) == 0 &&
3032       socket->priv->current_events & FD_WRITE)
3033     {
3034       if (socket->priv->current_errors & FD_WRITE)
3035         condition |= G_IO_ERR;
3036       else
3037         condition |= G_IO_OUT;
3038     }
3039   else
3040     {
3041       if (socket->priv->current_events & FD_CONNECT)
3042         {
3043           if (socket->priv->current_errors & FD_CONNECT)
3044             condition |= (G_IO_HUP | G_IO_ERR);
3045           else
3046             condition |= G_IO_OUT;
3047         }
3048     }
3049
3050   return condition;
3051 }
3052 #endif
3053
3054 typedef struct {
3055   GSource       source;
3056   GPollFD       pollfd;
3057   GSocket      *socket;
3058   GIOCondition  condition;
3059   GCancellable *cancellable;
3060   GPollFD       cancel_pollfd;
3061   gint64        timeout_time;
3062 } GSocketSource;
3063
3064 static gboolean
3065 socket_source_prepare (GSource *source,
3066                        gint    *timeout)
3067 {
3068   GSocketSource *socket_source = (GSocketSource *)source;
3069
3070   if (g_cancellable_is_cancelled (socket_source->cancellable))
3071     return TRUE;
3072
3073   if (socket_source->timeout_time)
3074     {
3075       gint64 now;
3076
3077       now = g_source_get_time (source);
3078       /* Round up to ensure that we don't try again too early */
3079       *timeout = (socket_source->timeout_time - now + 999) / 1000;
3080       if (*timeout < 0)
3081         {
3082           socket_source->socket->priv->timed_out = TRUE;
3083           *timeout = 0;
3084           return TRUE;
3085         }
3086     }
3087   else
3088     *timeout = -1;
3089
3090 #ifdef G_OS_WIN32
3091   socket_source->pollfd.revents = update_condition (socket_source->socket);
3092 #endif
3093
3094   if ((socket_source->condition & socket_source->pollfd.revents) != 0)
3095     return TRUE;
3096
3097   return FALSE;
3098 }
3099
3100 static gboolean
3101 socket_source_check (GSource *source)
3102 {
3103   int timeout;
3104
3105   return socket_source_prepare (source, &timeout);
3106 }
3107
3108 static gboolean
3109 socket_source_dispatch (GSource     *source,
3110                         GSourceFunc  callback,
3111                         gpointer     user_data)
3112 {
3113   GSocketSourceFunc func = (GSocketSourceFunc)callback;
3114   GSocketSource *socket_source = (GSocketSource *)source;
3115
3116 #ifdef G_OS_WIN32
3117   socket_source->pollfd.revents = update_condition (socket_source->socket);
3118 #endif
3119   if (socket_source->socket->priv->timed_out)
3120     socket_source->pollfd.revents |= socket_source->condition & (G_IO_IN | G_IO_OUT);
3121
3122   return (*func) (socket_source->socket,
3123                   socket_source->pollfd.revents & socket_source->condition,
3124                   user_data);
3125 }
3126
3127 static void
3128 socket_source_finalize (GSource *source)
3129 {
3130   GSocketSource *socket_source = (GSocketSource *)source;
3131   GSocket *socket;
3132
3133   socket = socket_source->socket;
3134
3135 #ifdef G_OS_WIN32
3136   remove_condition_watch (socket, &socket_source->condition);
3137 #endif
3138
3139   g_object_unref (socket);
3140
3141   if (socket_source->cancellable)
3142     {
3143       g_cancellable_release_fd (socket_source->cancellable);
3144       g_object_unref (socket_source->cancellable);
3145     }
3146 }
3147
3148 static gboolean
3149 socket_source_closure_callback (GSocket      *socket,
3150                                 GIOCondition  condition,
3151                                 gpointer      data)
3152 {
3153   GClosure *closure = data;
3154
3155   GValue params[2] = { G_VALUE_INIT, G_VALUE_INIT };
3156   GValue result_value = G_VALUE_INIT;
3157   gboolean result;
3158
3159   g_value_init (&result_value, G_TYPE_BOOLEAN);
3160
3161   g_value_init (&params[0], G_TYPE_SOCKET);
3162   g_value_set_object (&params[0], socket);
3163   g_value_init (&params[1], G_TYPE_IO_CONDITION);
3164   g_value_set_flags (&params[1], condition);
3165
3166   g_closure_invoke (closure, &result_value, 2, params, NULL);
3167
3168   result = g_value_get_boolean (&result_value);
3169   g_value_unset (&result_value);
3170   g_value_unset (&params[0]);
3171   g_value_unset (&params[1]);
3172
3173   return result;
3174 }
3175
3176 static GSourceFuncs socket_source_funcs =
3177 {
3178   socket_source_prepare,
3179   socket_source_check,
3180   socket_source_dispatch,
3181   socket_source_finalize,
3182   (GSourceFunc)socket_source_closure_callback,
3183   (GSourceDummyMarshal)g_cclosure_marshal_generic,
3184 };
3185
3186 static GSource *
3187 socket_source_new (GSocket      *socket,
3188                    GIOCondition  condition,
3189                    GCancellable *cancellable)
3190 {
3191   GSource *source;
3192   GSocketSource *socket_source;
3193
3194 #ifdef G_OS_WIN32
3195   ensure_event (socket);
3196
3197   if (socket->priv->event == WSA_INVALID_EVENT)
3198     {
3199       g_warning ("Failed to create WSAEvent");
3200       return g_source_new (&broken_funcs, sizeof (GSource));
3201     }
3202 #endif
3203
3204   condition |= G_IO_HUP | G_IO_ERR;
3205
3206   source = g_source_new (&socket_source_funcs, sizeof (GSocketSource));
3207   g_source_set_name (source, "GSocket");
3208   socket_source = (GSocketSource *)source;
3209
3210   socket_source->socket = g_object_ref (socket);
3211   socket_source->condition = condition;
3212
3213   if (g_cancellable_make_pollfd (cancellable,
3214                                  &socket_source->cancel_pollfd))
3215     {
3216       socket_source->cancellable = g_object_ref (cancellable);
3217       g_source_add_poll (source, &socket_source->cancel_pollfd);
3218     }
3219
3220 #ifdef G_OS_WIN32
3221   add_condition_watch (socket, &socket_source->condition);
3222   socket_source->pollfd.fd = (gintptr) socket->priv->event;
3223 #else
3224   socket_source->pollfd.fd = socket->priv->fd;
3225 #endif
3226
3227   socket_source->pollfd.events = condition;
3228   socket_source->pollfd.revents = 0;
3229   g_source_add_poll (source, &socket_source->pollfd);
3230
3231   if (socket->priv->timeout)
3232     socket_source->timeout_time = g_get_monotonic_time () +
3233                                   socket->priv->timeout * 1000000;
3234
3235   else
3236     socket_source->timeout_time = 0;
3237
3238   return source;
3239 }
3240
3241 /**
3242  * g_socket_create_source: (skip)
3243  * @socket: a #GSocket
3244  * @condition: a #GIOCondition mask to monitor
3245  * @cancellable: (allow-none): a %GCancellable or %NULL
3246  *
3247  * Creates a %GSource that can be attached to a %GMainContext to monitor
3248  * for the availibility of the specified @condition on the socket.
3249  *
3250  * The callback on the source is of the #GSocketSourceFunc type.
3251  *
3252  * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in @condition;
3253  * these conditions will always be reported output if they are true.
3254  *
3255  * @cancellable if not %NULL can be used to cancel the source, which will
3256  * cause the source to trigger, reporting the current condition (which
3257  * is likely 0 unless cancellation happened at the same time as a
3258  * condition change). You can check for this in the callback using
3259  * g_cancellable_is_cancelled().
3260  *
3261  * If @socket has a timeout set, and it is reached before @condition
3262  * occurs, the source will then trigger anyway, reporting %G_IO_IN or
3263  * %G_IO_OUT depending on @condition. However, @socket will have been
3264  * marked as having had a timeout, and so the next #GSocket I/O method
3265  * you call will then fail with a %G_IO_ERROR_TIMED_OUT.
3266  *
3267  * Returns: (transfer full): a newly allocated %GSource, free with g_source_unref().
3268  *
3269  * Since: 2.22
3270  */
3271 GSource *
3272 g_socket_create_source (GSocket      *socket,
3273                         GIOCondition  condition,
3274                         GCancellable *cancellable)
3275 {
3276   g_return_val_if_fail (G_IS_SOCKET (socket) && (cancellable == NULL || G_IS_CANCELLABLE (cancellable)), NULL);
3277
3278   return socket_source_new (socket, condition, cancellable);
3279 }
3280
3281 /**
3282  * g_socket_condition_check:
3283  * @socket: a #GSocket
3284  * @condition: a #GIOCondition mask to check
3285  *
3286  * Checks on the readiness of @socket to perform operations.
3287  * The operations specified in @condition are checked for and masked
3288  * against the currently-satisfied conditions on @socket. The result
3289  * is returned.
3290  *
3291  * Note that on Windows, it is possible for an operation to return
3292  * %G_IO_ERROR_WOULD_BLOCK even immediately after
3293  * g_socket_condition_check() has claimed that the socket is ready for
3294  * writing. Rather than calling g_socket_condition_check() and then
3295  * writing to the socket if it succeeds, it is generally better to
3296  * simply try writing to the socket right away, and try again later if
3297  * the initial attempt returns %G_IO_ERROR_WOULD_BLOCK.
3298  *
3299  * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in condition;
3300  * these conditions will always be set in the output if they are true.
3301  *
3302  * This call never blocks.
3303  *
3304  * Returns: the @GIOCondition mask of the current state
3305  *
3306  * Since: 2.22
3307  */
3308 GIOCondition
3309 g_socket_condition_check (GSocket      *socket,
3310                           GIOCondition  condition)
3311 {
3312   g_return_val_if_fail (G_IS_SOCKET (socket), 0);
3313
3314   if (!check_socket (socket, NULL))
3315     return 0;
3316
3317 #ifdef G_OS_WIN32
3318   {
3319     GIOCondition current_condition;
3320
3321     condition |= G_IO_ERR | G_IO_HUP;
3322
3323     add_condition_watch (socket, &condition);
3324     current_condition = update_condition (socket);
3325     remove_condition_watch (socket, &condition);
3326     return condition & current_condition;
3327   }
3328 #else
3329   {
3330     GPollFD poll_fd;
3331     gint result;
3332     poll_fd.fd = socket->priv->fd;
3333     poll_fd.events = condition;
3334
3335     do
3336       result = g_poll (&poll_fd, 1, 0);
3337     while (result == -1 && get_socket_errno () == EINTR);
3338
3339     return poll_fd.revents;
3340   }
3341 #endif
3342 }
3343
3344 /**
3345  * g_socket_condition_wait:
3346  * @socket: a #GSocket
3347  * @condition: a #GIOCondition mask to wait for
3348  * @cancellable: (allow-none): a #GCancellable, or %NULL
3349  * @error: a #GError pointer, or %NULL
3350  *
3351  * Waits for @condition to become true on @socket. When the condition
3352  * is met, %TRUE is returned.
3353  *
3354  * If @cancellable is cancelled before the condition is met, or if the
3355  * socket has a timeout set and it is reached before the condition is
3356  * met, then %FALSE is returned and @error, if non-%NULL, is set to
3357  * the appropriate value (%G_IO_ERROR_CANCELLED or
3358  * %G_IO_ERROR_TIMED_OUT).
3359  *
3360  * Returns: %TRUE if the condition was met, %FALSE otherwise
3361  *
3362  * Since: 2.22
3363  */
3364 gboolean
3365 g_socket_condition_wait (GSocket       *socket,
3366                          GIOCondition   condition,
3367                          GCancellable  *cancellable,
3368                          GError       **error)
3369 {
3370   g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
3371
3372   if (!check_socket (socket, error))
3373     return FALSE;
3374
3375   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3376     return FALSE;
3377
3378 #ifdef G_OS_WIN32
3379   {
3380     GIOCondition current_condition;
3381     WSAEVENT events[2];
3382     DWORD res, timeout;
3383     GPollFD cancel_fd;
3384     int num_events;
3385
3386     /* Always check these */
3387     condition |=  G_IO_ERR | G_IO_HUP;
3388
3389     add_condition_watch (socket, &condition);
3390
3391     num_events = 0;
3392     events[num_events++] = socket->priv->event;
3393
3394     if (g_cancellable_make_pollfd (cancellable, &cancel_fd))
3395       events[num_events++] = (WSAEVENT)cancel_fd.fd;
3396
3397     if (socket->priv->timeout)
3398       timeout = socket->priv->timeout * 1000;
3399     else
3400       timeout = WSA_INFINITE;
3401
3402     current_condition = update_condition (socket);
3403     while ((condition & current_condition) == 0)
3404       {
3405         res = WSAWaitForMultipleEvents(num_events, events,
3406                                        FALSE, timeout, FALSE);
3407         if (res == WSA_WAIT_FAILED)
3408           {
3409             int errsv = get_socket_errno ();
3410
3411             g_set_error (error, G_IO_ERROR,
3412                          socket_io_error_from_errno (errsv),
3413                          _("Waiting for socket condition: %s"),
3414                          socket_strerror (errsv));
3415             break;
3416           }
3417         else if (res == WSA_WAIT_TIMEOUT)
3418           {
3419             g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT,
3420                                  _("Socket I/O timed out"));
3421             break;
3422           }
3423
3424         if (g_cancellable_set_error_if_cancelled (cancellable, error))
3425           break;
3426
3427         current_condition = update_condition (socket);
3428       }
3429     remove_condition_watch (socket, &condition);
3430     if (num_events > 1)
3431       g_cancellable_release_fd (cancellable);
3432
3433     return (condition & current_condition) != 0;
3434   }
3435 #else
3436   {
3437     GPollFD poll_fd[2];
3438     gint result;
3439     gint num;
3440     gint timeout;
3441
3442     poll_fd[0].fd = socket->priv->fd;
3443     poll_fd[0].events = condition;
3444     num = 1;
3445
3446     if (g_cancellable_make_pollfd (cancellable, &poll_fd[1]))
3447       num++;
3448
3449     if (socket->priv->timeout)
3450       timeout = socket->priv->timeout * 1000;
3451     else
3452       timeout = -1;
3453
3454     do
3455       result = g_poll (poll_fd, num, timeout);
3456     while (result == -1 && get_socket_errno () == EINTR);
3457
3458     if (num > 1)
3459       g_cancellable_release_fd (cancellable);
3460
3461     if (result == 0)
3462       {
3463         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT,
3464                              _("Socket I/O timed out"));
3465         return FALSE;
3466       }
3467
3468     return !g_cancellable_set_error_if_cancelled (cancellable, error);
3469   }
3470   #endif
3471 }
3472
3473 /**
3474  * g_socket_send_message:
3475  * @socket: a #GSocket
3476  * @address: a #GSocketAddress, or %NULL
3477  * @vectors: (array length=num_vectors): an array of #GOutputVector structs
3478  * @num_vectors: the number of elements in @vectors, or -1
3479  * @messages: (array length=num_messages) (allow-none): a pointer to an
3480  *   array of #GSocketControlMessages, or %NULL.
3481  * @num_messages: number of elements in @messages, or -1.
3482  * @flags: an int containing #GSocketMsgFlags flags
3483  * @cancellable: (allow-none): a %GCancellable or %NULL
3484  * @error: #GError for error reporting, or %NULL to ignore.
3485  *
3486  * Send data to @address on @socket.  This is the most complicated and
3487  * fully-featured version of this call. For easier use, see
3488  * g_socket_send() and g_socket_send_to().
3489  *
3490  * If @address is %NULL then the message is sent to the default receiver
3491  * (set by g_socket_connect()).
3492  *
3493  * @vectors must point to an array of #GOutputVector structs and
3494  * @num_vectors must be the length of this array. (If @num_vectors is -1,
3495  * then @vectors is assumed to be terminated by a #GOutputVector with a
3496  * %NULL buffer pointer.) The #GOutputVector structs describe the buffers
3497  * that the sent data will be gathered from. Using multiple
3498  * #GOutputVector<!-- -->s is more memory-efficient than manually copying
3499  * data from multiple sources into a single buffer, and more
3500  * network-efficient than making multiple calls to g_socket_send().
3501  *
3502  * @messages, if non-%NULL, is taken to point to an array of @num_messages
3503  * #GSocketControlMessage instances. These correspond to the control
3504  * messages to be sent on the socket.
3505  * If @num_messages is -1 then @messages is treated as a %NULL-terminated
3506  * array.
3507  *
3508  * @flags modify how the message is sent. The commonly available arguments
3509  * for this are available in the #GSocketMsgFlags enum, but the
3510  * values there are the same as the system values, and the flags
3511  * are passed in as-is, so you can pass in system-specific flags too.
3512  *
3513  * If the socket is in blocking mode the call will block until there is
3514  * space for the data in the socket queue. If there is no space available
3515  * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
3516  * will be returned. To be notified when space is available, wait for the
3517  * %G_IO_OUT condition. Note though that you may still receive
3518  * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
3519  * notified of a %G_IO_OUT condition. (On Windows in particular, this is
3520  * very common due to the way the underlying APIs work.)
3521  *
3522  * On error -1 is returned and @error is set accordingly.
3523  *
3524  * Returns: Number of bytes written (which may be less than @size), or -1
3525  * on error
3526  *
3527  * Since: 2.22
3528  */
3529 gssize
3530 g_socket_send_message (GSocket                *socket,
3531                        GSocketAddress         *address,
3532                        GOutputVector          *vectors,
3533                        gint                    num_vectors,
3534                        GSocketControlMessage **messages,
3535                        gint                    num_messages,
3536                        gint                    flags,
3537                        GCancellable           *cancellable,
3538                        GError                **error)
3539 {
3540   GOutputVector one_vector;
3541   char zero;
3542
3543   g_return_val_if_fail (G_IS_SOCKET (socket), -1);
3544
3545   if (!check_socket (socket, error))
3546     return -1;
3547
3548   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3549     return -1;
3550
3551   if (num_vectors == -1)
3552     {
3553       for (num_vectors = 0;
3554            vectors[num_vectors].buffer != NULL;
3555            num_vectors++)
3556         ;
3557     }
3558
3559   if (num_messages == -1)
3560     {
3561       for (num_messages = 0;
3562            messages != NULL && messages[num_messages] != NULL;
3563            num_messages++)
3564         ;
3565     }
3566
3567   if (num_vectors == 0)
3568     {
3569       zero = '\0';
3570
3571       one_vector.buffer = &zero;
3572       one_vector.size = 1;
3573       num_vectors = 1;
3574       vectors = &one_vector;
3575     }
3576
3577 #ifndef G_OS_WIN32
3578   {
3579     struct msghdr msg;
3580     gssize result;
3581
3582    msg.msg_flags = 0;
3583
3584     /* name */
3585     if (address)
3586       {
3587         msg.msg_namelen = g_socket_address_get_native_size (address);
3588         msg.msg_name = g_alloca (msg.msg_namelen);
3589         if (!g_socket_address_to_native (address, msg.msg_name, msg.msg_namelen, error))
3590           return -1;
3591       }
3592     else
3593       {
3594         msg.msg_name = NULL;
3595         msg.msg_namelen = 0;
3596       }
3597
3598     /* iov */
3599     {
3600       /* this entire expression will be evaluated at compile time */
3601       if (sizeof *msg.msg_iov == sizeof *vectors &&
3602           sizeof msg.msg_iov->iov_base == sizeof vectors->buffer &&
3603           G_STRUCT_OFFSET (struct iovec, iov_base) ==
3604           G_STRUCT_OFFSET (GOutputVector, buffer) &&
3605           sizeof msg.msg_iov->iov_len == sizeof vectors->size &&
3606           G_STRUCT_OFFSET (struct iovec, iov_len) ==
3607           G_STRUCT_OFFSET (GOutputVector, size))
3608         /* ABI is compatible */
3609         {
3610           msg.msg_iov = (struct iovec *) vectors;
3611           msg.msg_iovlen = num_vectors;
3612         }
3613       else
3614         /* ABI is incompatible */
3615         {
3616           gint i;
3617
3618           msg.msg_iov = g_newa (struct iovec, num_vectors);
3619           for (i = 0; i < num_vectors; i++)
3620             {
3621               msg.msg_iov[i].iov_base = (void *) vectors[i].buffer;
3622               msg.msg_iov[i].iov_len = vectors[i].size;
3623             }
3624           msg.msg_iovlen = num_vectors;
3625         }
3626     }
3627
3628     /* control */
3629     {
3630       struct cmsghdr *cmsg;
3631       gint i;
3632
3633       msg.msg_controllen = 0;
3634       for (i = 0; i < num_messages; i++)
3635         msg.msg_controllen += CMSG_SPACE (g_socket_control_message_get_size (messages[i]));
3636
3637       if (msg.msg_controllen == 0)
3638         msg.msg_control = NULL;
3639       else
3640         {
3641           msg.msg_control = g_alloca (msg.msg_controllen);
3642           memset (msg.msg_control, '\0', msg.msg_controllen);
3643         }
3644
3645       cmsg = CMSG_FIRSTHDR (&msg);
3646       for (i = 0; i < num_messages; i++)
3647         {
3648           cmsg->cmsg_level = g_socket_control_message_get_level (messages[i]);
3649           cmsg->cmsg_type = g_socket_control_message_get_msg_type (messages[i]);
3650           cmsg->cmsg_len = CMSG_LEN (g_socket_control_message_get_size (messages[i]));
3651           g_socket_control_message_serialize (messages[i],
3652                                               CMSG_DATA (cmsg));
3653           cmsg = CMSG_NXTHDR (&msg, cmsg);
3654         }
3655       g_assert (cmsg == NULL);
3656     }
3657
3658     while (1)
3659       {
3660         if (socket->priv->blocking &&
3661             !g_socket_condition_wait (socket,
3662                                       G_IO_OUT, cancellable, error))
3663           return -1;
3664
3665         result = sendmsg (socket->priv->fd, &msg, flags | G_SOCKET_DEFAULT_SEND_FLAGS);
3666         if (result < 0)
3667           {
3668             int errsv = get_socket_errno ();
3669
3670             if (errsv == EINTR)
3671               continue;
3672
3673             if (socket->priv->blocking &&
3674                 (errsv == EWOULDBLOCK ||
3675                  errsv == EAGAIN))
3676               continue;
3677
3678             g_set_error (error, G_IO_ERROR,
3679                          socket_io_error_from_errno (errsv),
3680                          _("Error sending message: %s"), socket_strerror (errsv));
3681
3682             return -1;
3683           }
3684         break;
3685       }
3686
3687     return result;
3688   }
3689 #else
3690   {
3691     struct sockaddr_storage addr;
3692     guint addrlen;
3693     DWORD bytes_sent;
3694     int result;
3695     WSABUF *bufs;
3696     gint i;
3697
3698     /* Win32 doesn't support control messages.
3699        Actually this is possible for raw and datagram sockets
3700        via WSASendMessage on Vista or later, but that doesn't
3701        seem very useful */
3702     if (num_messages != 0)
3703       {
3704         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
3705                              _("GSocketControlMessage not supported on windows"));
3706         return -1;
3707       }
3708
3709     /* iov */
3710     bufs = g_newa (WSABUF, num_vectors);
3711     for (i = 0; i < num_vectors; i++)
3712       {
3713         bufs[i].buf = (char *)vectors[i].buffer;
3714         bufs[i].len = (gulong)vectors[i].size;
3715       }
3716
3717     /* name */
3718     addrlen = 0; /* Avoid warning */
3719     if (address)
3720       {
3721         addrlen = g_socket_address_get_native_size (address);
3722         if (!g_socket_address_to_native (address, &addr, sizeof addr, error))
3723           return -1;
3724       }
3725
3726     while (1)
3727       {
3728         if (socket->priv->blocking &&
3729             !g_socket_condition_wait (socket,
3730                                       G_IO_OUT, cancellable, error))
3731           return -1;
3732
3733         if (address)
3734           result = WSASendTo (socket->priv->fd,
3735                               bufs, num_vectors,
3736                               &bytes_sent, flags,
3737                               (const struct sockaddr *)&addr, addrlen,
3738                               NULL, NULL);
3739         else
3740           result = WSASend (socket->priv->fd,
3741                             bufs, num_vectors,
3742                             &bytes_sent, flags,
3743                             NULL, NULL);
3744
3745         if (result != 0)
3746           {
3747             int errsv = get_socket_errno ();
3748
3749             if (errsv == WSAEINTR)
3750               continue;
3751
3752             if (errsv == WSAEWOULDBLOCK)
3753               win32_unset_event_mask (socket, FD_WRITE);
3754
3755             if (socket->priv->blocking &&
3756                 errsv == WSAEWOULDBLOCK)
3757               continue;
3758
3759             g_set_error (error, G_IO_ERROR,
3760                          socket_io_error_from_errno (errsv),
3761                          _("Error sending message: %s"), socket_strerror (errsv));
3762
3763             return -1;
3764           }
3765         break;
3766       }
3767
3768     return bytes_sent;
3769   }
3770 #endif
3771 }
3772
3773 /**
3774  * g_socket_receive_message:
3775  * @socket: a #GSocket
3776  * @address: (out) (allow-none): a pointer to a #GSocketAddress
3777  *     pointer, or %NULL
3778  * @vectors: (array length=num_vectors): an array of #GInputVector structs
3779  * @num_vectors: the number of elements in @vectors, or -1
3780  * @messages: (array length=num_messages) (allow-none): a pointer which
3781  *    may be filled with an array of #GSocketControlMessages, or %NULL
3782  * @num_messages: a pointer which will be filled with the number of
3783  *    elements in @messages, or %NULL
3784  * @flags: a pointer to an int containing #GSocketMsgFlags flags
3785  * @cancellable: (allow-none): a %GCancellable or %NULL
3786  * @error: a #GError pointer, or %NULL
3787  *
3788  * Receive data from a socket.  This is the most complicated and
3789  * fully-featured version of this call. For easier use, see
3790  * g_socket_receive() and g_socket_receive_from().
3791  *
3792  * If @address is non-%NULL then @address will be set equal to the
3793  * source address of the received packet.
3794  * @address is owned by the caller.
3795  *
3796  * @vector must point to an array of #GInputVector structs and
3797  * @num_vectors must be the length of this array.  These structs
3798  * describe the buffers that received data will be scattered into.
3799  * If @num_vectors is -1, then @vectors is assumed to be terminated
3800  * by a #GInputVector with a %NULL buffer pointer.
3801  *
3802  * As a special case, if @num_vectors is 0 (in which case, @vectors
3803  * may of course be %NULL), then a single byte is received and
3804  * discarded. This is to facilitate the common practice of sending a
3805  * single '\0' byte for the purposes of transferring ancillary data.
3806  *
3807  * @messages, if non-%NULL, will be set to point to a newly-allocated
3808  * array of #GSocketControlMessage instances or %NULL if no such
3809  * messages was received. These correspond to the control messages
3810  * received from the kernel, one #GSocketControlMessage per message
3811  * from the kernel. This array is %NULL-terminated and must be freed
3812  * by the caller using g_free() after calling g_object_unref() on each
3813  * element. If @messages is %NULL, any control messages received will
3814  * be discarded.
3815  *
3816  * @num_messages, if non-%NULL, will be set to the number of control
3817  * messages received.
3818  *
3819  * If both @messages and @num_messages are non-%NULL, then
3820  * @num_messages gives the number of #GSocketControlMessage instances
3821  * in @messages (ie: not including the %NULL terminator).
3822  *
3823  * @flags is an in/out parameter. The commonly available arguments
3824  * for this are available in the #GSocketMsgFlags enum, but the
3825  * values there are the same as the system values, and the flags
3826  * are passed in as-is, so you can pass in system-specific flags too
3827  * (and g_socket_receive_message() may pass system-specific flags out).
3828  *
3829  * As with g_socket_receive(), data may be discarded if @socket is
3830  * %G_SOCKET_TYPE_DATAGRAM or %G_SOCKET_TYPE_SEQPACKET and you do not
3831  * provide enough buffer space to read a complete message. You can pass
3832  * %G_SOCKET_MSG_PEEK in @flags to peek at the current message without
3833  * removing it from the receive queue, but there is no portable way to find
3834  * out the length of the message other than by reading it into a
3835  * sufficiently-large buffer.
3836  *
3837  * If the socket is in blocking mode the call will block until there
3838  * is some data to receive, the connection is closed, or there is an
3839  * error. If there is no data available and the socket is in
3840  * non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
3841  * returned. To be notified when data is available, wait for the
3842  * %G_IO_IN condition.
3843  *
3844  * On error -1 is returned and @error is set accordingly.
3845  *
3846  * Returns: Number of bytes read, or 0 if the connection was closed by
3847  * the peer, or -1 on error
3848  *
3849  * Since: 2.22
3850  */
3851 gssize
3852 g_socket_receive_message (GSocket                 *socket,
3853                           GSocketAddress         **address,
3854                           GInputVector            *vectors,
3855                           gint                     num_vectors,
3856                           GSocketControlMessage ***messages,
3857                           gint                    *num_messages,
3858                           gint                    *flags,
3859                           GCancellable            *cancellable,
3860                           GError                 **error)
3861 {
3862   GInputVector one_vector;
3863   char one_byte;
3864
3865   g_return_val_if_fail (G_IS_SOCKET (socket), -1);
3866
3867   if (!check_socket (socket, error))
3868     return -1;
3869
3870   if (g_cancellable_set_error_if_cancelled (cancellable, error))
3871     return -1;
3872
3873   if (num_vectors == -1)
3874     {
3875       for (num_vectors = 0;
3876            vectors[num_vectors].buffer != NULL;
3877            num_vectors++)
3878         ;
3879     }
3880
3881   if (num_vectors == 0)
3882     {
3883       one_vector.buffer = &one_byte;
3884       one_vector.size = 1;
3885       num_vectors = 1;
3886       vectors = &one_vector;
3887     }
3888
3889 #ifndef G_OS_WIN32
3890   {
3891     struct msghdr msg;
3892     gssize result;
3893     struct sockaddr_storage one_sockaddr;
3894
3895     /* name */
3896     if (address)
3897       {
3898         msg.msg_name = &one_sockaddr;
3899         msg.msg_namelen = sizeof (struct sockaddr_storage);
3900       }
3901     else
3902       {
3903         msg.msg_name = NULL;
3904         msg.msg_namelen = 0;
3905       }
3906
3907     /* iov */
3908     /* this entire expression will be evaluated at compile time */
3909     if (sizeof *msg.msg_iov == sizeof *vectors &&
3910         sizeof msg.msg_iov->iov_base == sizeof vectors->buffer &&
3911         G_STRUCT_OFFSET (struct iovec, iov_base) ==
3912         G_STRUCT_OFFSET (GInputVector, buffer) &&
3913         sizeof msg.msg_iov->iov_len == sizeof vectors->size &&
3914         G_STRUCT_OFFSET (struct iovec, iov_len) ==
3915         G_STRUCT_OFFSET (GInputVector, size))
3916       /* ABI is compatible */
3917       {
3918         msg.msg_iov = (struct iovec *) vectors;
3919         msg.msg_iovlen = num_vectors;
3920       }
3921     else
3922       /* ABI is incompatible */
3923       {
3924         gint i;
3925
3926         msg.msg_iov = g_newa (struct iovec, num_vectors);
3927         for (i = 0; i < num_vectors; i++)
3928           {
3929             msg.msg_iov[i].iov_base = vectors[i].buffer;
3930             msg.msg_iov[i].iov_len = vectors[i].size;
3931           }
3932         msg.msg_iovlen = num_vectors;
3933       }
3934
3935     /* control */
3936     msg.msg_control = g_alloca (2048);
3937     msg.msg_controllen = 2048;
3938
3939     /* flags */
3940     if (flags != NULL)
3941       msg.msg_flags = *flags;
3942     else
3943       msg.msg_flags = 0;
3944
3945     /* We always set the close-on-exec flag so we don't leak file
3946      * descriptors into child processes.  Note that gunixfdmessage.c
3947      * will later call fcntl (fd, FD_CLOEXEC), but that isn't atomic.
3948      */
3949 #ifdef MSG_CMSG_CLOEXEC
3950     msg.msg_flags |= MSG_CMSG_CLOEXEC;
3951 #endif
3952
3953     /* do it */
3954     while (1)
3955       {
3956         if (socket->priv->blocking &&
3957             !g_socket_condition_wait (socket,
3958                                       G_IO_IN, cancellable, error))
3959           return -1;
3960
3961         result = recvmsg (socket->priv->fd, &msg, msg.msg_flags);
3962 #ifdef MSG_CMSG_CLOEXEC
3963         if (result < 0 && get_socket_errno () == EINVAL)
3964           {
3965             /* We must be running on an old kernel.  Call without the flag. */
3966             msg.msg_flags &= ~(MSG_CMSG_CLOEXEC);
3967             result = recvmsg (socket->priv->fd, &msg, msg.msg_flags);
3968           }
3969 #endif
3970
3971         if (result < 0)
3972           {
3973             int errsv = get_socket_errno ();
3974
3975             if (errsv == EINTR)
3976               continue;
3977
3978             if (socket->priv->blocking &&
3979                 (errsv == EWOULDBLOCK ||
3980                  errsv == EAGAIN))
3981               continue;
3982
3983             g_set_error (error, G_IO_ERROR,
3984                          socket_io_error_from_errno (errsv),
3985                          _("Error receiving message: %s"), socket_strerror (errsv));
3986
3987             return -1;
3988           }
3989         break;
3990       }
3991
3992     /* decode address */
3993     if (address != NULL)
3994       {
3995         if (msg.msg_namelen > 0)
3996           *address = g_socket_address_new_from_native (msg.msg_name,
3997                                                        msg.msg_namelen);
3998         else
3999           *address = NULL;
4000       }
4001
4002     /* decode control messages */
4003     {
4004       GPtrArray *my_messages = NULL;
4005       struct cmsghdr *cmsg;
4006
4007       for (cmsg = CMSG_FIRSTHDR (&msg); cmsg; cmsg = CMSG_NXTHDR (&msg, cmsg))
4008         {
4009           GSocketControlMessage *message;
4010
4011           message = g_socket_control_message_deserialize (cmsg->cmsg_level,
4012                                                           cmsg->cmsg_type,
4013                                                           cmsg->cmsg_len - ((char *)CMSG_DATA (cmsg) - (char *)cmsg),
4014                                                           CMSG_DATA (cmsg));
4015           if (message == NULL)
4016             /* We've already spewed about the problem in the
4017                deserialization code, so just continue */
4018             continue;
4019
4020           if (messages == NULL)
4021             {
4022               /* we have to do it this way if the user ignores the
4023                * messages so that we will close any received fds.
4024                */
4025               g_object_unref (message);
4026             }
4027           else
4028             {
4029               if (my_messages == NULL)
4030                 my_messages = g_ptr_array_new ();
4031               g_ptr_array_add (my_messages, message);
4032             }
4033         }
4034
4035       if (num_messages)
4036         *num_messages = my_messages != NULL ? my_messages->len : 0;
4037
4038       if (messages)
4039         {
4040           if (my_messages == NULL)
4041             {
4042               *messages = NULL;
4043             }
4044           else
4045             {
4046               g_ptr_array_add (my_messages, NULL);
4047               *messages = (GSocketControlMessage **) g_ptr_array_free (my_messages, FALSE);
4048             }
4049         }
4050       else
4051         {
4052           g_assert (my_messages == NULL);
4053         }
4054     }
4055
4056     /* capture the flags */
4057     if (flags != NULL)
4058       *flags = msg.msg_flags;
4059
4060     return result;
4061   }
4062 #else
4063   {
4064     struct sockaddr_storage addr;
4065     int addrlen;
4066     DWORD bytes_received;
4067     DWORD win_flags;
4068     int result;
4069     WSABUF *bufs;
4070     gint i;
4071
4072     /* iov */
4073     bufs = g_newa (WSABUF, num_vectors);
4074     for (i = 0; i < num_vectors; i++)
4075       {
4076         bufs[i].buf = (char *)vectors[i].buffer;
4077         bufs[i].len = (gulong)vectors[i].size;
4078       }
4079
4080     /* flags */
4081     if (flags != NULL)
4082       win_flags = *flags;
4083     else
4084       win_flags = 0;
4085
4086     /* do it */
4087     while (1)
4088       {
4089         if (socket->priv->blocking &&
4090             !g_socket_condition_wait (socket,
4091                                       G_IO_IN, cancellable, error))
4092           return -1;
4093
4094         addrlen = sizeof addr;
4095         if (address)
4096           result = WSARecvFrom (socket->priv->fd,
4097                                 bufs, num_vectors,
4098                                 &bytes_received, &win_flags,
4099                                 (struct sockaddr *)&addr, &addrlen,
4100                                 NULL, NULL);
4101         else
4102           result = WSARecv (socket->priv->fd,
4103                             bufs, num_vectors,
4104                             &bytes_received, &win_flags,
4105                             NULL, NULL);
4106         if (result != 0)
4107           {
4108             int errsv = get_socket_errno ();
4109
4110             if (errsv == WSAEINTR)
4111               continue;
4112
4113             win32_unset_event_mask (socket, FD_READ);
4114
4115             if (socket->priv->blocking &&
4116                 errsv == WSAEWOULDBLOCK)
4117               continue;
4118
4119             g_set_error (error, G_IO_ERROR,
4120                          socket_io_error_from_errno (errsv),
4121                          _("Error receiving message: %s"), socket_strerror (errsv));
4122
4123             return -1;
4124           }
4125         win32_unset_event_mask (socket, FD_READ);
4126         break;
4127       }
4128
4129     /* decode address */
4130     if (address != NULL)
4131       {
4132         if (addrlen > 0)
4133           *address = g_socket_address_new_from_native (&addr, addrlen);
4134         else
4135           *address = NULL;
4136       }
4137
4138     /* capture the flags */
4139     if (flags != NULL)
4140       *flags = win_flags;
4141
4142     if (messages != NULL)
4143       *messages = NULL;
4144     if (num_messages != NULL)
4145       *num_messages = 0;
4146
4147     return bytes_received;
4148   }
4149 #endif
4150 }
4151
4152 /**
4153  * g_socket_get_credentials:
4154  * @socket: a #GSocket.
4155  * @error: #GError for error reporting, or %NULL to ignore.
4156  *
4157  * Returns the credentials of the foreign process connected to this
4158  * socket, if any (e.g. it is only supported for %G_SOCKET_FAMILY_UNIX
4159  * sockets).
4160  *
4161  * If this operation isn't supported on the OS, the method fails with
4162  * the %G_IO_ERROR_NOT_SUPPORTED error. On Linux this is implemented
4163  * by reading the %SO_PEERCRED option on the underlying socket.
4164  *
4165  * Other ways to obtain credentials from a foreign peer includes the
4166  * #GUnixCredentialsMessage type and
4167  * g_unix_connection_send_credentials() /
4168  * g_unix_connection_receive_credentials() functions.
4169  *
4170  * Returns: (transfer full): %NULL if @error is set, otherwise a #GCredentials object
4171  * that must be freed with g_object_unref().
4172  *
4173  * Since: 2.26
4174  */
4175 GCredentials *
4176 g_socket_get_credentials (GSocket   *socket,
4177                           GError   **error)
4178 {
4179   GCredentials *ret;
4180
4181   g_return_val_if_fail (G_IS_SOCKET (socket), NULL);
4182   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
4183
4184   ret = NULL;
4185
4186 #if defined(__linux__) || defined(__OpenBSD__)
4187   {
4188     socklen_t optlen;
4189 #if defined(__linux__)
4190     struct ucred native_creds;
4191     optlen = sizeof (struct ucred);
4192 #elif defined(__OpenBSD__)
4193     struct sockpeercred native_creds;
4194     optlen = sizeof (struct sockpeercred);
4195 #endif
4196     if (getsockopt (socket->priv->fd,
4197                     SOL_SOCKET,
4198                     SO_PEERCRED,
4199                     (void *)&native_creds,
4200                     &optlen) != 0)
4201       {
4202         int errsv = get_socket_errno ();
4203         g_set_error (error,
4204                      G_IO_ERROR,
4205                      socket_io_error_from_errno (errsv),
4206                      _("Unable to get pending error: %s"),
4207                      socket_strerror (errsv));
4208       }
4209     else
4210       {
4211         ret = g_credentials_new ();
4212         g_credentials_set_native (ret,
4213 #if defined(__linux__)
4214                                   G_CREDENTIALS_TYPE_LINUX_UCRED,
4215 #elif defined(__OpenBSD__)
4216                                   G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED,
4217 #endif
4218                                   &native_creds);
4219       }
4220   }
4221 #else
4222   g_set_error_literal (error,
4223                        G_IO_ERROR,
4224                        G_IO_ERROR_NOT_SUPPORTED,
4225                        _("g_socket_get_credentials not implemented for this OS"));
4226 #endif
4227
4228   return ret;
4229 }