gio/gsocket.c

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