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