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