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