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