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