1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2008 Christian Kellner, Samuel Cormier-Iijima
4 * Copyright © 2009 Codethink Limited
5 * Copyright © 2009 Red Hat, Inc
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.
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.
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20 * Boston, MA 02111-1307, USA.
22 * Authors: Christian Kellner <gicmo@gnome.org>
23 * Samuel Cormier-Iijima <sciyoshi@gmail.com>
24 * Ryan Lortie <desrt@desrt.ca>
25 * Alexander Larsson <alexl@redhat.com>
33 #include "glib-unix.h"
44 # include <sys/ioctl.h>
47 #ifdef HAVE_SYS_FILIO_H
48 # include <sys/filio.h>
55 #include "gcancellable.h"
56 #include "gioenumtypes.h"
57 #include "ginetaddress.h"
58 #include "ginitable.h"
62 #include "gnetworkingprivate.h"
63 #include "gsocketaddress.h"
64 #include "gsocketcontrolmessage.h"
65 #include "gcredentials.h"
70 * @short_description: Low-level socket object
72 * @see_also: #GInitable, <link linkend="gio-gnetworking.h">gnetworking.h</link>
74 * A #GSocket is a low-level networking primitive. It is a more or less
75 * direct mapping of the BSD socket API in a portable GObject based API.
76 * It supports both the UNIX socket implementations and winsock2 on Windows.
78 * #GSocket is the platform independent base upon which the higher level
79 * network primitives are based. Applications are not typically meant to
80 * use it directly, but rather through classes like #GSocketClient,
81 * #GSocketService and #GSocketConnection. However there may be cases where
82 * direct use of #GSocket is useful.
84 * #GSocket implements the #GInitable interface, so if it is manually constructed
85 * by e.g. g_object_new() you must call g_initable_init() and check the
86 * results before using the object. This is done automatically in
87 * g_socket_new() and g_socket_new_from_fd(), so these functions can return
90 * Sockets operate in two general modes, blocking or non-blocking. When
91 * in blocking mode all operations block until the requested operation
92 * is finished or there is an error. In non-blocking mode all calls that
93 * would block return immediately with a %G_IO_ERROR_WOULD_BLOCK error.
94 * To know when a call would successfully run you can call g_socket_condition_check(),
95 * or g_socket_condition_wait(). You can also use g_socket_create_source() and
96 * attach it to a #GMainContext to get callbacks when I/O is possible.
97 * Note that all sockets are always set to non blocking mode in the system, and
98 * blocking mode is emulated in GSocket.
100 * When working in non-blocking mode applications should always be able to
101 * handle getting a %G_IO_ERROR_WOULD_BLOCK error even when some other
102 * function said that I/O was possible. This can easily happen in case
103 * of a race condition in the application, but it can also happen for other
104 * reasons. For instance, on Windows a socket is always seen as writable
105 * until a write returns %G_IO_ERROR_WOULD_BLOCK.
107 * #GSocket<!-- -->s can be either connection oriented or datagram based.
108 * For connection oriented types you must first establish a connection by
109 * either connecting to an address or accepting a connection from another
110 * address. For connectionless socket types the target/source address is
111 * specified or received in each I/O operation.
113 * All socket file descriptors are set to be close-on-exec.
115 * Note that creating a #GSocket causes the signal %SIGPIPE to be
116 * ignored for the remainder of the program. If you are writing a
117 * command-line utility that uses #GSocket, you may need to take into
118 * account the fact that your program will not automatically be killed
119 * if it tries to write to %stdout after it has been closed.
124 static void g_socket_initable_iface_init (GInitableIface
*iface
);
125 static gboolean
g_socket_initable_init (GInitable
*initable
,
126 GCancellable
*cancellable
,
144 PROP_MULTICAST_LOOPBACK
,
148 /* Size of the receiver cache for g_socket_receive_from() */
149 #define RECV_ADDR_CACHE_SIZE 8
151 struct _GSocketPrivate
153 GSocketFamily family
;
155 GSocketProtocol protocol
;
159 GError
*construct_error
;
160 GSocketAddress
*remote_address
;
168 guint connect_pending
: 1;
174 GList
*requested_conditions
; /* list of requested GIOCondition * */
178 GSocketAddress
*addr
;
179 struct sockaddr
*native
;
182 } recv_addr_cache
[RECV_ADDR_CACHE_SIZE
];
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
));
192 get_socket_errno (void)
197 return WSAGetLastError ();
202 socket_io_error_from_errno (int err
)
205 return g_io_error_from_errno (err
);
210 return G_IO_ERROR_ADDRESS_IN_USE
;
212 return G_IO_ERROR_WOULD_BLOCK
;
214 return G_IO_ERROR_PERMISSION_DENIED
;
215 case WSA_INVALID_HANDLE
:
216 case WSA_INVALID_PARAMETER
:
219 return G_IO_ERROR_INVALID_ARGUMENT
;
220 case WSAEPROTONOSUPPORT
:
221 return G_IO_ERROR_NOT_SUPPORTED
;
223 return G_IO_ERROR_CANCELLED
;
224 case WSAESOCKTNOSUPPORT
:
226 case WSAEPFNOSUPPORT
:
227 case WSAEAFNOSUPPORT
:
228 return G_IO_ERROR_NOT_SUPPORTED
;
230 return G_IO_ERROR_FAILED
;
236 socket_strerror (int err
)
239 return g_strerror (err
);
244 msg
= g_win32_error_message (err
);
246 msg_ret
= g_intern_string (msg
);
254 #define win32_unset_event_mask(_socket, _mask) _win32_unset_event_mask (_socket, _mask)
256 _win32_unset_event_mask (GSocket
*socket
, int mask
)
258 socket
->priv
->current_events
&= ~mask
;
259 socket
->priv
->current_errors
&= ~mask
;
262 #define win32_unset_event_mask(_socket, _mask)
265 /* Windows has broken prototypes... */
267 #define getsockopt(sockfd, level, optname, optval, optlen) \
268 getsockopt (sockfd, level, optname, (gpointer) optval, (int*) optlen)
269 #define setsockopt(sockfd, level, optname, optval, optlen) \
270 setsockopt (sockfd, level, optname, (gpointer) optval, optlen)
271 #define getsockname(sockfd, addr, addrlen) \
272 getsockname (sockfd, addr, (int *)addrlen)
273 #define getpeername(sockfd, addr, addrlen) \
274 getpeername (sockfd, addr, (int *)addrlen)
275 #define recv(sockfd, buf, len, flags) \
276 recv (sockfd, (gpointer)buf, len, flags)
280 set_fd_nonblocking (int fd
)
283 GError
*error
= NULL
;
289 if (!g_unix_set_fd_nonblocking (fd
, TRUE
, &error
))
291 g_warning ("Error setting socket nonblocking: %s", error
->message
);
292 g_clear_error (&error
);
297 if (ioctlsocket (fd
, FIONBIO
, &arg
) == SOCKET_ERROR
)
299 int errsv
= get_socket_errno ();
300 g_warning ("Error setting socket status flags: %s", socket_strerror (errsv
));
306 check_socket (GSocket
*socket
,
309 if (!socket
->priv
->inited
)
311 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_NOT_INITIALIZED
,
312 _("Invalid socket, not initialized"));
316 if (socket
->priv
->construct_error
)
318 g_set_error (error
, G_IO_ERROR
, G_IO_ERROR_NOT_INITIALIZED
,
319 _("Invalid socket, initialization failed due to: %s"),
320 socket
->priv
->construct_error
->message
);
324 if (socket
->priv
->closed
)
326 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_CLOSED
,
327 _("Socket is already closed"));
331 if (socket
->priv
->timed_out
)
333 socket
->priv
->timed_out
= FALSE
;
334 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_TIMED_OUT
,
335 _("Socket I/O timed out"));
343 g_socket_details_from_fd (GSocket
*socket
)
345 struct sockaddr_storage address
;
351 fd
= socket
->priv
->fd
;
352 if (!g_socket_get_option (socket
, SOL_SOCKET
, SO_TYPE
, &value
, NULL
))
354 errsv
= get_socket_errno ();
366 /* programmer error */
367 g_error ("creating GSocket from fd %d: %s\n",
368 fd
, socket_strerror (errsv
));
379 socket
->priv
->type
= G_SOCKET_TYPE_STREAM
;
383 socket
->priv
->type
= G_SOCKET_TYPE_DATAGRAM
;
387 socket
->priv
->type
= G_SOCKET_TYPE_SEQPACKET
;
391 socket
->priv
->type
= G_SOCKET_TYPE_INVALID
;
395 addrlen
= sizeof address
;
396 if (getsockname (fd
, (struct sockaddr
*) &address
, &addrlen
) != 0)
398 errsv
= get_socket_errno ();
404 g_assert (G_STRUCT_OFFSET (struct sockaddr
, sa_family
) +
405 sizeof address
.ss_family
<= addrlen
);
406 family
= address
.ss_family
;
410 /* On Solaris, this happens if the socket is not yet connected.
411 * But we can use SO_DOMAIN as a workaround there.
414 if (!g_socket_get_option (socket
, SOL_SOCKET
, SO_DOMAIN
, &family
, NULL
))
416 errsv
= get_socket_errno ();
420 /* This will translate to G_IO_ERROR_FAILED on either unix or windows */
428 case G_SOCKET_FAMILY_IPV4
:
429 case G_SOCKET_FAMILY_IPV6
:
430 socket
->priv
->family
= address
.ss_family
;
431 switch (socket
->priv
->type
)
433 case G_SOCKET_TYPE_STREAM
:
434 socket
->priv
->protocol
= G_SOCKET_PROTOCOL_TCP
;
437 case G_SOCKET_TYPE_DATAGRAM
:
438 socket
->priv
->protocol
= G_SOCKET_PROTOCOL_UDP
;
441 case G_SOCKET_TYPE_SEQPACKET
:
442 socket
->priv
->protocol
= G_SOCKET_PROTOCOL_SCTP
;
450 case G_SOCKET_FAMILY_UNIX
:
451 socket
->priv
->family
= G_SOCKET_FAMILY_UNIX
;
452 socket
->priv
->protocol
= G_SOCKET_PROTOCOL_DEFAULT
;
456 socket
->priv
->family
= G_SOCKET_FAMILY_INVALID
;
460 if (socket
->priv
->family
!= G_SOCKET_FAMILY_INVALID
)
462 addrlen
= sizeof address
;
463 if (getpeername (fd
, (struct sockaddr
*) &address
, &addrlen
) >= 0)
464 socket
->priv
->connected
= TRUE
;
467 if (g_socket_get_option (socket
, SOL_SOCKET
, SO_KEEPALIVE
, &value
, NULL
))
469 socket
->priv
->keepalive
= !!value
;
473 /* Can't read, maybe not supported, assume FALSE */
474 socket
->priv
->keepalive
= FALSE
;
480 g_set_error (&socket
->priv
->construct_error
, G_IO_ERROR
,
481 socket_io_error_from_errno (errsv
),
482 _("creating GSocket from fd: %s"),
483 socket_strerror (errsv
));
486 /* Wrapper around socket() that is shared with gnetworkmonitornetlink.c */
488 g_socket (gint domain
,
496 fd
= socket (domain
, type
| SOCK_CLOEXEC
, protocol
);
500 /* It's possible that libc has SOCK_CLOEXEC but the kernel does not */
501 if (fd
< 0 && errno
== EINVAL
)
503 fd
= socket (domain
, type
, protocol
);
507 int errsv
= get_socket_errno ();
509 g_set_error (error
, G_IO_ERROR
, socket_io_error_from_errno (errsv
),
510 _("Unable to create socket: %s"), socket_strerror (errsv
));
519 /* We always want to set close-on-exec to protect users. If you
520 need to so some weird inheritance to exec you can re-enable this
521 using lower level hacks with g_socket_get_fd(). */
522 flags
= fcntl (fd
, F_GETFD
, 0);
524 (flags
& FD_CLOEXEC
) == 0)
527 fcntl (fd
, F_SETFD
, flags
);
536 g_socket_create_socket (GSocketFamily family
,
545 case G_SOCKET_TYPE_STREAM
:
546 native_type
= SOCK_STREAM
;
549 case G_SOCKET_TYPE_DATAGRAM
:
550 native_type
= SOCK_DGRAM
;
553 case G_SOCKET_TYPE_SEQPACKET
:
554 native_type
= SOCK_SEQPACKET
;
558 g_assert_not_reached ();
563 g_set_error (error
, G_IO_ERROR
, G_IO_ERROR_INVALID_ARGUMENT
,
564 _("Unable to create socket: %s"), _("Unknown family was specified"));
570 g_set_error (error
, G_IO_ERROR
, G_IO_ERROR_INVALID_ARGUMENT
,
571 _("Unable to create socket: %s"), _("Unknown protocol was specified"));
575 return g_socket (family
, native_type
, protocol
, error
);
579 g_socket_constructed (GObject
*object
)
581 GSocket
*socket
= G_SOCKET (object
);
583 if (socket
->priv
->fd
>= 0)
584 /* create socket->priv info from the fd */
585 g_socket_details_from_fd (socket
);
588 /* create the fd from socket->priv info */
589 socket
->priv
->fd
= g_socket_create_socket (socket
->priv
->family
,
591 socket
->priv
->protocol
,
592 &socket
->priv
->construct_error
);
594 /* Always use native nonblocking sockets, as
595 windows sets sockets to nonblocking automatically
596 in certain operations. This way we make things work
597 the same on all platforms */
598 if (socket
->priv
->fd
!= -1)
599 set_fd_nonblocking (socket
->priv
->fd
);
603 g_socket_get_property (GObject
*object
,
608 GSocket
*socket
= G_SOCKET (object
);
609 GSocketAddress
*address
;
614 g_value_set_enum (value
, socket
->priv
->family
);
618 g_value_set_enum (value
, socket
->priv
->type
);
622 g_value_set_enum (value
, socket
->priv
->protocol
);
626 g_value_set_int (value
, socket
->priv
->fd
);
630 g_value_set_boolean (value
, socket
->priv
->blocking
);
633 case PROP_LISTEN_BACKLOG
:
634 g_value_set_int (value
, socket
->priv
->listen_backlog
);
638 g_value_set_boolean (value
, socket
->priv
->keepalive
);
641 case PROP_LOCAL_ADDRESS
:
642 address
= g_socket_get_local_address (socket
, NULL
);
643 g_value_take_object (value
, address
);
646 case PROP_REMOTE_ADDRESS
:
647 address
= g_socket_get_remote_address (socket
, NULL
);
648 g_value_take_object (value
, address
);
652 g_value_set_uint (value
, socket
->priv
->timeout
);
656 g_value_set_uint (value
, g_socket_get_ttl (socket
));
660 g_value_set_boolean (value
, g_socket_get_broadcast (socket
));
663 case PROP_MULTICAST_LOOPBACK
:
664 g_value_set_boolean (value
, g_socket_get_multicast_loopback (socket
));
667 case PROP_MULTICAST_TTL
:
668 g_value_set_uint (value
, g_socket_get_multicast_ttl (socket
));
672 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
677 g_socket_set_property (GObject
*object
,
682 GSocket
*socket
= G_SOCKET (object
);
687 socket
->priv
->family
= g_value_get_enum (value
);
691 socket
->priv
->type
= g_value_get_enum (value
);
695 socket
->priv
->protocol
= g_value_get_enum (value
);
699 socket
->priv
->fd
= g_value_get_int (value
);
703 g_socket_set_blocking (socket
, g_value_get_boolean (value
));
706 case PROP_LISTEN_BACKLOG
:
707 g_socket_set_listen_backlog (socket
, g_value_get_int (value
));
711 g_socket_set_keepalive (socket
, g_value_get_boolean (value
));
715 g_socket_set_timeout (socket
, g_value_get_uint (value
));
719 g_socket_set_ttl (socket
, g_value_get_uint (value
));
723 g_socket_set_broadcast (socket
, g_value_get_boolean (value
));
726 case PROP_MULTICAST_LOOPBACK
:
727 g_socket_set_multicast_loopback (socket
, g_value_get_boolean (value
));
730 case PROP_MULTICAST_TTL
:
731 g_socket_set_multicast_ttl (socket
, g_value_get_uint (value
));
735 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
740 g_socket_finalize (GObject
*object
)
742 GSocket
*socket
= G_SOCKET (object
);
745 g_clear_error (&socket
->priv
->construct_error
);
747 if (socket
->priv
->fd
!= -1 &&
748 !socket
->priv
->closed
)
749 g_socket_close (socket
, NULL
);
751 if (socket
->priv
->remote_address
)
752 g_object_unref (socket
->priv
->remote_address
);
755 if (socket
->priv
->event
!= WSA_INVALID_EVENT
)
757 WSACloseEvent (socket
->priv
->event
);
758 socket
->priv
->event
= WSA_INVALID_EVENT
;
761 g_assert (socket
->priv
->requested_conditions
== NULL
);
764 for (i
= 0; i
< RECV_ADDR_CACHE_SIZE
; i
++)
766 if (socket
->priv
->recv_addr_cache
[i
].addr
)
768 g_object_unref (socket
->priv
->recv_addr_cache
[i
].addr
);
769 g_free (socket
->priv
->recv_addr_cache
[i
].native
);
773 if (G_OBJECT_CLASS (g_socket_parent_class
)->finalize
)
774 (*G_OBJECT_CLASS (g_socket_parent_class
)->finalize
) (object
);
778 g_socket_class_init (GSocketClass
*klass
)
780 GObjectClass
*gobject_class G_GNUC_UNUSED
= G_OBJECT_CLASS (klass
);
783 /* There is no portable, thread-safe way to avoid having the process
784 * be killed by SIGPIPE when calling send() or sendmsg(), so we are
785 * forced to simply ignore the signal process-wide.
787 signal (SIGPIPE
, SIG_IGN
);
790 gobject_class
->finalize
= g_socket_finalize
;
791 gobject_class
->constructed
= g_socket_constructed
;
792 gobject_class
->set_property
= g_socket_set_property
;
793 gobject_class
->get_property
= g_socket_get_property
;
795 g_object_class_install_property (gobject_class
, PROP_FAMILY
,
796 g_param_spec_enum ("family",
798 P_("The sockets address family"),
799 G_TYPE_SOCKET_FAMILY
,
800 G_SOCKET_FAMILY_INVALID
,
801 G_PARAM_CONSTRUCT_ONLY
|
803 G_PARAM_STATIC_STRINGS
));
805 g_object_class_install_property (gobject_class
, PROP_TYPE
,
806 g_param_spec_enum ("type",
808 P_("The sockets type"),
810 G_SOCKET_TYPE_STREAM
,
811 G_PARAM_CONSTRUCT_ONLY
|
813 G_PARAM_STATIC_STRINGS
));
815 g_object_class_install_property (gobject_class
, PROP_PROTOCOL
,
816 g_param_spec_enum ("protocol",
817 P_("Socket protocol"),
818 P_("The id of the protocol to use, or -1 for unknown"),
819 G_TYPE_SOCKET_PROTOCOL
,
820 G_SOCKET_PROTOCOL_UNKNOWN
,
821 G_PARAM_CONSTRUCT_ONLY
|
823 G_PARAM_STATIC_STRINGS
));
825 g_object_class_install_property (gobject_class
, PROP_FD
,
826 g_param_spec_int ("fd",
827 P_("File descriptor"),
828 P_("The sockets file descriptor"),
832 G_PARAM_CONSTRUCT_ONLY
|
834 G_PARAM_STATIC_STRINGS
));
836 g_object_class_install_property (gobject_class
, PROP_BLOCKING
,
837 g_param_spec_boolean ("blocking",
839 P_("Whether or not I/O on this socket is blocking"),
842 G_PARAM_STATIC_STRINGS
));
844 g_object_class_install_property (gobject_class
, PROP_LISTEN_BACKLOG
,
845 g_param_spec_int ("listen-backlog",
846 P_("Listen backlog"),
847 P_("Outstanding connections in the listen queue"),
852 G_PARAM_STATIC_STRINGS
));
854 g_object_class_install_property (gobject_class
, PROP_KEEPALIVE
,
855 g_param_spec_boolean ("keepalive",
856 P_("Keep connection alive"),
857 P_("Keep connection alive by sending periodic pings"),
860 G_PARAM_STATIC_STRINGS
));
862 g_object_class_install_property (gobject_class
, PROP_LOCAL_ADDRESS
,
863 g_param_spec_object ("local-address",
865 P_("The local address the socket is bound to"),
866 G_TYPE_SOCKET_ADDRESS
,
868 G_PARAM_STATIC_STRINGS
));
870 g_object_class_install_property (gobject_class
, PROP_REMOTE_ADDRESS
,
871 g_param_spec_object ("remote-address",
872 P_("Remote address"),
873 P_("The remote address the socket is connected to"),
874 G_TYPE_SOCKET_ADDRESS
,
876 G_PARAM_STATIC_STRINGS
));
881 * The timeout in seconds on socket I/O
885 g_object_class_install_property (gobject_class
, PROP_TIMEOUT
,
886 g_param_spec_uint ("timeout",
888 P_("The timeout in seconds on socket I/O"),
893 G_PARAM_STATIC_STRINGS
));
898 * Whether the socket should allow sending to broadcast addresses.
902 g_object_class_install_property (gobject_class
, PROP_BROADCAST
,
903 g_param_spec_boolean ("broadcast",
905 P_("Whether to allow sending to broadcast addresses"),
908 G_PARAM_STATIC_STRINGS
));
913 * Time-to-live for outgoing unicast packets
917 g_object_class_install_property (gobject_class
, PROP_TTL
,
918 g_param_spec_uint ("ttl",
920 P_("Time-to-live of outgoing unicast packets"),
923 G_PARAM_STATIC_STRINGS
));
926 * GSocket:multicast-loopback:
928 * Whether outgoing multicast packets loop back to the local host.
932 g_object_class_install_property (gobject_class
, PROP_MULTICAST_LOOPBACK
,
933 g_param_spec_boolean ("multicast-loopback",
934 P_("Multicast loopback"),
935 P_("Whether outgoing multicast packets loop back to the local host"),
938 G_PARAM_STATIC_STRINGS
));
941 * GSocket:multicast-ttl:
943 * Time-to-live out outgoing multicast packets
947 g_object_class_install_property (gobject_class
, PROP_MULTICAST_TTL
,
948 g_param_spec_uint ("multicast-ttl",
950 P_("Time-to-live of outgoing multicast packets"),
953 G_PARAM_STATIC_STRINGS
));
957 g_socket_initable_iface_init (GInitableIface
*iface
)
959 iface
->init
= g_socket_initable_init
;
963 g_socket_init (GSocket
*socket
)
965 socket
->priv
= g_socket_get_instance_private (socket
);
967 socket
->priv
->fd
= -1;
968 socket
->priv
->blocking
= TRUE
;
969 socket
->priv
->listen_backlog
= 10;
970 socket
->priv
->construct_error
= NULL
;
972 socket
->priv
->event
= WSA_INVALID_EVENT
;
977 g_socket_initable_init (GInitable
*initable
,
978 GCancellable
*cancellable
,
983 g_return_val_if_fail (G_IS_SOCKET (initable
), FALSE
);
985 socket
= G_SOCKET (initable
);
987 if (cancellable
!= NULL
)
989 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
990 _("Cancellable initialization not supported"));
994 socket
->priv
->inited
= TRUE
;
996 if (socket
->priv
->construct_error
)
999 *error
= g_error_copy (socket
->priv
->construct_error
);
1009 * @family: the socket family to use, e.g. %G_SOCKET_FAMILY_IPV4.
1010 * @type: the socket type to use.
1011 * @protocol: the id of the protocol to use, or 0 for default.
1012 * @error: #GError for error reporting, or %NULL to ignore.
1014 * Creates a new #GSocket with the defined family, type and protocol.
1015 * If @protocol is 0 (%G_SOCKET_PROTOCOL_DEFAULT) the default protocol type
1016 * for the family and type is used.
1018 * The @protocol is a family and type specific int that specifies what
1019 * kind of protocol to use. #GSocketProtocol lists several common ones.
1020 * Many families only support one protocol, and use 0 for this, others
1021 * support several and using 0 means to use the default protocol for
1022 * the family and type.
1024 * The protocol id is passed directly to the operating
1025 * system, so you can use protocols not listed in #GSocketProtocol if you
1026 * know the protocol number used for it.
1028 * Returns: a #GSocket or %NULL on error.
1029 * Free the returned object with g_object_unref().
1034 g_socket_new (GSocketFamily family
,
1036 GSocketProtocol protocol
,
1039 return G_SOCKET (g_initable_new (G_TYPE_SOCKET
,
1043 "protocol", protocol
,
1048 * g_socket_new_from_fd:
1049 * @fd: a native socket file descriptor.
1050 * @error: #GError for error reporting, or %NULL to ignore.
1052 * Creates a new #GSocket from a native file descriptor
1053 * or winsock SOCKET handle.
1055 * This reads all the settings from the file descriptor so that
1056 * all properties should work. Note that the file descriptor
1057 * will be set to non-blocking mode, independent on the blocking
1058 * mode of the #GSocket.
1060 * Returns: a #GSocket or %NULL on error.
1061 * Free the returned object with g_object_unref().
1066 g_socket_new_from_fd (gint fd
,
1069 return G_SOCKET (g_initable_new (G_TYPE_SOCKET
,
1076 * g_socket_set_blocking:
1077 * @socket: a #GSocket.
1078 * @blocking: Whether to use blocking I/O or not.
1080 * Sets the blocking mode of the socket. In blocking mode
1081 * all operations block until they succeed or there is an error. In
1082 * non-blocking mode all functions return results immediately or
1083 * with a %G_IO_ERROR_WOULD_BLOCK error.
1085 * All sockets are created in blocking mode. However, note that the
1086 * platform level socket is always non-blocking, and blocking mode
1087 * is a GSocket level feature.
1092 g_socket_set_blocking (GSocket
*socket
,
1095 g_return_if_fail (G_IS_SOCKET (socket
));
1097 blocking
= !!blocking
;
1099 if (socket
->priv
->blocking
== blocking
)
1102 socket
->priv
->blocking
= blocking
;
1103 g_object_notify (G_OBJECT (socket
), "blocking");
1107 * g_socket_get_blocking:
1108 * @socket: a #GSocket.
1110 * Gets the blocking mode of the socket. For details on blocking I/O,
1111 * see g_socket_set_blocking().
1113 * Returns: %TRUE if blocking I/O is used, %FALSE otherwise.
1118 g_socket_get_blocking (GSocket
*socket
)
1120 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
1122 return socket
->priv
->blocking
;
1126 * g_socket_set_keepalive:
1127 * @socket: a #GSocket.
1128 * @keepalive: Value for the keepalive flag
1130 * Sets or unsets the %SO_KEEPALIVE flag on the underlying socket. When
1131 * this flag is set on a socket, the system will attempt to verify that the
1132 * remote socket endpoint is still present if a sufficiently long period of
1133 * time passes with no data being exchanged. If the system is unable to
1134 * verify the presence of the remote endpoint, it will automatically close
1137 * This option is only functional on certain kinds of sockets. (Notably,
1138 * %G_SOCKET_PROTOCOL_TCP sockets.)
1140 * The exact time between pings is system- and protocol-dependent, but will
1141 * normally be at least two hours. Most commonly, you would set this flag
1142 * on a server socket if you want to allow clients to remain idle for long
1143 * periods of time, but also want to ensure that connections are eventually
1144 * garbage-collected if clients crash or become unreachable.
1149 g_socket_set_keepalive (GSocket
*socket
,
1152 GError
*error
= NULL
;
1154 g_return_if_fail (G_IS_SOCKET (socket
));
1156 keepalive
= !!keepalive
;
1157 if (socket
->priv
->keepalive
== keepalive
)
1160 if (!g_socket_set_option (socket
, SOL_SOCKET
, SO_KEEPALIVE
,
1163 g_warning ("error setting keepalive: %s", error
->message
);
1164 g_error_free (error
);
1168 socket
->priv
->keepalive
= keepalive
;
1169 g_object_notify (G_OBJECT (socket
), "keepalive");
1173 * g_socket_get_keepalive:
1174 * @socket: a #GSocket.
1176 * Gets the keepalive mode of the socket. For details on this,
1177 * see g_socket_set_keepalive().
1179 * Returns: %TRUE if keepalive is active, %FALSE otherwise.
1184 g_socket_get_keepalive (GSocket
*socket
)
1186 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
1188 return socket
->priv
->keepalive
;
1192 * g_socket_get_listen_backlog:
1193 * @socket: a #GSocket.
1195 * Gets the listen backlog setting of the socket. For details on this,
1196 * see g_socket_set_listen_backlog().
1198 * Returns: the maximum number of pending connections.
1203 g_socket_get_listen_backlog (GSocket
*socket
)
1205 g_return_val_if_fail (G_IS_SOCKET (socket
), 0);
1207 return socket
->priv
->listen_backlog
;
1211 * g_socket_set_listen_backlog:
1212 * @socket: a #GSocket.
1213 * @backlog: the maximum number of pending connections.
1215 * Sets the maximum number of outstanding connections allowed
1216 * when listening on this socket. If more clients than this are
1217 * connecting to the socket and the application is not handling them
1218 * on time then the new connections will be refused.
1220 * Note that this must be called before g_socket_listen() and has no
1221 * effect if called after that.
1226 g_socket_set_listen_backlog (GSocket
*socket
,
1229 g_return_if_fail (G_IS_SOCKET (socket
));
1230 g_return_if_fail (!socket
->priv
->listening
);
1232 if (backlog
!= socket
->priv
->listen_backlog
)
1234 socket
->priv
->listen_backlog
= backlog
;
1235 g_object_notify (G_OBJECT (socket
), "listen-backlog");
1240 * g_socket_get_timeout:
1241 * @socket: a #GSocket.
1243 * Gets the timeout setting of the socket. For details on this, see
1244 * g_socket_set_timeout().
1246 * Returns: the timeout in seconds
1251 g_socket_get_timeout (GSocket
*socket
)
1253 g_return_val_if_fail (G_IS_SOCKET (socket
), 0);
1255 return socket
->priv
->timeout
;
1259 * g_socket_set_timeout:
1260 * @socket: a #GSocket.
1261 * @timeout: the timeout for @socket, in seconds, or 0 for none
1263 * Sets the time in seconds after which I/O operations on @socket will
1264 * time out if they have not yet completed.
1266 * On a blocking socket, this means that any blocking #GSocket
1267 * operation will time out after @timeout seconds of inactivity,
1268 * returning %G_IO_ERROR_TIMED_OUT.
1270 * On a non-blocking socket, calls to g_socket_condition_wait() will
1271 * also fail with %G_IO_ERROR_TIMED_OUT after the given time. Sources
1272 * created with g_socket_create_source() will trigger after
1273 * @timeout seconds of inactivity, with the requested condition
1274 * set, at which point calling g_socket_receive(), g_socket_send(),
1275 * g_socket_check_connect_result(), etc, will fail with
1276 * %G_IO_ERROR_TIMED_OUT.
1278 * If @timeout is 0 (the default), operations will never time out
1281 * Note that if an I/O operation is interrupted by a signal, this may
1282 * cause the timeout to be reset.
1287 g_socket_set_timeout (GSocket
*socket
,
1290 g_return_if_fail (G_IS_SOCKET (socket
));
1292 if (timeout
!= socket
->priv
->timeout
)
1294 socket
->priv
->timeout
= timeout
;
1295 g_object_notify (G_OBJECT (socket
), "timeout");
1301 * @socket: a #GSocket.
1303 * Gets the unicast time-to-live setting on @socket; see
1304 * g_socket_set_ttl() for more details.
1306 * Returns: the time-to-live setting on @socket
1311 g_socket_get_ttl (GSocket
*socket
)
1313 GError
*error
= NULL
;
1316 g_return_val_if_fail (G_IS_SOCKET (socket
), 0);
1318 if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV4
)
1320 g_socket_get_option (socket
, IPPROTO_IP
, IP_TTL
,
1323 else if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV6
)
1325 g_socket_get_option (socket
, IPPROTO_IPV6
, IPV6_UNICAST_HOPS
,
1329 g_return_val_if_reached (0);
1333 g_warning ("error getting unicast ttl: %s", error
->message
);
1334 g_error_free (error
);
1343 * @socket: a #GSocket.
1344 * @ttl: the time-to-live value for all unicast packets on @socket
1346 * Sets the time-to-live for outgoing unicast packets on @socket.
1347 * By default the platform-specific default value is used.
1352 g_socket_set_ttl (GSocket
*socket
,
1355 GError
*error
= NULL
;
1357 g_return_if_fail (G_IS_SOCKET (socket
));
1359 if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV4
)
1361 g_socket_set_option (socket
, IPPROTO_IP
, IP_TTL
,
1364 else if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV6
)
1366 g_socket_set_option (socket
, IPPROTO_IP
, IP_TTL
,
1368 g_socket_set_option (socket
, IPPROTO_IPV6
, IPV6_UNICAST_HOPS
,
1372 g_return_if_reached ();
1376 g_warning ("error setting unicast ttl: %s", error
->message
);
1377 g_error_free (error
);
1381 g_object_notify (G_OBJECT (socket
), "ttl");
1385 * g_socket_get_broadcast:
1386 * @socket: a #GSocket.
1388 * Gets the broadcast setting on @socket; if %TRUE,
1389 * it is possible to send packets to broadcast
1392 * Returns: the broadcast setting on @socket
1397 g_socket_get_broadcast (GSocket
*socket
)
1399 GError
*error
= NULL
;
1402 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
1404 if (!g_socket_get_option (socket
, SOL_SOCKET
, SO_BROADCAST
,
1407 g_warning ("error getting broadcast: %s", error
->message
);
1408 g_error_free (error
);
1416 * g_socket_set_broadcast:
1417 * @socket: a #GSocket.
1418 * @broadcast: whether @socket should allow sending to broadcast
1421 * Sets whether @socket should allow sending to broadcast addresses.
1422 * This is %FALSE by default.
1427 g_socket_set_broadcast (GSocket
*socket
,
1430 GError
*error
= NULL
;
1432 g_return_if_fail (G_IS_SOCKET (socket
));
1434 broadcast
= !!broadcast
;
1436 if (!g_socket_set_option (socket
, SOL_SOCKET
, SO_BROADCAST
,
1439 g_warning ("error setting broadcast: %s", error
->message
);
1440 g_error_free (error
);
1444 g_object_notify (G_OBJECT (socket
), "broadcast");
1448 * g_socket_get_multicast_loopback:
1449 * @socket: a #GSocket.
1451 * Gets the multicast loopback setting on @socket; if %TRUE (the
1452 * default), outgoing multicast packets will be looped back to
1453 * multicast listeners on the same host.
1455 * Returns: the multicast loopback setting on @socket
1460 g_socket_get_multicast_loopback (GSocket
*socket
)
1462 GError
*error
= NULL
;
1465 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
1467 if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV4
)
1469 g_socket_get_option (socket
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
1472 else if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV6
)
1474 g_socket_get_option (socket
, IPPROTO_IPV6
, IPV6_MULTICAST_LOOP
,
1478 g_return_val_if_reached (FALSE
);
1482 g_warning ("error getting multicast loopback: %s", error
->message
);
1483 g_error_free (error
);
1491 * g_socket_set_multicast_loopback:
1492 * @socket: a #GSocket.
1493 * @loopback: whether @socket should receive messages sent to its
1494 * multicast groups from the local host
1496 * Sets whether outgoing multicast packets will be received by sockets
1497 * listening on that multicast address on the same host. This is %TRUE
1503 g_socket_set_multicast_loopback (GSocket
*socket
,
1506 GError
*error
= NULL
;
1508 g_return_if_fail (G_IS_SOCKET (socket
));
1510 loopback
= !!loopback
;
1512 if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV4
)
1514 g_socket_set_option (socket
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
1517 else if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV6
)
1519 g_socket_set_option (socket
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
1521 g_socket_set_option (socket
, IPPROTO_IPV6
, IPV6_MULTICAST_LOOP
,
1525 g_return_if_reached ();
1529 g_warning ("error setting multicast loopback: %s", error
->message
);
1530 g_error_free (error
);
1534 g_object_notify (G_OBJECT (socket
), "multicast-loopback");
1538 * g_socket_get_multicast_ttl:
1539 * @socket: a #GSocket.
1541 * Gets the multicast time-to-live setting on @socket; see
1542 * g_socket_set_multicast_ttl() for more details.
1544 * Returns: the multicast time-to-live setting on @socket
1549 g_socket_get_multicast_ttl (GSocket
*socket
)
1551 GError
*error
= NULL
;
1554 g_return_val_if_fail (G_IS_SOCKET (socket
), 0);
1556 if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV4
)
1558 g_socket_get_option (socket
, IPPROTO_IP
, IP_MULTICAST_TTL
,
1561 else if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV6
)
1563 g_socket_get_option (socket
, IPPROTO_IPV6
, IPV6_MULTICAST_HOPS
,
1567 g_return_val_if_reached (FALSE
);
1571 g_warning ("error getting multicast ttl: %s", error
->message
);
1572 g_error_free (error
);
1580 * g_socket_set_multicast_ttl:
1581 * @socket: a #GSocket.
1582 * @ttl: the time-to-live value for all multicast datagrams on @socket
1584 * Sets the time-to-live for outgoing multicast datagrams on @socket.
1585 * By default, this is 1, meaning that multicast packets will not leave
1586 * the local network.
1591 g_socket_set_multicast_ttl (GSocket
*socket
,
1594 GError
*error
= NULL
;
1596 g_return_if_fail (G_IS_SOCKET (socket
));
1598 if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV4
)
1600 g_socket_set_option (socket
, IPPROTO_IP
, IP_MULTICAST_TTL
,
1603 else if (socket
->priv
->family
== G_SOCKET_FAMILY_IPV6
)
1605 g_socket_set_option (socket
, IPPROTO_IP
, IP_MULTICAST_TTL
,
1607 g_socket_set_option (socket
, IPPROTO_IPV6
, IPV6_MULTICAST_HOPS
,
1611 g_return_if_reached ();
1615 g_warning ("error setting multicast ttl: %s", error
->message
);
1616 g_error_free (error
);
1620 g_object_notify (G_OBJECT (socket
), "multicast-ttl");
1624 * g_socket_get_family:
1625 * @socket: a #GSocket.
1627 * Gets the socket family of the socket.
1629 * Returns: a #GSocketFamily
1634 g_socket_get_family (GSocket
*socket
)
1636 g_return_val_if_fail (G_IS_SOCKET (socket
), G_SOCKET_FAMILY_INVALID
);
1638 return socket
->priv
->family
;
1642 * g_socket_get_socket_type:
1643 * @socket: a #GSocket.
1645 * Gets the socket type of the socket.
1647 * Returns: a #GSocketType
1652 g_socket_get_socket_type (GSocket
*socket
)
1654 g_return_val_if_fail (G_IS_SOCKET (socket
), G_SOCKET_TYPE_INVALID
);
1656 return socket
->priv
->type
;
1660 * g_socket_get_protocol:
1661 * @socket: a #GSocket.
1663 * Gets the socket protocol id the socket was created with.
1664 * In case the protocol is unknown, -1 is returned.
1666 * Returns: a protocol id, or -1 if unknown
1671 g_socket_get_protocol (GSocket
*socket
)
1673 g_return_val_if_fail (G_IS_SOCKET (socket
), -1);
1675 return socket
->priv
->protocol
;
1680 * @socket: a #GSocket.
1682 * Returns the underlying OS socket object. On unix this
1683 * is a socket file descriptor, and on Windows this is
1684 * a Winsock2 SOCKET handle. This may be useful for
1685 * doing platform specific or otherwise unusual operations
1688 * Returns: the file descriptor of the socket.
1693 g_socket_get_fd (GSocket
*socket
)
1695 g_return_val_if_fail (G_IS_SOCKET (socket
), -1);
1697 return socket
->priv
->fd
;
1701 * g_socket_get_local_address:
1702 * @socket: a #GSocket.
1703 * @error: #GError for error reporting, or %NULL to ignore.
1705 * Try to get the local address of a bound socket. This is only
1706 * useful if the socket has been bound to a local address,
1707 * either explicitly or implicitly when connecting.
1709 * Returns: (transfer full): a #GSocketAddress or %NULL on error.
1710 * Free the returned object with g_object_unref().
1715 g_socket_get_local_address (GSocket
*socket
,
1718 struct sockaddr_storage buffer
;
1719 guint len
= sizeof (buffer
);
1721 g_return_val_if_fail (G_IS_SOCKET (socket
), NULL
);
1723 if (getsockname (socket
->priv
->fd
, (struct sockaddr
*) &buffer
, &len
) < 0)
1725 int errsv
= get_socket_errno ();
1726 g_set_error (error
, G_IO_ERROR
, socket_io_error_from_errno (errsv
),
1727 _("could not get local address: %s"), socket_strerror (errsv
));
1731 return g_socket_address_new_from_native (&buffer
, len
);
1735 * g_socket_get_remote_address:
1736 * @socket: a #GSocket.
1737 * @error: #GError for error reporting, or %NULL to ignore.
1739 * Try to get the remove address of a connected socket. This is only
1740 * useful for connection oriented sockets that have been connected.
1742 * Returns: (transfer full): a #GSocketAddress or %NULL on error.
1743 * Free the returned object with g_object_unref().
1748 g_socket_get_remote_address (GSocket
*socket
,
1751 struct sockaddr_storage buffer
;
1752 guint len
= sizeof (buffer
);
1754 g_return_val_if_fail (G_IS_SOCKET (socket
), NULL
);
1756 if (socket
->priv
->connect_pending
)
1758 if (!g_socket_check_connect_result (socket
, error
))
1761 socket
->priv
->connect_pending
= FALSE
;
1764 if (!socket
->priv
->remote_address
)
1766 if (getpeername (socket
->priv
->fd
, (struct sockaddr
*) &buffer
, &len
) < 0)
1768 int errsv
= get_socket_errno ();
1769 g_set_error (error
, G_IO_ERROR
, socket_io_error_from_errno (errsv
),
1770 _("could not get remote address: %s"), socket_strerror (errsv
));
1774 socket
->priv
->remote_address
= g_socket_address_new_from_native (&buffer
, len
);
1777 return g_object_ref (socket
->priv
->remote_address
);
1781 * g_socket_is_connected:
1782 * @socket: a #GSocket.
1784 * Check whether the socket is connected. This is only useful for
1785 * connection-oriented sockets.
1787 * Returns: %TRUE if socket is connected, %FALSE otherwise.
1792 g_socket_is_connected (GSocket
*socket
)
1794 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
1796 return socket
->priv
->connected
;
1801 * @socket: a #GSocket.
1802 * @error: #GError for error reporting, or %NULL to ignore.
1804 * Marks the socket as a server socket, i.e. a socket that is used
1805 * to accept incoming requests using g_socket_accept().
1807 * Before calling this the socket must be bound to a local address using
1810 * To set the maximum amount of outstanding clients, use
1811 * g_socket_set_listen_backlog().
1813 * Returns: %TRUE on success, %FALSE on error.
1818 g_socket_listen (GSocket
*socket
,
1821 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
1823 if (!check_socket (socket
, error
))
1826 if (listen (socket
->priv
->fd
, socket
->priv
->listen_backlog
) < 0)
1828 int errsv
= get_socket_errno ();
1830 g_set_error (error
, G_IO_ERROR
, socket_io_error_from_errno (errsv
),
1831 _("could not listen: %s"), socket_strerror (errsv
));
1835 socket
->priv
->listening
= TRUE
;
1842 * @socket: a #GSocket.
1843 * @address: a #GSocketAddress specifying the local address.
1844 * @allow_reuse: whether to allow reusing this address
1845 * @error: #GError for error reporting, or %NULL to ignore.
1847 * When a socket is created it is attached to an address family, but it
1848 * doesn't have an address in this family. g_socket_bind() assigns the
1849 * address (sometimes called name) of the socket.
1851 * It is generally required to bind to a local address before you can
1852 * receive connections. (See g_socket_listen() and g_socket_accept() ).
1853 * In certain situations, you may also want to bind a socket that will be
1854 * used to initiate connections, though this is not normally required.
1856 * If @socket is a TCP socket, then @allow_reuse controls the setting
1857 * of the <literal>SO_REUSEADDR</literal> socket option; normally it
1858 * should be %TRUE for server sockets (sockets that you will
1859 * eventually call g_socket_accept() on), and %FALSE for client
1860 * sockets. (Failing to set this flag on a server socket may cause
1861 * g_socket_bind() to return %G_IO_ERROR_ADDRESS_IN_USE if the server
1862 * program is stopped and then immediately restarted.)
1864 * If @socket is a UDP socket, then @allow_reuse determines whether or
1865 * not other UDP sockets can be bound to the same address at the same
1866 * time. In particular, you can have several UDP sockets bound to the
1867 * same address, and they will all receive all of the multicast and
1868 * broadcast packets sent to that address. (The behavior of unicast
1869 * UDP packets to an address with multiple listeners is not defined.)
1871 * Returns: %TRUE on success, %FALSE on error.
1876 g_socket_bind (GSocket
*socket
,
1877 GSocketAddress
*address
,
1878 gboolean reuse_address
,
1881 struct sockaddr_storage addr
;
1882 gboolean so_reuseaddr
;
1884 gboolean so_reuseport
;
1887 g_return_val_if_fail (G_IS_SOCKET (socket
) && G_IS_SOCKET_ADDRESS (address
), FALSE
);
1889 if (!check_socket (socket
, error
))
1892 if (!g_socket_address_to_native (address
, &addr
, sizeof addr
, error
))
1895 /* On Windows, SO_REUSEADDR has the semantics we want for UDP
1896 * sockets, but has nasty side effects we don't want for TCP
1899 * On other platforms, we set SO_REUSEPORT, if it exists, for
1900 * UDP sockets, and SO_REUSEADDR for all sockets, hoping that
1901 * if SO_REUSEPORT doesn't exist, then SO_REUSEADDR will have
1902 * the desired semantics on UDP (as it does on Linux, although
1903 * Linux has SO_REUSEPORT too as of 3.9).
1907 so_reuseaddr
= reuse_address
&& (socket
->priv
->type
== G_SOCKET_TYPE_DATAGRAM
);
1909 so_reuseaddr
= !!reuse_address
;
1913 so_reuseport
= reuse_address
&& (socket
->priv
->type
== G_SOCKET_TYPE_DATAGRAM
);
1916 /* Ignore errors here, the only likely error is "not supported", and
1917 * this is a "best effort" thing mainly.
1919 g_socket_set_option (socket
, SOL_SOCKET
, SO_REUSEADDR
, so_reuseaddr
, NULL
);
1921 g_socket_set_option (socket
, SOL_SOCKET
, SO_REUSEPORT
, so_reuseport
, NULL
);
1924 if (bind (socket
->priv
->fd
, (struct sockaddr
*) &addr
,
1925 g_socket_address_get_native_size (address
)) < 0)
1927 int errsv
= get_socket_errno ();
1929 G_IO_ERROR
, socket_io_error_from_errno (errsv
),
1930 _("Error binding to address: %s"), socket_strerror (errsv
));
1937 #if !defined(HAVE_IF_NAMETOINDEX) && defined(G_OS_WIN32)
1939 if_nametoindex (const gchar
*iface
)
1941 PIP_ADAPTER_ADDRESSES addresses
= NULL
, p
;
1942 gulong addresses_len
= 0;
1946 res
= GetAdaptersAddresses (AF_UNSPEC
, 0, NULL
, NULL
, &addresses_len
);
1947 if (res
!= NO_ERROR
&& res
!= ERROR_BUFFER_OVERFLOW
)
1949 if (res
== ERROR_NO_DATA
)
1956 addresses
= g_malloc (addresses_len
);
1957 res
= GetAdaptersAddresses (AF_UNSPEC
, 0, NULL
, addresses
, &addresses_len
);
1959 if (res
!= NO_ERROR
)
1962 if (res
== ERROR_NO_DATA
)
1972 if (strcmp (p
->AdapterName
, iface
) == 0)
1988 #define HAVE_IF_NAMETOINDEX 1
1992 g_socket_multicast_group_operation (GSocket
*socket
,
1993 GInetAddress
*group
,
1994 gboolean source_specific
,
1996 gboolean join_group
,
1999 const guint8
*native_addr
;
2000 gint optname
, result
;
2002 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
2003 g_return_val_if_fail (socket
->priv
->type
== G_SOCKET_TYPE_DATAGRAM
, FALSE
);
2004 g_return_val_if_fail (G_IS_INET_ADDRESS (group
), FALSE
);
2006 if (!check_socket (socket
, error
))
2009 native_addr
= g_inet_address_to_bytes (group
);
2010 if (g_inet_address_get_family (group
) == G_SOCKET_FAMILY_IPV4
)
2012 #ifdef HAVE_IP_MREQN
2013 struct ip_mreqn mc_req
;
2015 struct ip_mreq mc_req
;
2018 memset (&mc_req
, 0, sizeof (mc_req
));
2019 memcpy (&mc_req
.imr_multiaddr
, native_addr
, sizeof (struct in_addr
));
2021 #ifdef HAVE_IP_MREQN
2023 mc_req
.imr_ifindex
= if_nametoindex (iface
);
2025 mc_req
.imr_ifindex
= 0; /* Pick any. */
2026 #elif defined(G_OS_WIN32)
2028 mc_req
.imr_interface
.s_addr
= g_htonl (if_nametoindex (iface
));
2030 mc_req
.imr_interface
.s_addr
= g_htonl (INADDR_ANY
);
2032 mc_req
.imr_interface
.s_addr
= g_htonl (INADDR_ANY
);
2035 if (source_specific
)
2037 #ifdef IP_ADD_SOURCE_MEMBERSHIP
2038 optname
= join_group
? IP_ADD_SOURCE_MEMBERSHIP
: IP_DROP_SOURCE_MEMBERSHIP
;
2040 g_set_error (error
, G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
2042 _("Error joining multicast group: %s") :
2043 _("Error leaving multicast group: %s"),
2044 _("No support for source-specific multicast"));
2049 optname
= join_group
? IP_ADD_MEMBERSHIP
: IP_DROP_MEMBERSHIP
;
2050 result
= setsockopt (socket
->priv
->fd
, IPPROTO_IP
, optname
,
2051 &mc_req
, sizeof (mc_req
));
2053 else if (g_inet_address_get_family (group
) == G_SOCKET_FAMILY_IPV6
)
2055 struct ipv6_mreq mc_req_ipv6
;
2057 memset (&mc_req_ipv6
, 0, sizeof (mc_req_ipv6
));
2058 memcpy (&mc_req_ipv6
.ipv6mr_multiaddr
, native_addr
, sizeof (struct in6_addr
));
2059 #ifdef HAVE_IF_NAMETOINDEX
2061 mc_req_ipv6
.ipv6mr_interface
= if_nametoindex (iface
);
2064 mc_req_ipv6
.ipv6mr_interface
= 0;
2066 optname
= join_group
? IPV6_JOIN_GROUP
: IPV6_LEAVE_GROUP
;
2067 result
= setsockopt (socket
->priv
->fd
, IPPROTO_IPV6
, optname
,
2068 &mc_req_ipv6
, sizeof (mc_req_ipv6
));
2071 g_return_val_if_reached (FALSE
);
2075 int errsv
= get_socket_errno ();
2077 g_set_error (error
, G_IO_ERROR
, socket_io_error_from_errno (errsv
),
2079 _("Error joining multicast group: %s") :
2080 _("Error leaving multicast group: %s"),
2081 socket_strerror (errsv
));
2089 * g_socket_join_multicast_group:
2090 * @socket: a #GSocket.
2091 * @group: a #GInetAddress specifying the group address to join.
2092 * @iface: (allow-none): Name of the interface to use, or %NULL
2093 * @source_specific: %TRUE if source-specific multicast should be used
2094 * @error: #GError for error reporting, or %NULL to ignore.
2096 * Registers @socket to receive multicast messages sent to @group.
2097 * @socket must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have
2098 * been bound to an appropriate interface and port with
2101 * If @iface is %NULL, the system will automatically pick an interface
2102 * to bind to based on @group.
2104 * If @source_specific is %TRUE, source-specific multicast as defined
2105 * in RFC 4604 is used. Note that on older platforms this may fail
2106 * with a %G_IO_ERROR_NOT_SUPPORTED error.
2108 * Returns: %TRUE on success, %FALSE on error.
2113 g_socket_join_multicast_group (GSocket
*socket
,
2114 GInetAddress
*group
,
2115 gboolean source_specific
,
2119 return g_socket_multicast_group_operation (socket
, group
, source_specific
, iface
, TRUE
, error
);
2123 * g_socket_leave_multicast_group:
2124 * @socket: a #GSocket.
2125 * @group: a #GInetAddress specifying the group address to leave.
2126 * @iface: (allow-none): Interface used
2127 * @source_specific: %TRUE if source-specific multicast was used
2128 * @error: #GError for error reporting, or %NULL to ignore.
2130 * Removes @socket from the multicast group defined by @group, @iface,
2131 * and @source_specific (which must all have the same values they had
2132 * when you joined the group).
2134 * @socket remains bound to its address and port, and can still receive
2135 * unicast messages after calling this.
2137 * Returns: %TRUE on success, %FALSE on error.
2142 g_socket_leave_multicast_group (GSocket
*socket
,
2143 GInetAddress
*group
,
2144 gboolean source_specific
,
2148 return g_socket_multicast_group_operation (socket
, group
, source_specific
, iface
, FALSE
, error
);
2152 * g_socket_speaks_ipv4:
2153 * @socket: a #GSocket
2155 * Checks if a socket is capable of speaking IPv4.
2157 * IPv4 sockets are capable of speaking IPv4. On some operating systems
2158 * and under some combinations of circumstances IPv6 sockets are also
2159 * capable of speaking IPv4. See RFC 3493 section 3.7 for more
2162 * No other types of sockets are currently considered as being capable
2165 * Returns: %TRUE if this socket can be used with IPv4.
2170 g_socket_speaks_ipv4 (GSocket
*socket
)
2172 switch (socket
->priv
->family
)
2174 case G_SOCKET_FAMILY_IPV4
:
2177 case G_SOCKET_FAMILY_IPV6
:
2178 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
2182 if (!g_socket_get_option (socket
,
2183 IPPROTO_IPV6
, IPV6_V6ONLY
,
2200 * @socket: a #GSocket.
2201 * @cancellable: (allow-none): a %GCancellable or %NULL
2202 * @error: #GError for error reporting, or %NULL to ignore.
2204 * Accept incoming connections on a connection-based socket. This removes
2205 * the first outstanding connection request from the listening socket and
2206 * creates a #GSocket object for it.
2208 * The @socket must be bound to a local address with g_socket_bind() and
2209 * must be listening for incoming connections (g_socket_listen()).
2211 * If there are no outstanding connections then the operation will block
2212 * or return %G_IO_ERROR_WOULD_BLOCK if non-blocking I/O is enabled.
2213 * To be notified of an incoming connection, wait for the %G_IO_IN condition.
2215 * Returns: (transfer full): a new #GSocket, or %NULL on error.
2216 * Free the returned object with g_object_unref().
2221 g_socket_accept (GSocket
*socket
,
2222 GCancellable
*cancellable
,
2225 GSocket
*new_socket
;
2228 g_return_val_if_fail (G_IS_SOCKET (socket
), NULL
);
2230 if (!check_socket (socket
, error
))
2235 if (socket
->priv
->blocking
&&
2236 !g_socket_condition_wait (socket
,
2237 G_IO_IN
, cancellable
, error
))
2240 if ((ret
= accept (socket
->priv
->fd
, NULL
, 0)) < 0)
2242 int errsv
= get_socket_errno ();
2244 win32_unset_event_mask (socket
, FD_ACCEPT
);
2249 if (socket
->priv
->blocking
)
2251 #ifdef WSAEWOULDBLOCK
2252 if (errsv
== WSAEWOULDBLOCK
)
2255 if (errsv
== EWOULDBLOCK
||
2261 g_set_error (error
, G_IO_ERROR
,
2262 socket_io_error_from_errno (errsv
),
2263 _("Error accepting connection: %s"), socket_strerror (errsv
));
2269 win32_unset_event_mask (socket
, FD_ACCEPT
);
2273 /* The socket inherits the accepting sockets event mask and even object,
2274 we need to remove that */
2275 WSAEventSelect (ret
, NULL
, 0);
2281 /* We always want to set close-on-exec to protect users. If you
2282 need to so some weird inheritance to exec you can re-enable this
2283 using lower level hacks with g_socket_get_fd(). */
2284 flags
= fcntl (ret
, F_GETFD
, 0);
2286 (flags
& FD_CLOEXEC
) == 0)
2288 flags
|= FD_CLOEXEC
;
2289 fcntl (ret
, F_SETFD
, flags
);
2294 new_socket
= g_socket_new_from_fd (ret
, error
);
2295 if (new_socket
== NULL
)
2304 new_socket
->priv
->protocol
= socket
->priv
->protocol
;
2311 * @socket: a #GSocket.
2312 * @address: a #GSocketAddress specifying the remote address.
2313 * @cancellable: (allow-none): a %GCancellable or %NULL
2314 * @error: #GError for error reporting, or %NULL to ignore.
2316 * Connect the socket to the specified remote address.
2318 * For connection oriented socket this generally means we attempt to make
2319 * a connection to the @address. For a connection-less socket it sets
2320 * the default address for g_socket_send() and discards all incoming datagrams
2321 * from other sources.
2323 * Generally connection oriented sockets can only connect once, but
2324 * connection-less sockets can connect multiple times to change the
2327 * If the connect call needs to do network I/O it will block, unless
2328 * non-blocking I/O is enabled. Then %G_IO_ERROR_PENDING is returned
2329 * and the user can be notified of the connection finishing by waiting
2330 * for the G_IO_OUT condition. The result of the connection must then be
2331 * checked with g_socket_check_connect_result().
2333 * Returns: %TRUE if connected, %FALSE on error.
2338 g_socket_connect (GSocket
*socket
,
2339 GSocketAddress
*address
,
2340 GCancellable
*cancellable
,
2343 struct sockaddr_storage buffer
;
2345 g_return_val_if_fail (G_IS_SOCKET (socket
) && G_IS_SOCKET_ADDRESS (address
), FALSE
);
2347 if (!check_socket (socket
, error
))
2350 if (!g_socket_address_to_native (address
, &buffer
, sizeof buffer
, error
))
2353 if (socket
->priv
->remote_address
)
2354 g_object_unref (socket
->priv
->remote_address
);
2355 socket
->priv
->remote_address
= g_object_ref (address
);
2359 if (connect (socket
->priv
->fd
, (struct sockaddr
*) &buffer
,
2360 g_socket_address_get_native_size (address
)) < 0)
2362 int errsv
= get_socket_errno ();
2368 if (errsv
== EINPROGRESS
)
2370 if (errsv
== WSAEWOULDBLOCK
)
2373 if (socket
->priv
->blocking
)
2375 if (g_socket_condition_wait (socket
, G_IO_OUT
, cancellable
, error
))
2377 if (g_socket_check_connect_result (socket
, error
))
2383 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_PENDING
,
2384 _("Connection in progress"));
2385 socket
->priv
->connect_pending
= TRUE
;
2389 g_set_error_literal (error
, G_IO_ERROR
,
2390 socket_io_error_from_errno (errsv
),
2391 socket_strerror (errsv
));
2398 win32_unset_event_mask (socket
, FD_CONNECT
);
2400 socket
->priv
->connected
= TRUE
;
2406 * g_socket_check_connect_result:
2407 * @socket: a #GSocket
2408 * @error: #GError for error reporting, or %NULL to ignore.
2410 * Checks and resets the pending connect error for the socket.
2411 * This is used to check for errors when g_socket_connect() is
2412 * used in non-blocking mode.
2414 * Returns: %TRUE if no error, %FALSE otherwise, setting @error to the error
2419 g_socket_check_connect_result (GSocket
*socket
,
2424 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
2426 if (!check_socket (socket
, error
))
2429 if (!g_socket_get_option (socket
, SOL_SOCKET
, SO_ERROR
, &value
, error
))
2431 g_prefix_error (error
, _("Unable to get pending error: "));
2437 g_set_error_literal (error
, G_IO_ERROR
, socket_io_error_from_errno (value
),
2438 socket_strerror (value
));
2439 if (socket
->priv
->remote_address
)
2441 g_object_unref (socket
->priv
->remote_address
);
2442 socket
->priv
->remote_address
= NULL
;
2447 socket
->priv
->connected
= TRUE
;
2452 * g_socket_get_available_bytes:
2453 * @socket: a #GSocket
2455 * Get the amount of data pending in the OS input buffer.
2457 * Returns: the number of bytes that can be read from the socket
2458 * without blocking or -1 on error.
2463 g_socket_get_available_bytes (GSocket
*socket
)
2467 g_return_val_if_fail (G_IS_SOCKET (socket
), -1);
2470 if (ioctl (socket
->priv
->fd
, FIONREAD
, &avail
) < 0)
2473 if (ioctlsocket (socket
->priv
->fd
, FIONREAD
, &avail
) == SOCKET_ERROR
)
2482 * @socket: a #GSocket
2483 * @buffer: (array length=size) (element-type guint8): a buffer to
2484 * read data into (which should be at least @size bytes long).
2485 * @size: the number of bytes you want to read from the socket
2486 * @cancellable: (allow-none): a %GCancellable or %NULL
2487 * @error: #GError for error reporting, or %NULL to ignore.
2489 * Receive data (up to @size bytes) from a socket. This is mainly used by
2490 * connection-oriented sockets; it is identical to g_socket_receive_from()
2491 * with @address set to %NULL.
2493 * For %G_SOCKET_TYPE_DATAGRAM and %G_SOCKET_TYPE_SEQPACKET sockets,
2494 * g_socket_receive() will always read either 0 or 1 complete messages from
2495 * the socket. If the received message is too large to fit in @buffer, then
2496 * the data beyond @size bytes will be discarded, without any explicit
2497 * indication that this has occurred.
2499 * For %G_SOCKET_TYPE_STREAM sockets, g_socket_receive() can return any
2500 * number of bytes, up to @size. If more than @size bytes have been
2501 * received, the additional data will be returned in future calls to
2502 * g_socket_receive().
2504 * If the socket is in blocking mode the call will block until there
2505 * is some data to receive, the connection is closed, or there is an
2506 * error. If there is no data available and the socket is in
2507 * non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
2508 * returned. To be notified when data is available, wait for the
2509 * %G_IO_IN condition.
2511 * On error -1 is returned and @error is set accordingly.
2513 * Returns: Number of bytes read, or 0 if the connection was closed by
2514 * the peer, or -1 on error
2519 g_socket_receive (GSocket
*socket
,
2522 GCancellable
*cancellable
,
2525 return g_socket_receive_with_blocking (socket
, buffer
, size
,
2526 socket
->priv
->blocking
,
2527 cancellable
, error
);
2531 * g_socket_receive_with_blocking:
2532 * @socket: a #GSocket
2533 * @buffer: (array length=size) (element-type guint8): a buffer to
2534 * read data into (which should be at least @size bytes long).
2535 * @size: the number of bytes you want to read from the socket
2536 * @blocking: whether to do blocking or non-blocking I/O
2537 * @cancellable: (allow-none): a %GCancellable or %NULL
2538 * @error: #GError for error reporting, or %NULL to ignore.
2540 * This behaves exactly the same as g_socket_receive(), except that
2541 * the choice of blocking or non-blocking behavior is determined by
2542 * the @blocking argument rather than by @socket's properties.
2544 * Returns: Number of bytes read, or 0 if the connection was closed by
2545 * the peer, or -1 on error
2550 g_socket_receive_with_blocking (GSocket
*socket
,
2554 GCancellable
*cancellable
,
2559 g_return_val_if_fail (G_IS_SOCKET (socket
) && buffer
!= NULL
, -1);
2561 if (!check_socket (socket
, error
))
2564 if (g_cancellable_set_error_if_cancelled (cancellable
, error
))
2570 !g_socket_condition_wait (socket
,
2571 G_IO_IN
, cancellable
, error
))
2574 if ((ret
= recv (socket
->priv
->fd
, buffer
, size
, 0)) < 0)
2576 int errsv
= get_socket_errno ();
2583 #ifdef WSAEWOULDBLOCK
2584 if (errsv
== WSAEWOULDBLOCK
)
2587 if (errsv
== EWOULDBLOCK
||
2593 win32_unset_event_mask (socket
, FD_READ
);
2595 g_set_error (error
, G_IO_ERROR
,
2596 socket_io_error_from_errno (errsv
),
2597 _("Error receiving data: %s"), socket_strerror (errsv
));
2601 win32_unset_event_mask (socket
, FD_READ
);
2610 * g_socket_receive_from:
2611 * @socket: a #GSocket
2612 * @address: (out) (allow-none): a pointer to a #GSocketAddress
2614 * @buffer: (array length=size) (element-type guint8): a buffer to
2615 * read data into (which should be at least @size bytes long).
2616 * @size: the number of bytes you want to read from the socket
2617 * @cancellable: (allow-none): a %GCancellable or %NULL
2618 * @error: #GError for error reporting, or %NULL to ignore.
2620 * Receive data (up to @size bytes) from a socket.
2622 * If @address is non-%NULL then @address will be set equal to the
2623 * source address of the received packet.
2624 * @address is owned by the caller.
2626 * See g_socket_receive() for additional information.
2628 * Returns: Number of bytes read, or 0 if the connection was closed by
2629 * the peer, or -1 on error
2634 g_socket_receive_from (GSocket
*socket
,
2635 GSocketAddress
**address
,
2638 GCancellable
*cancellable
,
2646 return g_socket_receive_message (socket
,
2654 /* Although we ignore SIGPIPE, gdb will still stop if the app receives
2655 * one, which can be confusing and annoying. So if possible, we want
2656 * to suppress the signal entirely.
2659 #define G_SOCKET_DEFAULT_SEND_FLAGS MSG_NOSIGNAL
2661 #define G_SOCKET_DEFAULT_SEND_FLAGS 0
2666 * @socket: a #GSocket
2667 * @buffer: (array length=size) (element-type guint8): the buffer
2668 * containing the data to send.
2669 * @size: the number of bytes to send
2670 * @cancellable: (allow-none): a %GCancellable or %NULL
2671 * @error: #GError for error reporting, or %NULL to ignore.
2673 * Tries to send @size bytes from @buffer on the socket. This is
2674 * mainly used by connection-oriented sockets; it is identical to
2675 * g_socket_send_to() with @address set to %NULL.
2677 * If the socket is in blocking mode the call will block until there is
2678 * space for the data in the socket queue. If there is no space available
2679 * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
2680 * will be returned. To be notified when space is available, wait for the
2681 * %G_IO_OUT condition. Note though that you may still receive
2682 * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
2683 * notified of a %G_IO_OUT condition. (On Windows in particular, this is
2684 * very common due to the way the underlying APIs work.)
2686 * On error -1 is returned and @error is set accordingly.
2688 * Returns: Number of bytes written (which may be less than @size), or -1
2694 g_socket_send (GSocket
*socket
,
2695 const gchar
*buffer
,
2697 GCancellable
*cancellable
,
2700 return g_socket_send_with_blocking (socket
, buffer
, size
,
2701 socket
->priv
->blocking
,
2702 cancellable
, error
);
2706 * g_socket_send_with_blocking:
2707 * @socket: a #GSocket
2708 * @buffer: (array length=size) (element-type guint8): the buffer
2709 * containing the data to send.
2710 * @size: the number of bytes to send
2711 * @blocking: whether to do blocking or non-blocking I/O
2712 * @cancellable: (allow-none): a %GCancellable or %NULL
2713 * @error: #GError for error reporting, or %NULL to ignore.
2715 * This behaves exactly the same as g_socket_send(), except that
2716 * the choice of blocking or non-blocking behavior is determined by
2717 * the @blocking argument rather than by @socket's properties.
2719 * Returns: Number of bytes written (which may be less than @size), or -1
2725 g_socket_send_with_blocking (GSocket
*socket
,
2726 const gchar
*buffer
,
2729 GCancellable
*cancellable
,
2734 g_return_val_if_fail (G_IS_SOCKET (socket
) && buffer
!= NULL
, -1);
2736 if (!check_socket (socket
, error
))
2739 if (g_cancellable_set_error_if_cancelled (cancellable
, error
))
2745 !g_socket_condition_wait (socket
,
2746 G_IO_OUT
, cancellable
, error
))
2749 if ((ret
= send (socket
->priv
->fd
, buffer
, size
, G_SOCKET_DEFAULT_SEND_FLAGS
)) < 0)
2751 int errsv
= get_socket_errno ();
2756 #ifdef WSAEWOULDBLOCK
2757 if (errsv
== WSAEWOULDBLOCK
)
2758 win32_unset_event_mask (socket
, FD_WRITE
);
2763 #ifdef WSAEWOULDBLOCK
2764 if (errsv
== WSAEWOULDBLOCK
)
2767 if (errsv
== EWOULDBLOCK
||
2773 g_set_error (error
, G_IO_ERROR
,
2774 socket_io_error_from_errno (errsv
),
2775 _("Error sending data: %s"), socket_strerror (errsv
));
2786 * @socket: a #GSocket
2787 * @address: (allow-none): a #GSocketAddress, or %NULL
2788 * @buffer: (array length=size) (element-type guint8): the buffer
2789 * containing the data to send.
2790 * @size: the number of bytes to send
2791 * @cancellable: (allow-none): a %GCancellable or %NULL
2792 * @error: #GError for error reporting, or %NULL to ignore.
2794 * Tries to send @size bytes from @buffer to @address. If @address is
2795 * %NULL then the message is sent to the default receiver (set by
2796 * g_socket_connect()).
2798 * See g_socket_send() for additional information.
2800 * Returns: Number of bytes written (which may be less than @size), or -1
2806 g_socket_send_to (GSocket
*socket
,
2807 GSocketAddress
*address
,
2808 const gchar
*buffer
,
2810 GCancellable
*cancellable
,
2818 return g_socket_send_message (socket
,
2828 * g_socket_shutdown:
2829 * @socket: a #GSocket
2830 * @shutdown_read: whether to shut down the read side
2831 * @shutdown_write: whether to shut down the write side
2832 * @error: #GError for error reporting, or %NULL to ignore.
2834 * Shut down part of a full-duplex connection.
2836 * If @shutdown_read is %TRUE then the receiving side of the connection
2837 * is shut down, and further reading is disallowed.
2839 * If @shutdown_write is %TRUE then the sending side of the connection
2840 * is shut down, and further writing is disallowed.
2842 * It is allowed for both @shutdown_read and @shutdown_write to be %TRUE.
2844 * One example where this is used is graceful disconnect for TCP connections
2845 * where you close the sending side, then wait for the other side to close
2846 * the connection, thus ensuring that the other side saw all sent data.
2848 * Returns: %TRUE on success, %FALSE on error
2853 g_socket_shutdown (GSocket
*socket
,
2854 gboolean shutdown_read
,
2855 gboolean shutdown_write
,
2860 g_return_val_if_fail (G_IS_SOCKET (socket
), TRUE
);
2862 if (!check_socket (socket
, error
))
2866 if (!shutdown_read
&& !shutdown_write
)
2870 if (shutdown_read
&& shutdown_write
)
2872 else if (shutdown_read
)
2877 if (shutdown_read
&& shutdown_write
)
2879 else if (shutdown_read
)
2885 if (shutdown (socket
->priv
->fd
, how
) != 0)
2887 int errsv
= get_socket_errno ();
2888 g_set_error (error
, G_IO_ERROR
, socket_io_error_from_errno (errsv
),
2889 _("Unable to shutdown socket: %s"), socket_strerror (errsv
));
2893 if (shutdown_read
&& shutdown_write
)
2894 socket
->priv
->connected
= FALSE
;
2901 * @socket: a #GSocket
2902 * @error: #GError for error reporting, or %NULL to ignore.
2904 * Closes the socket, shutting down any active connection.
2906 * Closing a socket does not wait for all outstanding I/O operations
2907 * to finish, so the caller should not rely on them to be guaranteed
2908 * to complete even if the close returns with no error.
2910 * Once the socket is closed, all other operations will return
2911 * %G_IO_ERROR_CLOSED. Closing a socket multiple times will not
2914 * Sockets will be automatically closed when the last reference
2915 * is dropped, but you might want to call this function to make sure
2916 * resources are released as early as possible.
2918 * Beware that due to the way that TCP works, it is possible for
2919 * recently-sent data to be lost if either you close a socket while the
2920 * %G_IO_IN condition is set, or else if the remote connection tries to
2921 * send something to you after you close the socket but before it has
2922 * finished reading all of the data you sent. There is no easy generic
2923 * way to avoid this problem; the easiest fix is to design the network
2924 * protocol such that the client will never send data "out of turn".
2925 * Another solution is for the server to half-close the connection by
2926 * calling g_socket_shutdown() with only the @shutdown_write flag set,
2927 * and then wait for the client to notice this and close its side of the
2928 * connection, after which the server can safely call g_socket_close().
2929 * (This is what #GTcpConnection does if you call
2930 * g_tcp_connection_set_graceful_disconnect(). But of course, this
2931 * only works if the client will close its connection after the server
2934 * Returns: %TRUE on success, %FALSE on error
2939 g_socket_close (GSocket
*socket
,
2944 g_return_val_if_fail (G_IS_SOCKET (socket
), TRUE
);
2946 if (socket
->priv
->closed
)
2947 return TRUE
; /* Multiple close not an error */
2949 if (!check_socket (socket
, error
))
2955 res
= closesocket (socket
->priv
->fd
);
2957 res
= close (socket
->priv
->fd
);
2961 int errsv
= get_socket_errno ();
2966 g_set_error (error
, G_IO_ERROR
,
2967 socket_io_error_from_errno (errsv
),
2968 _("Error closing socket: %s"),
2969 socket_strerror (errsv
));
2975 socket
->priv
->connected
= FALSE
;
2976 socket
->priv
->closed
= TRUE
;
2977 if (socket
->priv
->remote_address
)
2979 g_object_unref (socket
->priv
->remote_address
);
2980 socket
->priv
->remote_address
= NULL
;
2987 * g_socket_is_closed:
2988 * @socket: a #GSocket
2990 * Checks whether a socket is closed.
2992 * Returns: %TRUE if socket is closed, %FALSE otherwise
2997 g_socket_is_closed (GSocket
*socket
)
2999 return socket
->priv
->closed
;
3003 /* Broken source, used on errors */
3005 broken_dispatch (GSource
*source
,
3006 GSourceFunc callback
,
3012 static GSourceFuncs broken_funcs
=
3021 network_events_for_condition (GIOCondition condition
)
3025 if (condition
& G_IO_IN
)
3026 event_mask
|= (FD_READ
| FD_ACCEPT
);
3027 if (condition
& G_IO_OUT
)
3028 event_mask
|= (FD_WRITE
| FD_CONNECT
);
3029 event_mask
|= FD_CLOSE
;
3035 ensure_event (GSocket
*socket
)
3037 if (socket
->priv
->event
== WSA_INVALID_EVENT
)
3038 socket
->priv
->event
= WSACreateEvent();
3042 update_select_events (GSocket
*socket
)
3049 ensure_event (socket
);
3052 for (l
= socket
->priv
->requested_conditions
; l
!= NULL
; l
= l
->next
)
3055 event_mask
|= network_events_for_condition (*ptr
);
3058 if (event_mask
!= socket
->priv
->selected_events
)
3060 /* If no events selected, disable event so we can unset
3063 if (event_mask
== 0)
3066 event
= socket
->priv
->event
;
3068 if (WSAEventSelect (socket
->priv
->fd
, event
, event_mask
) == 0)
3069 socket
->priv
->selected_events
= event_mask
;
3074 add_condition_watch (GSocket
*socket
,
3075 GIOCondition
*condition
)
3077 g_assert (g_list_find (socket
->priv
->requested_conditions
, condition
) == NULL
);
3079 socket
->priv
->requested_conditions
=
3080 g_list_prepend (socket
->priv
->requested_conditions
, condition
);
3082 update_select_events (socket
);
3086 remove_condition_watch (GSocket
*socket
,
3087 GIOCondition
*condition
)
3089 g_assert (g_list_find (socket
->priv
->requested_conditions
, condition
) != NULL
);
3091 socket
->priv
->requested_conditions
=
3092 g_list_remove (socket
->priv
->requested_conditions
, condition
);
3094 update_select_events (socket
);
3098 update_condition (GSocket
*socket
)
3100 WSANETWORKEVENTS events
;
3101 GIOCondition condition
;
3103 if (WSAEnumNetworkEvents (socket
->priv
->fd
,
3104 socket
->priv
->event
,
3107 socket
->priv
->current_events
|= events
.lNetworkEvents
;
3108 if (events
.lNetworkEvents
& FD_WRITE
&&
3109 events
.iErrorCode
[FD_WRITE_BIT
] != 0)
3110 socket
->priv
->current_errors
|= FD_WRITE
;
3111 if (events
.lNetworkEvents
& FD_CONNECT
&&
3112 events
.iErrorCode
[FD_CONNECT_BIT
] != 0)
3113 socket
->priv
->current_errors
|= FD_CONNECT
;
3117 if (socket
->priv
->current_events
& (FD_READ
| FD_ACCEPT
))
3118 condition
|= G_IO_IN
;
3120 if (socket
->priv
->current_events
& FD_CLOSE
)
3122 int r
, errsv
, buffer
;
3124 r
= recv (socket
->priv
->fd
, &buffer
, sizeof (buffer
), MSG_PEEK
);
3126 errsv
= get_socket_errno ();
3129 (r
< 0 && errsv
== WSAENOTCONN
))
3130 condition
|= G_IO_IN
;
3132 (r
< 0 && (errsv
== WSAESHUTDOWN
|| errsv
== WSAECONNRESET
||
3133 errsv
== WSAECONNABORTED
|| errsv
== WSAENETRESET
)))
3134 condition
|= G_IO_HUP
;
3136 condition
|= G_IO_ERR
;
3139 if (socket
->priv
->closed
)
3140 condition
|= G_IO_HUP
;
3142 /* Never report both G_IO_OUT and HUP, these are
3143 mutually exclusive (can't write to a closed socket) */
3144 if ((condition
& G_IO_HUP
) == 0 &&
3145 socket
->priv
->current_events
& FD_WRITE
)
3147 if (socket
->priv
->current_errors
& FD_WRITE
)
3148 condition
|= G_IO_ERR
;
3150 condition
|= G_IO_OUT
;
3154 if (socket
->priv
->current_events
& FD_CONNECT
)
3156 if (socket
->priv
->current_errors
& FD_CONNECT
)
3157 condition
|= (G_IO_HUP
| G_IO_ERR
);
3159 condition
|= G_IO_OUT
;
3171 GIOCondition condition
;
3172 GCancellable
*cancellable
;
3173 GPollFD cancel_pollfd
;
3174 gint64 timeout_time
;
3178 socket_source_prepare (GSource
*source
,
3181 GSocketSource
*socket_source
= (GSocketSource
*)source
;
3183 if (g_cancellable_is_cancelled (socket_source
->cancellable
))
3186 if (socket_source
->timeout_time
)
3190 now
= g_source_get_time (source
);
3191 /* Round up to ensure that we don't try again too early */
3192 *timeout
= (socket_source
->timeout_time
- now
+ 999) / 1000;
3195 socket_source
->socket
->priv
->timed_out
= TRUE
;
3204 socket_source
->pollfd
.revents
= update_condition (socket_source
->socket
);
3207 if ((socket_source
->condition
& socket_source
->pollfd
.revents
) != 0)
3214 socket_source_check (GSource
*source
)
3218 return socket_source_prepare (source
, &timeout
);
3222 socket_source_dispatch (GSource
*source
,
3223 GSourceFunc callback
,
3226 GSocketSourceFunc func
= (GSocketSourceFunc
)callback
;
3227 GSocketSource
*socket_source
= (GSocketSource
*)source
;
3228 GSocket
*socket
= socket_source
->socket
;
3232 socket_source
->pollfd
.revents
= update_condition (socket_source
->socket
);
3234 if (socket_source
->socket
->priv
->timed_out
)
3235 socket_source
->pollfd
.revents
|= socket_source
->condition
& (G_IO_IN
| G_IO_OUT
);
3237 ret
= (*func
) (socket
,
3238 socket_source
->pollfd
.revents
& socket_source
->condition
,
3241 if (socket
->priv
->timeout
)
3242 socket_source
->timeout_time
= g_get_monotonic_time () +
3243 socket
->priv
->timeout
* 1000000;
3246 socket_source
->timeout_time
= 0;
3252 socket_source_finalize (GSource
*source
)
3254 GSocketSource
*socket_source
= (GSocketSource
*)source
;
3257 socket
= socket_source
->socket
;
3260 remove_condition_watch (socket
, &socket_source
->condition
);
3263 g_object_unref (socket
);
3265 if (socket_source
->cancellable
)
3267 g_cancellable_release_fd (socket_source
->cancellable
);
3268 g_object_unref (socket_source
->cancellable
);
3273 socket_source_closure_callback (GSocket
*socket
,
3274 GIOCondition condition
,
3277 GClosure
*closure
= data
;
3279 GValue params
[2] = { G_VALUE_INIT
, G_VALUE_INIT
};
3280 GValue result_value
= G_VALUE_INIT
;
3283 g_value_init (&result_value
, G_TYPE_BOOLEAN
);
3285 g_value_init (¶ms
[0], G_TYPE_SOCKET
);
3286 g_value_set_object (¶ms
[0], socket
);
3287 g_value_init (¶ms
[1], G_TYPE_IO_CONDITION
);
3288 g_value_set_flags (¶ms
[1], condition
);
3290 g_closure_invoke (closure
, &result_value
, 2, params
, NULL
);
3292 result
= g_value_get_boolean (&result_value
);
3293 g_value_unset (&result_value
);
3294 g_value_unset (¶ms
[0]);
3295 g_value_unset (¶ms
[1]);
3300 static GSourceFuncs socket_source_funcs
=
3302 socket_source_prepare
,
3303 socket_source_check
,
3304 socket_source_dispatch
,
3305 socket_source_finalize
,
3306 (GSourceFunc
)socket_source_closure_callback
,
3310 socket_source_new (GSocket
*socket
,
3311 GIOCondition condition
,
3312 GCancellable
*cancellable
)
3315 GSocketSource
*socket_source
;
3318 ensure_event (socket
);
3320 if (socket
->priv
->event
== WSA_INVALID_EVENT
)
3322 g_warning ("Failed to create WSAEvent");
3323 return g_source_new (&broken_funcs
, sizeof (GSource
));
3327 condition
|= G_IO_HUP
| G_IO_ERR
;
3329 source
= g_source_new (&socket_source_funcs
, sizeof (GSocketSource
));
3330 g_source_set_name (source
, "GSocket");
3331 socket_source
= (GSocketSource
*)source
;
3333 socket_source
->socket
= g_object_ref (socket
);
3334 socket_source
->condition
= condition
;
3336 if (g_cancellable_make_pollfd (cancellable
,
3337 &socket_source
->cancel_pollfd
))
3339 socket_source
->cancellable
= g_object_ref (cancellable
);
3340 g_source_add_poll (source
, &socket_source
->cancel_pollfd
);
3344 add_condition_watch (socket
, &socket_source
->condition
);
3345 socket_source
->pollfd
.fd
= (gintptr
) socket
->priv
->event
;
3347 socket_source
->pollfd
.fd
= socket
->priv
->fd
;
3350 socket_source
->pollfd
.events
= condition
;
3351 socket_source
->pollfd
.revents
= 0;
3352 g_source_add_poll (source
, &socket_source
->pollfd
);
3354 if (socket
->priv
->timeout
)
3355 socket_source
->timeout_time
= g_get_monotonic_time () +
3356 socket
->priv
->timeout
* 1000000;
3359 socket_source
->timeout_time
= 0;
3365 * g_socket_create_source: (skip)
3366 * @socket: a #GSocket
3367 * @condition: a #GIOCondition mask to monitor
3368 * @cancellable: (allow-none): a %GCancellable or %NULL
3370 * Creates a %GSource that can be attached to a %GMainContext to monitor
3371 * for the availibility of the specified @condition on the socket.
3373 * The callback on the source is of the #GSocketSourceFunc type.
3375 * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in @condition;
3376 * these conditions will always be reported output if they are true.
3378 * @cancellable if not %NULL can be used to cancel the source, which will
3379 * cause the source to trigger, reporting the current condition (which
3380 * is likely 0 unless cancellation happened at the same time as a
3381 * condition change). You can check for this in the callback using
3382 * g_cancellable_is_cancelled().
3384 * If @socket has a timeout set, and it is reached before @condition
3385 * occurs, the source will then trigger anyway, reporting %G_IO_IN or
3386 * %G_IO_OUT depending on @condition. However, @socket will have been
3387 * marked as having had a timeout, and so the next #GSocket I/O method
3388 * you call will then fail with a %G_IO_ERROR_TIMED_OUT.
3390 * Returns: (transfer full): a newly allocated %GSource, free with g_source_unref().
3395 g_socket_create_source (GSocket
*socket
,
3396 GIOCondition condition
,
3397 GCancellable
*cancellable
)
3399 g_return_val_if_fail (G_IS_SOCKET (socket
) && (cancellable
== NULL
|| G_IS_CANCELLABLE (cancellable
)), NULL
);
3401 return socket_source_new (socket
, condition
, cancellable
);
3405 * g_socket_condition_check:
3406 * @socket: a #GSocket
3407 * @condition: a #GIOCondition mask to check
3409 * Checks on the readiness of @socket to perform operations.
3410 * The operations specified in @condition are checked for and masked
3411 * against the currently-satisfied conditions on @socket. The result
3414 * Note that on Windows, it is possible for an operation to return
3415 * %G_IO_ERROR_WOULD_BLOCK even immediately after
3416 * g_socket_condition_check() has claimed that the socket is ready for
3417 * writing. Rather than calling g_socket_condition_check() and then
3418 * writing to the socket if it succeeds, it is generally better to
3419 * simply try writing to the socket right away, and try again later if
3420 * the initial attempt returns %G_IO_ERROR_WOULD_BLOCK.
3422 * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in condition;
3423 * these conditions will always be set in the output if they are true.
3425 * This call never blocks.
3427 * Returns: the @GIOCondition mask of the current state
3432 g_socket_condition_check (GSocket
*socket
,
3433 GIOCondition condition
)
3435 g_return_val_if_fail (G_IS_SOCKET (socket
), 0);
3437 if (!check_socket (socket
, NULL
))
3442 GIOCondition current_condition
;
3444 condition
|= G_IO_ERR
| G_IO_HUP
;
3446 add_condition_watch (socket
, &condition
);
3447 current_condition
= update_condition (socket
);
3448 remove_condition_watch (socket
, &condition
);
3449 return condition
& current_condition
;
3455 poll_fd
.fd
= socket
->priv
->fd
;
3456 poll_fd
.events
= condition
;
3457 poll_fd
.revents
= 0;
3460 result
= g_poll (&poll_fd
, 1, 0);
3461 while (result
== -1 && get_socket_errno () == EINTR
);
3463 return poll_fd
.revents
;
3469 * g_socket_condition_wait:
3470 * @socket: a #GSocket
3471 * @condition: a #GIOCondition mask to wait for
3472 * @cancellable: (allow-none): a #GCancellable, or %NULL
3473 * @error: a #GError pointer, or %NULL
3475 * Waits for @condition to become true on @socket. When the condition
3476 * is met, %TRUE is returned.
3478 * If @cancellable is cancelled before the condition is met, or if the
3479 * socket has a timeout set and it is reached before the condition is
3480 * met, then %FALSE is returned and @error, if non-%NULL, is set to
3481 * the appropriate value (%G_IO_ERROR_CANCELLED or
3482 * %G_IO_ERROR_TIMED_OUT).
3484 * See also g_socket_condition_timed_wait().
3486 * Returns: %TRUE if the condition was met, %FALSE otherwise
3491 g_socket_condition_wait (GSocket
*socket
,
3492 GIOCondition condition
,
3493 GCancellable
*cancellable
,
3496 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
3498 return g_socket_condition_timed_wait (socket
, condition
, -1,
3499 cancellable
, error
);
3503 * g_socket_condition_timed_wait:
3504 * @socket: a #GSocket
3505 * @condition: a #GIOCondition mask to wait for
3506 * @timeout: the maximum time (in microseconds) to wait, or -1
3507 * @cancellable: (allow-none): a #GCancellable, or %NULL
3508 * @error: a #GError pointer, or %NULL
3510 * Waits for up to @timeout microseconds for @condition to become true
3511 * on @socket. If the condition is met, %TRUE is returned.
3513 * If @cancellable is cancelled before the condition is met, or if
3514 * @timeout (or the socket's #GSocket:timeout) is reached before the
3515 * condition is met, then %FALSE is returned and @error, if non-%NULL,
3516 * is set to the appropriate value (%G_IO_ERROR_CANCELLED or
3517 * %G_IO_ERROR_TIMED_OUT).
3519 * If you don't want a timeout, use g_socket_condition_wait().
3520 * (Alternatively, you can pass -1 for @timeout.)
3522 * Note that although @timeout is in microseconds for consistency with
3523 * other GLib APIs, this function actually only has millisecond
3524 * resolution, and the behavior is undefined if @timeout is not an
3525 * exact number of milliseconds.
3527 * Returns: %TRUE if the condition was met, %FALSE otherwise
3532 g_socket_condition_timed_wait (GSocket
*socket
,
3533 GIOCondition condition
,
3535 GCancellable
*cancellable
,
3540 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
3542 if (!check_socket (socket
, error
))
3545 if (g_cancellable_set_error_if_cancelled (cancellable
, error
))
3548 if (socket
->priv
->timeout
&&
3549 (timeout
< 0 || socket
->priv
->timeout
< timeout
/ G_USEC_PER_SEC
))
3550 timeout
= socket
->priv
->timeout
* 1000;
3551 else if (timeout
!= -1)
3552 timeout
= timeout
/ 1000;
3554 start_time
= g_get_monotonic_time ();
3558 GIOCondition current_condition
;
3564 /* Always check these */
3565 condition
|= G_IO_ERR
| G_IO_HUP
;
3567 add_condition_watch (socket
, &condition
);
3570 events
[num_events
++] = socket
->priv
->event
;
3572 if (g_cancellable_make_pollfd (cancellable
, &cancel_fd
))
3573 events
[num_events
++] = (WSAEVENT
)cancel_fd
.fd
;
3576 timeout
= WSA_INFINITE
;
3578 current_condition
= update_condition (socket
);
3579 while ((condition
& current_condition
) == 0)
3581 res
= WSAWaitForMultipleEvents (num_events
, events
,
3582 FALSE
, timeout
, FALSE
);
3583 if (res
== WSA_WAIT_FAILED
)
3585 int errsv
= get_socket_errno ();
3587 g_set_error (error
, G_IO_ERROR
,
3588 socket_io_error_from_errno (errsv
),
3589 _("Waiting for socket condition: %s"),
3590 socket_strerror (errsv
));
3593 else if (res
== WSA_WAIT_TIMEOUT
)
3595 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_TIMED_OUT
,
3596 _("Socket I/O timed out"));
3600 if (g_cancellable_set_error_if_cancelled (cancellable
, error
))
3603 current_condition
= update_condition (socket
);
3605 if (timeout
!= WSA_INFINITE
)
3607 timeout
-= (g_get_monotonic_time () - start_time
) * 1000;
3612 remove_condition_watch (socket
, &condition
);
3614 g_cancellable_release_fd (cancellable
);
3616 return (condition
& current_condition
) != 0;
3624 poll_fd
[0].fd
= socket
->priv
->fd
;
3625 poll_fd
[0].events
= condition
;
3628 if (g_cancellable_make_pollfd (cancellable
, &poll_fd
[1]))
3633 result
= g_poll (poll_fd
, num
, timeout
);
3634 if (result
!= -1 || errno
!= EINTR
)
3639 timeout
-= (g_get_monotonic_time () - start_time
) * 1000;
3646 g_cancellable_release_fd (cancellable
);
3650 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_TIMED_OUT
,
3651 _("Socket I/O timed out"));
3655 return !g_cancellable_set_error_if_cancelled (cancellable
, error
);
3661 * g_socket_send_message:
3662 * @socket: a #GSocket
3663 * @address: (allow-none): a #GSocketAddress, or %NULL
3664 * @vectors: (array length=num_vectors): an array of #GOutputVector structs
3665 * @num_vectors: the number of elements in @vectors, or -1
3666 * @messages: (array length=num_messages) (allow-none): a pointer to an
3667 * array of #GSocketControlMessages, or %NULL.
3668 * @num_messages: number of elements in @messages, or -1.
3669 * @flags: an int containing #GSocketMsgFlags flags
3670 * @cancellable: (allow-none): a %GCancellable or %NULL
3671 * @error: #GError for error reporting, or %NULL to ignore.
3673 * Send data to @address on @socket. This is the most complicated and
3674 * fully-featured version of this call. For easier use, see
3675 * g_socket_send() and g_socket_send_to().
3677 * If @address is %NULL then the message is sent to the default receiver
3678 * (set by g_socket_connect()).
3680 * @vectors must point to an array of #GOutputVector structs and
3681 * @num_vectors must be the length of this array. (If @num_vectors is -1,
3682 * then @vectors is assumed to be terminated by a #GOutputVector with a
3683 * %NULL buffer pointer.) The #GOutputVector structs describe the buffers
3684 * that the sent data will be gathered from. Using multiple
3685 * #GOutputVector<!-- -->s is more memory-efficient than manually copying
3686 * data from multiple sources into a single buffer, and more
3687 * network-efficient than making multiple calls to g_socket_send().
3689 * @messages, if non-%NULL, is taken to point to an array of @num_messages
3690 * #GSocketControlMessage instances. These correspond to the control
3691 * messages to be sent on the socket.
3692 * If @num_messages is -1 then @messages is treated as a %NULL-terminated
3695 * @flags modify how the message is sent. The commonly available arguments
3696 * for this are available in the #GSocketMsgFlags enum, but the
3697 * values there are the same as the system values, and the flags
3698 * are passed in as-is, so you can pass in system-specific flags too.
3700 * If the socket is in blocking mode the call will block until there is
3701 * space for the data in the socket queue. If there is no space available
3702 * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
3703 * will be returned. To be notified when space is available, wait for the
3704 * %G_IO_OUT condition. Note though that you may still receive
3705 * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
3706 * notified of a %G_IO_OUT condition. (On Windows in particular, this is
3707 * very common due to the way the underlying APIs work.)
3709 * On error -1 is returned and @error is set accordingly.
3711 * Returns: Number of bytes written (which may be less than @size), or -1
3717 g_socket_send_message (GSocket
*socket
,
3718 GSocketAddress
*address
,
3719 GOutputVector
*vectors
,
3721 GSocketControlMessage
**messages
,
3724 GCancellable
*cancellable
,
3727 GOutputVector one_vector
;
3730 g_return_val_if_fail (G_IS_SOCKET (socket
), -1);
3732 if (!check_socket (socket
, error
))
3735 if (g_cancellable_set_error_if_cancelled (cancellable
, error
))
3738 if (num_vectors
== -1)
3740 for (num_vectors
= 0;
3741 vectors
[num_vectors
].buffer
!= NULL
;
3746 if (num_messages
== -1)
3748 for (num_messages
= 0;
3749 messages
!= NULL
&& messages
[num_messages
] != NULL
;
3754 if (num_vectors
== 0)
3758 one_vector
.buffer
= &zero
;
3759 one_vector
.size
= 1;
3761 vectors
= &one_vector
;
3774 msg
.msg_namelen
= g_socket_address_get_native_size (address
);
3775 msg
.msg_name
= g_alloca (msg
.msg_namelen
);
3776 if (!g_socket_address_to_native (address
, msg
.msg_name
, msg
.msg_namelen
, error
))
3781 msg
.msg_name
= NULL
;
3782 msg
.msg_namelen
= 0;
3787 /* this entire expression will be evaluated at compile time */
3788 if (sizeof *msg
.msg_iov
== sizeof *vectors
&&
3789 sizeof msg
.msg_iov
->iov_base
== sizeof vectors
->buffer
&&
3790 G_STRUCT_OFFSET (struct iovec
, iov_base
) ==
3791 G_STRUCT_OFFSET (GOutputVector
, buffer
) &&
3792 sizeof msg
.msg_iov
->iov_len
== sizeof vectors
->size
&&
3793 G_STRUCT_OFFSET (struct iovec
, iov_len
) ==
3794 G_STRUCT_OFFSET (GOutputVector
, size
))
3795 /* ABI is compatible */
3797 msg
.msg_iov
= (struct iovec
*) vectors
;
3798 msg
.msg_iovlen
= num_vectors
;
3801 /* ABI is incompatible */
3805 msg
.msg_iov
= g_newa (struct iovec
, num_vectors
);
3806 for (i
= 0; i
< num_vectors
; i
++)
3808 msg
.msg_iov
[i
].iov_base
= (void *) vectors
[i
].buffer
;
3809 msg
.msg_iov
[i
].iov_len
= vectors
[i
].size
;
3811 msg
.msg_iovlen
= num_vectors
;
3817 struct cmsghdr
*cmsg
;
3820 msg
.msg_controllen
= 0;
3821 for (i
= 0; i
< num_messages
; i
++)
3822 msg
.msg_controllen
+= CMSG_SPACE (g_socket_control_message_get_size (messages
[i
]));
3824 if (msg
.msg_controllen
== 0)
3825 msg
.msg_control
= NULL
;
3828 msg
.msg_control
= g_alloca (msg
.msg_controllen
);
3829 memset (msg
.msg_control
, '\0', msg
.msg_controllen
);
3832 cmsg
= CMSG_FIRSTHDR (&msg
);
3833 for (i
= 0; i
< num_messages
; i
++)
3835 cmsg
->cmsg_level
= g_socket_control_message_get_level (messages
[i
]);
3836 cmsg
->cmsg_type
= g_socket_control_message_get_msg_type (messages
[i
]);
3837 cmsg
->cmsg_len
= CMSG_LEN (g_socket_control_message_get_size (messages
[i
]));
3838 g_socket_control_message_serialize (messages
[i
],
3840 cmsg
= CMSG_NXTHDR (&msg
, cmsg
);
3842 g_assert (cmsg
== NULL
);
3847 if (socket
->priv
->blocking
&&
3848 !g_socket_condition_wait (socket
,
3849 G_IO_OUT
, cancellable
, error
))
3852 result
= sendmsg (socket
->priv
->fd
, &msg
, flags
| G_SOCKET_DEFAULT_SEND_FLAGS
);
3855 int errsv
= get_socket_errno ();
3860 if (socket
->priv
->blocking
&&
3861 (errsv
== EWOULDBLOCK
||
3865 g_set_error (error
, G_IO_ERROR
,
3866 socket_io_error_from_errno (errsv
),
3867 _("Error sending message: %s"), socket_strerror (errsv
));
3878 struct sockaddr_storage addr
;
3885 /* Win32 doesn't support control messages.
3886 Actually this is possible for raw and datagram sockets
3887 via WSASendMessage on Vista or later, but that doesn't
3889 if (num_messages
!= 0)
3891 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
3892 _("GSocketControlMessage not supported on Windows"));
3897 bufs
= g_newa (WSABUF
, num_vectors
);
3898 for (i
= 0; i
< num_vectors
; i
++)
3900 bufs
[i
].buf
= (char *)vectors
[i
].buffer
;
3901 bufs
[i
].len
= (gulong
)vectors
[i
].size
;
3905 addrlen
= 0; /* Avoid warning */
3908 addrlen
= g_socket_address_get_native_size (address
);
3909 if (!g_socket_address_to_native (address
, &addr
, sizeof addr
, error
))
3915 if (socket
->priv
->blocking
&&
3916 !g_socket_condition_wait (socket
,
3917 G_IO_OUT
, cancellable
, error
))
3921 result
= WSASendTo (socket
->priv
->fd
,
3924 (const struct sockaddr
*)&addr
, addrlen
,
3927 result
= WSASend (socket
->priv
->fd
,
3934 int errsv
= get_socket_errno ();
3936 if (errsv
== WSAEINTR
)
3939 if (errsv
== WSAEWOULDBLOCK
)
3940 win32_unset_event_mask (socket
, FD_WRITE
);
3942 if (socket
->priv
->blocking
&&
3943 errsv
== WSAEWOULDBLOCK
)
3946 g_set_error (error
, G_IO_ERROR
,
3947 socket_io_error_from_errno (errsv
),
3948 _("Error sending message: %s"), socket_strerror (errsv
));
3960 static GSocketAddress
*
3961 cache_recv_address (GSocket
*socket
, struct sockaddr
*native
, int native_len
)
3963 GSocketAddress
*saddr
;
3965 guint64 oldest_time
= G_MAXUINT64
;
3966 gint oldest_index
= 0;
3968 if (native_len
<= 0)
3972 for (i
= 0; i
< RECV_ADDR_CACHE_SIZE
; i
++)
3974 GSocketAddress
*tmp
= socket
->priv
->recv_addr_cache
[i
].addr
;
3975 gpointer tmp_native
= socket
->priv
->recv_addr_cache
[i
].native
;
3976 gint tmp_native_len
= socket
->priv
->recv_addr_cache
[i
].native_len
;
3981 if (tmp_native_len
!= native_len
)
3984 if (memcmp (tmp_native
, native
, native_len
) == 0)
3986 saddr
= g_object_ref (tmp
);
3987 socket
->priv
->recv_addr_cache
[i
].last_used
= g_get_monotonic_time ();
3991 if (socket
->priv
->recv_addr_cache
[i
].last_used
< oldest_time
)
3993 oldest_time
= socket
->priv
->recv_addr_cache
[i
].last_used
;
3998 saddr
= g_socket_address_new_from_native (native
, native_len
);
4000 if (socket
->priv
->recv_addr_cache
[oldest_index
].addr
)
4002 g_object_unref (socket
->priv
->recv_addr_cache
[oldest_index
].addr
);
4003 g_free (socket
->priv
->recv_addr_cache
[oldest_index
].native
);
4006 socket
->priv
->recv_addr_cache
[oldest_index
].native
= g_memdup (native
, native_len
);
4007 socket
->priv
->recv_addr_cache
[oldest_index
].native_len
= native_len
;
4008 socket
->priv
->recv_addr_cache
[oldest_index
].addr
= g_object_ref (saddr
);
4009 socket
->priv
->recv_addr_cache
[oldest_index
].last_used
= g_get_monotonic_time ();
4015 * g_socket_receive_message:
4016 * @socket: a #GSocket
4017 * @address: (out) (allow-none): a pointer to a #GSocketAddress
4019 * @vectors: (array length=num_vectors): an array of #GInputVector structs
4020 * @num_vectors: the number of elements in @vectors, or -1
4021 * @messages: (array length=num_messages) (allow-none): a pointer which
4022 * may be filled with an array of #GSocketControlMessages, or %NULL
4023 * @num_messages: a pointer which will be filled with the number of
4024 * elements in @messages, or %NULL
4025 * @flags: a pointer to an int containing #GSocketMsgFlags flags
4026 * @cancellable: (allow-none): a %GCancellable or %NULL
4027 * @error: a #GError pointer, or %NULL
4029 * Receive data from a socket. This is the most complicated and
4030 * fully-featured version of this call. For easier use, see
4031 * g_socket_receive() and g_socket_receive_from().
4033 * If @address is non-%NULL then @address will be set equal to the
4034 * source address of the received packet.
4035 * @address is owned by the caller.
4037 * @vector must point to an array of #GInputVector structs and
4038 * @num_vectors must be the length of this array. These structs
4039 * describe the buffers that received data will be scattered into.
4040 * If @num_vectors is -1, then @vectors is assumed to be terminated
4041 * by a #GInputVector with a %NULL buffer pointer.
4043 * As a special case, if @num_vectors is 0 (in which case, @vectors
4044 * may of course be %NULL), then a single byte is received and
4045 * discarded. This is to facilitate the common practice of sending a
4046 * single '\0' byte for the purposes of transferring ancillary data.
4048 * @messages, if non-%NULL, will be set to point to a newly-allocated
4049 * array of #GSocketControlMessage instances or %NULL if no such
4050 * messages was received. These correspond to the control messages
4051 * received from the kernel, one #GSocketControlMessage per message
4052 * from the kernel. This array is %NULL-terminated and must be freed
4053 * by the caller using g_free() after calling g_object_unref() on each
4054 * element. If @messages is %NULL, any control messages received will
4057 * @num_messages, if non-%NULL, will be set to the number of control
4058 * messages received.
4060 * If both @messages and @num_messages are non-%NULL, then
4061 * @num_messages gives the number of #GSocketControlMessage instances
4062 * in @messages (ie: not including the %NULL terminator).
4064 * @flags is an in/out parameter. The commonly available arguments
4065 * for this are available in the #GSocketMsgFlags enum, but the
4066 * values there are the same as the system values, and the flags
4067 * are passed in as-is, so you can pass in system-specific flags too
4068 * (and g_socket_receive_message() may pass system-specific flags out).
4070 * As with g_socket_receive(), data may be discarded if @socket is
4071 * %G_SOCKET_TYPE_DATAGRAM or %G_SOCKET_TYPE_SEQPACKET and you do not
4072 * provide enough buffer space to read a complete message. You can pass
4073 * %G_SOCKET_MSG_PEEK in @flags to peek at the current message without
4074 * removing it from the receive queue, but there is no portable way to find
4075 * out the length of the message other than by reading it into a
4076 * sufficiently-large buffer.
4078 * If the socket is in blocking mode the call will block until there
4079 * is some data to receive, the connection is closed, or there is an
4080 * error. If there is no data available and the socket is in
4081 * non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
4082 * returned. To be notified when data is available, wait for the
4083 * %G_IO_IN condition.
4085 * On error -1 is returned and @error is set accordingly.
4087 * Returns: Number of bytes read, or 0 if the connection was closed by
4088 * the peer, or -1 on error
4093 g_socket_receive_message (GSocket
*socket
,
4094 GSocketAddress
**address
,
4095 GInputVector
*vectors
,
4097 GSocketControlMessage
***messages
,
4100 GCancellable
*cancellable
,
4103 GInputVector one_vector
;
4106 g_return_val_if_fail (G_IS_SOCKET (socket
), -1);
4108 if (!check_socket (socket
, error
))
4111 if (g_cancellable_set_error_if_cancelled (cancellable
, error
))
4114 if (num_vectors
== -1)
4116 for (num_vectors
= 0;
4117 vectors
[num_vectors
].buffer
!= NULL
;
4122 if (num_vectors
== 0)
4124 one_vector
.buffer
= &one_byte
;
4125 one_vector
.size
= 1;
4127 vectors
= &one_vector
;
4134 struct sockaddr_storage one_sockaddr
;
4139 msg
.msg_name
= &one_sockaddr
;
4140 msg
.msg_namelen
= sizeof (struct sockaddr_storage
);
4144 msg
.msg_name
= NULL
;
4145 msg
.msg_namelen
= 0;
4149 /* this entire expression will be evaluated at compile time */
4150 if (sizeof *msg
.msg_iov
== sizeof *vectors
&&
4151 sizeof msg
.msg_iov
->iov_base
== sizeof vectors
->buffer
&&
4152 G_STRUCT_OFFSET (struct iovec
, iov_base
) ==
4153 G_STRUCT_OFFSET (GInputVector
, buffer
) &&
4154 sizeof msg
.msg_iov
->iov_len
== sizeof vectors
->size
&&
4155 G_STRUCT_OFFSET (struct iovec
, iov_len
) ==
4156 G_STRUCT_OFFSET (GInputVector
, size
))
4157 /* ABI is compatible */
4159 msg
.msg_iov
= (struct iovec
*) vectors
;
4160 msg
.msg_iovlen
= num_vectors
;
4163 /* ABI is incompatible */
4167 msg
.msg_iov
= g_newa (struct iovec
, num_vectors
);
4168 for (i
= 0; i
< num_vectors
; i
++)
4170 msg
.msg_iov
[i
].iov_base
= vectors
[i
].buffer
;
4171 msg
.msg_iov
[i
].iov_len
= vectors
[i
].size
;
4173 msg
.msg_iovlen
= num_vectors
;
4177 msg
.msg_control
= g_alloca (2048);
4178 msg
.msg_controllen
= 2048;
4182 msg
.msg_flags
= *flags
;
4186 /* We always set the close-on-exec flag so we don't leak file
4187 * descriptors into child processes. Note that gunixfdmessage.c
4188 * will later call fcntl (fd, FD_CLOEXEC), but that isn't atomic.
4190 #ifdef MSG_CMSG_CLOEXEC
4191 msg
.msg_flags
|= MSG_CMSG_CLOEXEC
;
4197 if (socket
->priv
->blocking
&&
4198 !g_socket_condition_wait (socket
,
4199 G_IO_IN
, cancellable
, error
))
4202 result
= recvmsg (socket
->priv
->fd
, &msg
, msg
.msg_flags
);
4203 #ifdef MSG_CMSG_CLOEXEC
4204 if (result
< 0 && get_socket_errno () == EINVAL
)
4206 /* We must be running on an old kernel. Call without the flag. */
4207 msg
.msg_flags
&= ~(MSG_CMSG_CLOEXEC
);
4208 result
= recvmsg (socket
->priv
->fd
, &msg
, msg
.msg_flags
);
4214 int errsv
= get_socket_errno ();
4219 if (socket
->priv
->blocking
&&
4220 (errsv
== EWOULDBLOCK
||
4224 g_set_error (error
, G_IO_ERROR
,
4225 socket_io_error_from_errno (errsv
),
4226 _("Error receiving message: %s"), socket_strerror (errsv
));
4233 /* decode address */
4234 if (address
!= NULL
)
4236 *address
= cache_recv_address (socket
, msg
.msg_name
, msg
.msg_namelen
);
4239 /* decode control messages */
4241 GPtrArray
*my_messages
= NULL
;
4242 struct cmsghdr
*cmsg
;
4244 if (msg
.msg_controllen
>= sizeof (struct cmsghdr
))
4246 for (cmsg
= CMSG_FIRSTHDR (&msg
); cmsg
; cmsg
= CMSG_NXTHDR (&msg
, cmsg
))
4248 GSocketControlMessage
*message
;
4250 message
= g_socket_control_message_deserialize (cmsg
->cmsg_level
,
4252 cmsg
->cmsg_len
- ((char *)CMSG_DATA (cmsg
) - (char *)cmsg
),
4254 if (message
== NULL
)
4255 /* We've already spewed about the problem in the
4256 deserialization code, so just continue */
4259 if (messages
== NULL
)
4261 /* we have to do it this way if the user ignores the
4262 * messages so that we will close any received fds.
4264 g_object_unref (message
);
4268 if (my_messages
== NULL
)
4269 my_messages
= g_ptr_array_new ();
4270 g_ptr_array_add (my_messages
, message
);
4276 *num_messages
= my_messages
!= NULL
? my_messages
->len
: 0;
4280 if (my_messages
== NULL
)
4286 g_ptr_array_add (my_messages
, NULL
);
4287 *messages
= (GSocketControlMessage
**) g_ptr_array_free (my_messages
, FALSE
);
4292 g_assert (my_messages
== NULL
);
4296 /* capture the flags */
4298 *flags
= msg
.msg_flags
;
4304 struct sockaddr_storage addr
;
4306 DWORD bytes_received
;
4313 bufs
= g_newa (WSABUF
, num_vectors
);
4314 for (i
= 0; i
< num_vectors
; i
++)
4316 bufs
[i
].buf
= (char *)vectors
[i
].buffer
;
4317 bufs
[i
].len
= (gulong
)vectors
[i
].size
;
4329 if (socket
->priv
->blocking
&&
4330 !g_socket_condition_wait (socket
,
4331 G_IO_IN
, cancellable
, error
))
4334 addrlen
= sizeof addr
;
4336 result
= WSARecvFrom (socket
->priv
->fd
,
4338 &bytes_received
, &win_flags
,
4339 (struct sockaddr
*)&addr
, &addrlen
,
4342 result
= WSARecv (socket
->priv
->fd
,
4344 &bytes_received
, &win_flags
,
4348 int errsv
= get_socket_errno ();
4350 if (errsv
== WSAEINTR
)
4353 win32_unset_event_mask (socket
, FD_READ
);
4355 if (socket
->priv
->blocking
&&
4356 errsv
== WSAEWOULDBLOCK
)
4359 g_set_error (error
, G_IO_ERROR
,
4360 socket_io_error_from_errno (errsv
),
4361 _("Error receiving message: %s"), socket_strerror (errsv
));
4365 win32_unset_event_mask (socket
, FD_READ
);
4369 /* decode address */
4370 if (address
!= NULL
)
4372 *address
= cache_recv_address (socket
, (struct sockaddr
*)&addr
, addrlen
);
4375 /* capture the flags */
4379 if (messages
!= NULL
)
4381 if (num_messages
!= NULL
)
4384 return bytes_received
;
4390 * g_socket_get_credentials:
4391 * @socket: a #GSocket.
4392 * @error: #GError for error reporting, or %NULL to ignore.
4394 * Returns the credentials of the foreign process connected to this
4395 * socket, if any (e.g. it is only supported for %G_SOCKET_FAMILY_UNIX
4398 * If this operation isn't supported on the OS, the method fails with
4399 * the %G_IO_ERROR_NOT_SUPPORTED error. On Linux this is implemented
4400 * by reading the %SO_PEERCRED option on the underlying socket.
4402 * Other ways to obtain credentials from a foreign peer includes the
4403 * #GUnixCredentialsMessage type and
4404 * g_unix_connection_send_credentials() /
4405 * g_unix_connection_receive_credentials() functions.
4407 * Returns: (transfer full): %NULL if @error is set, otherwise a #GCredentials object
4408 * that must be freed with g_object_unref().
4413 g_socket_get_credentials (GSocket
*socket
,
4418 g_return_val_if_fail (G_IS_SOCKET (socket
), NULL
);
4419 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
4423 #if defined(__linux__) || defined(__OpenBSD__)
4426 #if defined(__linux__)
4427 struct ucred native_creds
;
4428 optlen
= sizeof (struct ucred
);
4429 #elif defined(__OpenBSD__)
4430 struct sockpeercred native_creds
;
4431 optlen
= sizeof (struct sockpeercred
);
4433 if (getsockopt (socket
->priv
->fd
,
4436 (void *)&native_creds
,
4439 int errsv
= get_socket_errno ();
4442 socket_io_error_from_errno (errsv
),
4443 _("Unable to read socket credentials: %s"),
4444 socket_strerror (errsv
));
4448 ret
= g_credentials_new ();
4449 g_credentials_set_native (ret
,
4450 #if defined(__linux__)
4451 G_CREDENTIALS_TYPE_LINUX_UCRED
,
4452 #elif defined(__OpenBSD__)
4453 G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED
,
4459 g_set_error_literal (error
,
4461 G_IO_ERROR_NOT_SUPPORTED
,
4462 _("g_socket_get_credentials not implemented for this OS"));
4469 * g_socket_get_option:
4470 * @socket: a #GSocket
4471 * @level: the "API level" of the option (eg, <literal>SOL_SOCKET</literal>)
4472 * @optname: the "name" of the option (eg, <literal>SO_BROADCAST</literal>)
4473 * @value: (out): return location for the option value
4474 * @error: #GError for error reporting, or %NULL to ignore.
4476 * Gets the value of an integer-valued option on @socket, as with
4477 * <literal>getsockopt ()</literal>. (If you need to fetch a
4478 * non-integer-valued option, you will need to call
4479 * <literal>getsockopt ()</literal> directly.)
4481 * The <link linkend="gio-gnetworking.h"><literal><gio/gnetworking.h></literal></link>
4482 * header pulls in system headers that will define most of the
4483 * standard/portable socket options. For unusual socket protocols or
4484 * platform-dependent options, you may need to include additional
4487 * Note that even for socket options that are a single byte in size,
4488 * @value is still a pointer to a #gint variable, not a #guchar;
4489 * g_socket_get_option() will handle the conversion internally.
4491 * Returns: success or failure. On failure, @error will be set, and
4492 * the system error value (<literal>errno</literal> or
4493 * <literal>WSAGetLastError ()</literal>) will still be set to the
4494 * result of the <literal>getsockopt ()</literal> call.
4499 g_socket_get_option (GSocket
*socket
,
4507 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
4510 size
= sizeof (gint
);
4511 if (getsockopt (socket
->priv
->fd
, level
, optname
, value
, &size
) != 0)
4513 int errsv
= get_socket_errno ();
4515 g_set_error_literal (error
,
4517 socket_io_error_from_errno (errsv
),
4518 socket_strerror (errsv
));
4520 /* Reset errno in case the caller wants to look at it */
4526 #if G_BYTE_ORDER == G_BIG_ENDIAN
4527 /* If the returned value is smaller than an int then we need to
4528 * slide it over into the low-order bytes of *value.
4530 if (size
!= sizeof (gint
))
4531 *value
= *value
>> (8 * (sizeof (gint
) - size
));
4538 * g_socket_set_option:
4539 * @socket: a #GSocket
4540 * @level: the "API level" of the option (eg, <literal>SOL_SOCKET</literal>)
4541 * @optname: the "name" of the option (eg, <literal>SO_BROADCAST</literal>)
4542 * @value: the value to set the option to
4543 * @error: #GError for error reporting, or %NULL to ignore.
4545 * Sets the value of an integer-valued option on @socket, as with
4546 * <literal>setsockopt ()</literal>. (If you need to set a
4547 * non-integer-valued option, you will need to call
4548 * <literal>setsockopt ()</literal> directly.)
4550 * The <link linkend="gio-gnetworking.h"><literal><gio/gnetworking.h></literal></link>
4551 * header pulls in system headers that will define most of the
4552 * standard/portable socket options. For unusual socket protocols or
4553 * platform-dependent options, you may need to include additional
4556 * Returns: success or failure. On failure, @error will be set, and
4557 * the system error value (<literal>errno</literal> or
4558 * <literal>WSAGetLastError ()</literal>) will still be set to the
4559 * result of the <literal>setsockopt ()</literal> call.
4564 g_socket_set_option (GSocket
*socket
,
4572 g_return_val_if_fail (G_IS_SOCKET (socket
), FALSE
);
4574 if (setsockopt (socket
->priv
->fd
, level
, optname
, &value
, sizeof (gint
)) == 0)
4577 #if !defined (__linux__) && !defined (G_OS_WIN32)
4578 /* Linux and Windows let you set a single-byte value from an int,
4579 * but most other platforms don't.
4581 if (errno
== EINVAL
&& value
>= SCHAR_MIN
&& value
<= CHAR_MAX
)
4583 #if G_BYTE_ORDER == G_BIG_ENDIAN
4584 value
= value
<< (8 * (sizeof (gint
) - 1));
4586 if (setsockopt (socket
->priv
->fd
, level
, optname
, &value
, 1) == 0)
4591 errsv
= get_socket_errno ();
4593 g_set_error_literal (error
,
4595 socket_io_error_from_errno (errsv
),
4596 socket_strerror (errsv
));