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