gio/gsocket.c

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