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