1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright © 2008, 2009 codethink
4 * Copyright © 2009 Red Hat, Inc
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General
17 * Public License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
19 * Boston, MA 02111-1307, USA.
21 * Authors: Ryan Lortie <desrt@desrt.ca>
22 * Alexander Larsson <alexl@redhat.com>
26 #include "gsocketclient.h"
31 #include <gio/gioenumtypes.h>
32 #include <gio/gsocketaddressenumerator.h>
33 #include <gio/gsocketconnectable.h>
34 #include <gio/gsocketconnection.h>
35 #include <gio/gproxyaddressenumerator.h>
36 #include <gio/gproxyaddress.h>
37 #include <gio/gsimpleasyncresult.h>
38 #include <gio/gcancellable.h>
39 #include <gio/gioerror.h>
40 #include <gio/gsocket.h>
41 #include <gio/gnetworkaddress.h>
42 #include <gio/gnetworkservice.h>
43 #include <gio/gproxy.h>
44 #include <gio/gsocketaddress.h>
45 #include <gio/gtcpconnection.h>
46 #include <gio/gtcpwrapperconnection.h>
47 #include <gio/gtlscertificate.h>
48 #include <gio/gtlsclientconnection.h>
49 #include <gio/ginetaddress.h>
54 * SECTION:gsocketclient
55 * @short_description: Helper for connecting to a network service
57 * @see_also: #GSocketConnection, #GSocketListener
59 * #GSocketClient is a high-level utility class for connecting to a
60 * network host using a connection oriented socket type.
62 * You create a #GSocketClient object, set any options you want, and then
63 * call a sync or async connect operation, which returns a #GSocketConnection
64 * subclass on success.
66 * The type of the #GSocketConnection object returned depends on the type of
67 * the underlying socket that is in use. For instance, for a TCP/IP connection
68 * it will be a #GTcpConnection.
74 G_DEFINE_TYPE (GSocketClient, g_socket_client, G_TYPE_OBJECT);
86 PROP_TLS_VALIDATION_FLAGS
89 struct _GSocketClientPrivate
93 GSocketProtocol protocol;
94 GSocketAddress *local_address;
96 gboolean enable_proxy;
97 GHashTable *app_proxies;
99 GTlsCertificateFlags tls_validation_flags;
103 create_socket (GSocketClient *client,
104 GSocketAddress *dest_address,
107 GSocketFamily family;
110 family = client->priv->family;
111 if (family == G_SOCKET_FAMILY_INVALID &&
112 client->priv->local_address != NULL)
113 family = g_socket_address_get_family (client->priv->local_address);
114 if (family == G_SOCKET_FAMILY_INVALID)
115 family = g_socket_address_get_family (dest_address);
117 socket = g_socket_new (family,
119 client->priv->protocol,
124 if (client->priv->local_address)
126 if (!g_socket_bind (socket,
127 client->priv->local_address,
131 g_object_unref (socket);
136 if (client->priv->timeout)
137 g_socket_set_timeout (socket, client->priv->timeout);
143 can_use_proxy (GSocketClient *client)
145 GSocketClientPrivate *priv = client->priv;
147 return priv->enable_proxy
148 && priv->type == G_SOCKET_TYPE_STREAM;
152 clarify_connect_error (GError *error,
153 GSocketConnectable *connectable,
154 GSocketAddress *address)
157 char *tmp_name = NULL;
159 if (G_IS_PROXY_ADDRESS (address))
161 name = tmp_name = g_inet_address_to_string (g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (address)));
163 g_prefix_error (&error, _("Could not connect to proxy server %s: "), name);
167 if (G_IS_NETWORK_ADDRESS (connectable))
168 name = g_network_address_get_hostname (G_NETWORK_ADDRESS (connectable));
169 else if (G_IS_NETWORK_SERVICE (connectable))
170 name = g_network_service_get_domain (G_NETWORK_SERVICE (connectable));
171 else if (G_IS_INET_SOCKET_ADDRESS (connectable))
172 name = tmp_name = g_inet_address_to_string (g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (connectable)));
177 g_prefix_error (&error, _("Could not connect to %s: "), name);
179 g_prefix_error (&error, _("Could not connect: "));
186 g_socket_client_init (GSocketClient *client)
188 client->priv = G_TYPE_INSTANCE_GET_PRIVATE (client,
189 G_TYPE_SOCKET_CLIENT,
190 GSocketClientPrivate);
191 client->priv->type = G_SOCKET_TYPE_STREAM;
192 client->priv->app_proxies = g_hash_table_new_full (g_str_hash,
199 * g_socket_client_new:
201 * Creates a new #GSocketClient with the default options.
203 * Returns: a #GSocketClient.
204 * Free the returned object with g_object_unref().
209 g_socket_client_new (void)
211 return g_object_new (G_TYPE_SOCKET_CLIENT, NULL);
215 g_socket_client_finalize (GObject *object)
217 GSocketClient *client = G_SOCKET_CLIENT (object);
219 if (client->priv->local_address)
220 g_object_unref (client->priv->local_address);
222 if (G_OBJECT_CLASS (g_socket_client_parent_class)->finalize)
223 (*G_OBJECT_CLASS (g_socket_client_parent_class)->finalize) (object);
225 g_hash_table_unref (client->priv->app_proxies);
229 g_socket_client_get_property (GObject *object,
234 GSocketClient *client = G_SOCKET_CLIENT (object);
239 g_value_set_enum (value, client->priv->family);
243 g_value_set_enum (value, client->priv->type);
247 g_value_set_enum (value, client->priv->protocol);
250 case PROP_LOCAL_ADDRESS:
251 g_value_set_object (value, client->priv->local_address);
255 g_value_set_uint (value, client->priv->timeout);
258 case PROP_ENABLE_PROXY:
259 g_value_set_boolean (value, client->priv->enable_proxy);
263 g_value_set_boolean (value, g_socket_client_get_tls (client));
266 case PROP_TLS_VALIDATION_FLAGS:
267 g_value_set_flags (value, g_socket_client_get_tls_validation_flags (client));
271 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
276 g_socket_client_set_property (GObject *object,
281 GSocketClient *client = G_SOCKET_CLIENT (object);
286 g_socket_client_set_family (client, g_value_get_enum (value));
290 g_socket_client_set_socket_type (client, g_value_get_enum (value));
294 g_socket_client_set_protocol (client, g_value_get_enum (value));
297 case PROP_LOCAL_ADDRESS:
298 g_socket_client_set_local_address (client, g_value_get_object (value));
302 g_socket_client_set_timeout (client, g_value_get_uint (value));
305 case PROP_ENABLE_PROXY:
306 g_socket_client_set_enable_proxy (client, g_value_get_boolean (value));
310 g_socket_client_set_tls (client, g_value_get_boolean (value));
313 case PROP_TLS_VALIDATION_FLAGS:
314 g_socket_client_set_tls_validation_flags (client, g_value_get_flags (value));
318 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
323 * g_socket_client_get_family:
324 * @client: a #GSocketClient.
326 * Gets the socket family of the socket client.
328 * See g_socket_client_set_family() for details.
330 * Returns: a #GSocketFamily
335 g_socket_client_get_family (GSocketClient *client)
337 return client->priv->family;
341 * g_socket_client_set_family:
342 * @client: a #GSocketClient.
343 * @family: a #GSocketFamily
345 * Sets the socket family of the socket client.
346 * If this is set to something other than %G_SOCKET_FAMILY_INVALID
347 * then the sockets created by this object will be of the specified
350 * This might be useful for instance if you want to force the local
351 * connection to be an ipv4 socket, even though the address might
352 * be an ipv6 mapped to ipv4 address.
357 g_socket_client_set_family (GSocketClient *client,
358 GSocketFamily family)
360 if (client->priv->family == family)
363 client->priv->family = family;
364 g_object_notify (G_OBJECT (client), "family");
368 * g_socket_client_get_socket_type:
369 * @client: a #GSocketClient.
371 * Gets the socket type of the socket client.
373 * See g_socket_client_set_socket_type() for details.
375 * Returns: a #GSocketFamily
380 g_socket_client_get_socket_type (GSocketClient *client)
382 return client->priv->type;
386 * g_socket_client_set_socket_type:
387 * @client: a #GSocketClient.
388 * @type: a #GSocketType
390 * Sets the socket type of the socket client.
391 * The sockets created by this object will be of the specified
394 * It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,
395 * as GSocketClient is used for connection oriented services.
400 g_socket_client_set_socket_type (GSocketClient *client,
403 if (client->priv->type == type)
406 client->priv->type = type;
407 g_object_notify (G_OBJECT (client), "type");
411 * g_socket_client_get_protocol:
412 * @client: a #GSocketClient
414 * Gets the protocol name type of the socket client.
416 * See g_socket_client_set_protocol() for details.
418 * Returns: a #GSocketProtocol
423 g_socket_client_get_protocol (GSocketClient *client)
425 return client->priv->protocol;
429 * g_socket_client_set_protocol:
430 * @client: a #GSocketClient.
431 * @protocol: a #GSocketProtocol
433 * Sets the protocol of the socket client.
434 * The sockets created by this object will use of the specified
437 * If @protocol is %0 that means to use the default
438 * protocol for the socket family and type.
443 g_socket_client_set_protocol (GSocketClient *client,
444 GSocketProtocol protocol)
446 if (client->priv->protocol == protocol)
449 client->priv->protocol = protocol;
450 g_object_notify (G_OBJECT (client), "protocol");
454 * g_socket_client_get_local_address:
455 * @client: a #GSocketClient.
457 * Gets the local address of the socket client.
459 * See g_socket_client_set_local_address() for details.
461 * Returns: (transfer none): a #GSocketAddress or %NULL. Do not free.
466 g_socket_client_get_local_address (GSocketClient *client)
468 return client->priv->local_address;
472 * g_socket_client_set_local_address:
473 * @client: a #GSocketClient.
474 * @address: a #GSocketAddress, or %NULL
476 * Sets the local address of the socket client.
477 * The sockets created by this object will bound to the
478 * specified address (if not %NULL) before connecting.
480 * This is useful if you want to ensure that the local
481 * side of the connection is on a specific port, or on
482 * a specific interface.
487 g_socket_client_set_local_address (GSocketClient *client,
488 GSocketAddress *address)
491 g_object_ref (address);
493 if (client->priv->local_address)
495 g_object_unref (client->priv->local_address);
497 client->priv->local_address = address;
498 g_object_notify (G_OBJECT (client), "local-address");
502 * g_socket_client_get_timeout:
503 * @client: a #GSocketClient
505 * Gets the I/O timeout time for sockets created by @client.
507 * See g_socket_client_set_timeout() for details.
509 * Returns: the timeout in seconds
514 g_socket_client_get_timeout (GSocketClient *client)
516 return client->priv->timeout;
521 * g_socket_client_set_timeout:
522 * @client: a #GSocketClient.
523 * @timeout: the timeout
525 * Sets the I/O timeout for sockets created by @client. @timeout is a
526 * time in seconds, or 0 for no timeout (the default).
528 * The timeout value affects the initial connection attempt as well,
529 * so setting this may cause calls to g_socket_client_connect(), etc,
530 * to fail with %G_IO_ERROR_TIMED_OUT.
535 g_socket_client_set_timeout (GSocketClient *client,
538 if (client->priv->timeout == timeout)
541 client->priv->timeout = timeout;
542 g_object_notify (G_OBJECT (client), "timeout");
546 * g_socket_client_get_enable_proxy:
547 * @client: a #GSocketClient.
549 * Gets the proxy enable state; see g_socket_client_set_enable_proxy()
551 * Returns: whether proxying is enabled
556 g_socket_client_get_enable_proxy (GSocketClient *client)
558 return client->priv->enable_proxy;
562 * g_socket_client_set_enable_proxy:
563 * @client: a #GSocketClient.
564 * @enable: whether to enable proxies
566 * Sets whether or not @client attempts to make connections via a
567 * proxy server. When enabled (the default), #GSocketClient will use a
568 * #GProxyResolver to determine if a proxy protocol such as SOCKS is
569 * needed, and automatically do the necessary proxy negotiation.
574 g_socket_client_set_enable_proxy (GSocketClient *client,
578 if (client->priv->enable_proxy == enable)
581 client->priv->enable_proxy = enable;
582 g_object_notify (G_OBJECT (client), "enable-proxy");
586 * g_socket_client_get_tls:
587 * @client: a #GSocketClient.
589 * Gets whether @client creates TLS connections. See
590 * g_socket_client_set_tls() for details.
592 * Returns: whether @client uses TLS
597 g_socket_client_get_tls (GSocketClient *client)
599 return client->priv->tls;
603 * g_socket_client_set_tls:
604 * @client: a #GSocketClient.
605 * @tls: whether to use TLS
607 * Sets whether @client creates TLS (aka SSL) connections. If @tls is
608 * %TRUE, @client will wrap its connections in a #GTlsClientConnection
609 * and perform a TLS handshake when connecting.
611 * Note that since #GSocketClient must return a #GSocketConnection,
612 * but #GTlsClientConnection is not a #GSocketConnection, this
613 * actually wraps the resulting #GTlsClientConnection in a
614 * #GTcpWrapperConnection when returning it. You can use
615 * g_tcp_wrapper_connection_get_base_io_stream() on the return value
616 * to extract the #GTlsClientConnection.
621 g_socket_client_set_tls (GSocketClient *client,
625 if (tls == client->priv->tls)
628 client->priv->tls = tls;
629 g_object_notify (G_OBJECT (client), "tls");
633 * g_socket_client_get_tls_validation_flags:
634 * @client: a #GSocketClient.
636 * Gets the TLS validation flags used creating TLS connections via
639 * Returns: the TLS validation flags
644 g_socket_client_get_tls_validation_flags (GSocketClient *client)
646 return client->priv->tls_validation_flags;
650 * g_socket_client_set_tls_validation_flags:
651 * @client: a #GSocketClient.
652 * @flags: the validation flags
654 * Sets the TLS validation flags used when creating TLS connections
655 * via @client. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
660 g_socket_client_set_tls_validation_flags (GSocketClient *client,
661 GTlsCertificateFlags flags)
663 if (client->priv->tls_validation_flags != flags)
665 client->priv->tls_validation_flags = flags;
666 g_object_notify (G_OBJECT (client), "tls-validation-flags");
671 g_socket_client_class_init (GSocketClientClass *class)
673 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
675 g_type_class_add_private (class, sizeof (GSocketClientPrivate));
677 gobject_class->finalize = g_socket_client_finalize;
678 gobject_class->set_property = g_socket_client_set_property;
679 gobject_class->get_property = g_socket_client_get_property;
681 g_object_class_install_property (gobject_class, PROP_FAMILY,
682 g_param_spec_enum ("family",
684 P_("The sockets address family to use for socket construction"),
685 G_TYPE_SOCKET_FAMILY,
686 G_SOCKET_FAMILY_INVALID,
689 G_PARAM_STATIC_STRINGS));
691 g_object_class_install_property (gobject_class, PROP_TYPE,
692 g_param_spec_enum ("type",
694 P_("The sockets type to use for socket construction"),
696 G_SOCKET_TYPE_STREAM,
699 G_PARAM_STATIC_STRINGS));
701 g_object_class_install_property (gobject_class, PROP_PROTOCOL,
702 g_param_spec_enum ("protocol",
703 P_("Socket protocol"),
704 P_("The protocol to use for socket construction, or 0 for default"),
705 G_TYPE_SOCKET_PROTOCOL,
706 G_SOCKET_PROTOCOL_DEFAULT,
709 G_PARAM_STATIC_STRINGS));
711 g_object_class_install_property (gobject_class, PROP_LOCAL_ADDRESS,
712 g_param_spec_object ("local-address",
714 P_("The local address constructed sockets will be bound to"),
715 G_TYPE_SOCKET_ADDRESS,
718 G_PARAM_STATIC_STRINGS));
720 g_object_class_install_property (gobject_class, PROP_TIMEOUT,
721 g_param_spec_uint ("timeout",
722 P_("Socket timeout"),
723 P_("The I/O timeout for sockets, or 0 for none"),
727 G_PARAM_STATIC_STRINGS));
729 g_object_class_install_property (gobject_class, PROP_ENABLE_PROXY,
730 g_param_spec_boolean ("enable-proxy",
732 P_("Enable proxy support"),
736 G_PARAM_STATIC_STRINGS));
738 g_object_class_install_property (gobject_class, PROP_TLS,
739 g_param_spec_boolean ("tls",
741 P_("Whether to create TLS connections"),
745 G_PARAM_STATIC_STRINGS));
746 g_object_class_install_property (gobject_class, PROP_TLS_VALIDATION_FLAGS,
747 g_param_spec_flags ("tls-validation-flags",
748 P_("TLS validation flags"),
749 P_("TLS validation flags to use"),
750 G_TYPE_TLS_CERTIFICATE_FLAGS,
751 G_TLS_CERTIFICATE_VALIDATE_ALL,
754 G_PARAM_STATIC_STRINGS));
758 * g_socket_client_connect:
759 * @client: a #GSocketClient.
760 * @connectable: a #GSocketConnectable specifying the remote address.
761 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
762 * @error: #GError for error reporting, or %NULL to ignore.
764 * Tries to resolve the @connectable and make a network connection to it.
766 * Upon a successful connection, a new #GSocketConnection is constructed
767 * and returned. The caller owns this new object and must drop their
768 * reference to it when finished with it.
770 * The type of the #GSocketConnection object returned depends on the type of
771 * the underlying socket that is used. For instance, for a TCP/IP connection
772 * it will be a #GTcpConnection.
774 * The socket created will be the same family as the address that the
775 * @connectable resolves to, unless family is set with g_socket_client_set_family()
776 * or indirectly via g_socket_client_set_local_address(). The socket type
777 * defaults to %G_SOCKET_TYPE_STREAM but can be set with
778 * g_socket_client_set_socket_type().
780 * If a local address is specified with g_socket_client_set_local_address() the
781 * socket will be bound to this address before connecting.
783 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
788 g_socket_client_connect (GSocketClient *client,
789 GSocketConnectable *connectable,
790 GCancellable *cancellable,
793 GIOStream *connection = NULL;
794 GSocketAddressEnumerator *enumerator = NULL;
795 GError *last_error, *tmp_error;
799 if (can_use_proxy (client))
800 enumerator = g_socket_connectable_proxy_enumerate (connectable);
802 enumerator = g_socket_connectable_enumerate (connectable);
804 while (connection == NULL)
806 GSocketAddress *address = NULL;
807 gboolean application_proxy = FALSE;
810 if (g_cancellable_is_cancelled (cancellable))
812 g_clear_error (error);
813 g_cancellable_set_error_if_cancelled (cancellable, error);
818 address = g_socket_address_enumerator_next (enumerator, cancellable,
825 g_clear_error (&last_error);
826 g_propagate_error (error, tmp_error);
830 g_propagate_error (error, last_error);
833 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
834 _("Unknown error on connect"));
838 /* clear error from previous attempt */
839 g_clear_error (&last_error);
841 socket = create_socket (client, address, &last_error);
844 g_object_unref (address);
848 if (g_socket_connect (socket, address, cancellable, &last_error))
849 connection = (GIOStream *)g_socket_connection_factory_create_connection (socket);
851 clarify_connect_error (last_error, connectable, address);
854 G_IS_PROXY_ADDRESS (address) &&
855 client->priv->enable_proxy)
857 GProxyAddress *proxy_addr = G_PROXY_ADDRESS (address);
858 const gchar *protocol;
861 protocol = g_proxy_address_get_protocol (proxy_addr);
862 proxy = g_proxy_get_default_for_protocol (protocol);
864 /* The connection should not be anything else then TCP Connection,
865 * but let's put a safety guard in case
867 if (!G_IS_TCP_CONNECTION (connection))
869 g_critical ("Trying to proxy over non-TCP connection, this is "
870 "most likely a bug in GLib IO library.");
872 g_set_error_literal (&last_error,
873 G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
874 _("Trying to proxy over non-TCP connection is not supported."));
876 g_object_unref (connection);
881 GIOStream *proxy_connection;
883 proxy_connection = g_proxy_connect (proxy,
888 g_object_unref (connection);
889 connection = proxy_connection;
890 g_object_unref (proxy);
892 else if (!g_hash_table_lookup_extended (client->priv->app_proxies,
893 protocol, NULL, NULL))
895 g_set_error (&last_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
896 _("Proxy protocol '%s' is not supported."),
898 g_object_unref (connection);
903 application_proxy = TRUE;
907 if (!application_proxy && connection && client->priv->tls)
911 tlsconn = g_tls_client_connection_new (connection, connectable, &last_error);
912 g_object_unref (connection);
913 connection = tlsconn;
917 g_tls_client_connection_set_validation_flags (G_TLS_CLIENT_CONNECTION (tlsconn),
918 client->priv->tls_validation_flags);
919 if (!g_tls_connection_handshake (G_TLS_CONNECTION (tlsconn),
920 cancellable, &last_error))
922 g_object_unref (tlsconn);
928 if (connection && !G_IS_SOCKET_CONNECTION (connection))
930 GSocketConnection *wrapper_connection;
932 wrapper_connection = g_tcp_wrapper_connection_new (connection, socket);
933 g_object_unref (connection);
934 connection = (GIOStream *)wrapper_connection;
937 g_object_unref (socket);
938 g_object_unref (address);
940 g_object_unref (enumerator);
942 return G_SOCKET_CONNECTION (connection);
946 * g_socket_client_connect_to_host:
947 * @client: a #GSocketClient
948 * @host_and_port: the name and optionally port of the host to connect to
949 * @default_port: the default port to connect to
950 * @cancellable: (allow-none): a #GCancellable, or %NULL
951 * @error: a pointer to a #GError, or %NULL
953 * This is a helper function for g_socket_client_connect().
955 * Attempts to create a TCP connection to the named host.
957 * @host_and_port may be in any of a number of recognized formats; an IPv6
958 * address, an IPv4 address, or a domain name (in which case a DNS
959 * lookup is performed). Quoting with [] is supported for all address
960 * types. A port override may be specified in the usual way with a
961 * colon. Ports may be given as decimal numbers or symbolic names (in
962 * which case an /etc/services lookup is performed).
964 * If no port override is given in @host_and_port then @default_port will be
965 * used as the port number to connect to.
967 * In general, @host_and_port is expected to be provided by the user (allowing
968 * them to give the hostname, and a port override if necessary) and
969 * @default_port is expected to be provided by the application.
971 * In the case that an IP address is given, a single connection
972 * attempt is made. In the case that a name is given, multiple
973 * connection attempts may be made, in turn and according to the
974 * number of address records in DNS, until a connection succeeds.
976 * Upon a successful connection, a new #GSocketConnection is constructed
977 * and returned. The caller owns this new object and must drop their
978 * reference to it when finished with it.
980 * In the event of any failure (DNS error, service not found, no hosts
981 * connectable) %NULL is returned and @error (if non-%NULL) is set
984 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
989 g_socket_client_connect_to_host (GSocketClient *client,
990 const gchar *host_and_port,
991 guint16 default_port,
992 GCancellable *cancellable,
995 GSocketConnectable *connectable;
996 GSocketConnection *connection;
998 connectable = g_network_address_parse (host_and_port, default_port, error);
999 if (connectable == NULL)
1002 connection = g_socket_client_connect (client, connectable,
1003 cancellable, error);
1004 g_object_unref (connectable);
1010 * g_socket_client_connect_to_service:
1011 * @client: a #GSocketConnection
1012 * @domain: a domain name
1013 * @service: the name of the service to connect to
1014 * @cancellable: (allow-none): a #GCancellable, or %NULL
1015 * @error: a pointer to a #GError, or %NULL
1017 * Attempts to create a TCP connection to a service.
1019 * This call looks up the SRV record for @service at @domain for the
1020 * "tcp" protocol. It then attempts to connect, in turn, to each of
1021 * the hosts providing the service until either a connection succeeds
1022 * or there are no hosts remaining.
1024 * Upon a successful connection, a new #GSocketConnection is constructed
1025 * and returned. The caller owns this new object and must drop their
1026 * reference to it when finished with it.
1028 * In the event of any failure (DNS error, service not found, no hosts
1029 * connectable) %NULL is returned and @error (if non-%NULL) is set
1032 * Returns: (transfer full): a #GSocketConnection if successful, or %NULL on error
1035 g_socket_client_connect_to_service (GSocketClient *client,
1036 const gchar *domain,
1037 const gchar *service,
1038 GCancellable *cancellable,
1041 GSocketConnectable *connectable;
1042 GSocketConnection *connection;
1044 connectable = g_network_service_new (service, "tcp", domain);
1045 connection = g_socket_client_connect (client, connectable,
1046 cancellable, error);
1047 g_object_unref (connectable);
1053 * g_socket_client_connect_to_uri:
1054 * @client: a #GSocketClient
1055 * @uri: A network URI
1056 * @default_port: the default port to connect to
1057 * @cancellable: (allow-none): a #GCancellable, or %NULL
1058 * @error: a pointer to a #GError, or %NULL
1060 * This is a helper function for g_socket_client_connect().
1062 * Attempts to create a TCP connection with a network URI.
1064 * @uri may be any valid URI containing an "authority" (hostname/port)
1065 * component. If a port is not specified in the URI, @default_port
1066 * will be used. TLS will be negotiated if #GSocketClient:tls is %TRUE.
1067 * (#GSocketClient does not know to automatically assume TLS for
1068 * certain URI schemes.)
1070 * Using this rather than g_socket_client_connect() or
1071 * g_socket_client_connect_to_host() allows #GSocketClient to
1072 * determine when to use application-specific proxy protocols.
1074 * Upon a successful connection, a new #GSocketConnection is constructed
1075 * and returned. The caller owns this new object and must drop their
1076 * reference to it when finished with it.
1078 * In the event of any failure (DNS error, service not found, no hosts
1079 * connectable) %NULL is returned and @error (if non-%NULL) is set
1082 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1087 g_socket_client_connect_to_uri (GSocketClient *client,
1089 guint16 default_port,
1090 GCancellable *cancellable,
1093 GSocketConnectable *connectable;
1094 GSocketConnection *connection;
1096 connectable = g_network_address_parse_uri (uri, default_port, error);
1097 if (connectable == NULL)
1100 connection = g_socket_client_connect (client, connectable,
1101 cancellable, error);
1102 g_object_unref (connectable);
1109 GSimpleAsyncResult *result;
1110 GCancellable *cancellable;
1111 GSocketClient *client;
1113 GSocketConnectable *connectable;
1114 GSocketAddressEnumerator *enumerator;
1115 GProxyAddress *proxy_addr;
1116 GSocketAddress *current_addr;
1117 GSocket *current_socket;
1118 GIOStream *connection;
1121 } GSocketClientAsyncConnectData;
1124 g_socket_client_async_connect_complete (GSocketClientAsyncConnectData *data)
1126 if (data->last_error)
1128 g_simple_async_result_take_error (data->result, data->last_error);
1132 g_assert (data->connection);
1134 if (!G_IS_SOCKET_CONNECTION (data->connection))
1136 GSocketConnection *wrapper_connection;
1138 wrapper_connection = g_tcp_wrapper_connection_new (data->connection,
1139 data->current_socket);
1140 g_object_unref (data->connection);
1141 data->connection = (GIOStream *)wrapper_connection;
1144 g_simple_async_result_set_op_res_gpointer (data->result,
1149 g_simple_async_result_complete (data->result);
1150 g_object_unref (data->result);
1151 g_object_unref (data->connectable);
1152 g_object_unref (data->enumerator);
1153 if (data->cancellable)
1154 g_object_unref (data->cancellable);
1155 if (data->current_addr)
1156 g_object_unref (data->current_addr);
1157 if (data->current_socket)
1158 g_object_unref (data->current_socket);
1159 if (data->proxy_addr)
1160 g_object_unref (data->proxy_addr);
1161 g_slice_free (GSocketClientAsyncConnectData, data);
1166 g_socket_client_enumerator_callback (GObject *object,
1167 GAsyncResult *result,
1168 gpointer user_data);
1171 set_last_error (GSocketClientAsyncConnectData *data,
1174 g_clear_error (&data->last_error);
1175 data->last_error = error;
1179 enumerator_next_async (GSocketClientAsyncConnectData *data)
1181 /* We need to cleanup the state */
1182 g_clear_object (&data->current_socket);
1183 g_clear_object (&data->current_addr);
1184 g_clear_object (&data->proxy_addr);
1185 g_clear_object (&data->connection);
1187 g_socket_address_enumerator_next_async (data->enumerator,
1189 g_socket_client_enumerator_callback,
1194 g_socket_client_tls_handshake_callback (GObject *object,
1195 GAsyncResult *result,
1198 GSocketClientAsyncConnectData *data = user_data;
1200 if (g_tls_connection_handshake_finish (G_TLS_CONNECTION (object),
1204 g_object_unref (data->connection);
1205 data->connection = G_IO_STREAM (object);
1207 g_socket_client_async_connect_complete (data);
1211 g_object_unref (object);
1212 enumerator_next_async (data);
1217 g_socket_client_tls_handshake (GSocketClientAsyncConnectData *data)
1221 if (!data->client->priv->tls)
1223 g_socket_client_async_connect_complete (data);
1227 tlsconn = g_tls_client_connection_new (data->connection,
1232 g_tls_client_connection_set_validation_flags (G_TLS_CLIENT_CONNECTION (tlsconn),
1233 data->client->priv->tls_validation_flags);
1234 g_tls_connection_handshake_async (G_TLS_CONNECTION (tlsconn),
1237 g_socket_client_tls_handshake_callback,
1242 enumerator_next_async (data);
1247 g_socket_client_proxy_connect_callback (GObject *object,
1248 GAsyncResult *result,
1251 GSocketClientAsyncConnectData *data = user_data;
1253 g_object_unref (data->connection);
1254 data->connection = g_proxy_connect_finish (G_PROXY (object),
1257 if (!data->connection)
1259 enumerator_next_async (data);
1263 g_socket_client_tls_handshake (data);
1267 g_socket_client_proxy_connect (GSocketClientAsyncConnectData *data)
1270 const gchar *protocol;
1272 if (!data->proxy_addr)
1274 g_socket_client_tls_handshake (data);
1278 protocol = g_proxy_address_get_protocol (data->proxy_addr);
1279 proxy = g_proxy_get_default_for_protocol (protocol);
1281 /* The connection should not be anything else then TCP Connection,
1282 * but let's put a safety guard in case
1284 if (!G_IS_TCP_CONNECTION (data->connection))
1286 g_critical ("Trying to proxy over non-TCP connection, this is "
1287 "most likely a bug in GLib IO library.");
1289 g_set_error_literal (&data->last_error,
1290 G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
1291 _("Trying to proxy over non-TCP connection is not supported."));
1293 enumerator_next_async (data);
1297 g_proxy_connect_async (proxy,
1301 g_socket_client_proxy_connect_callback,
1303 g_object_unref (proxy);
1305 else if (!g_hash_table_lookup_extended (data->client->priv->app_proxies,
1306 protocol, NULL, NULL))
1308 g_clear_error (&data->last_error);
1310 g_set_error (&data->last_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
1311 _("Proxy protocol '%s' is not supported."),
1314 enumerator_next_async (data);
1318 /* Simply complete the connection, we don't want to do TLS handshake
1319 * as the application proxy handling may need proxy handshake first */
1320 g_socket_client_async_connect_complete (data);
1325 g_socket_client_socket_connected (GSocketClientAsyncConnectData *data)
1327 g_socket_set_blocking (data->current_socket, TRUE);
1329 data->connection = (GIOStream *)
1330 g_socket_connection_factory_create_connection (data->current_socket);
1332 g_socket_client_proxy_connect (data);
1336 g_socket_client_socket_callback (GSocket *socket,
1337 GIOCondition condition,
1338 GSocketClientAsyncConnectData *data)
1340 GError *error = NULL;
1342 if (g_cancellable_is_cancelled (data->cancellable))
1344 /* Cancelled, return done with last error being cancelled */
1345 g_clear_error (&data->last_error);
1346 g_cancellable_set_error_if_cancelled (data->cancellable,
1349 g_socket_client_async_connect_complete (data);
1354 /* socket is ready for writing means connect done, did it succeed? */
1355 if (!g_socket_check_connect_result (data->current_socket, &error))
1357 clarify_connect_error (error, data->connectable,
1358 data->current_addr);
1359 set_last_error (data, error);
1362 enumerator_next_async (data);
1368 g_socket_client_socket_connected (data);
1373 g_socket_client_enumerator_callback (GObject *object,
1374 GAsyncResult *result,
1377 GSocketClientAsyncConnectData *data = user_data;
1378 GSocketAddress *address = NULL;
1380 GError *tmp_error = NULL;
1382 if (g_cancellable_is_cancelled (data->cancellable))
1384 g_clear_error (&data->last_error);
1385 g_cancellable_set_error_if_cancelled (data->cancellable, &data->last_error);
1386 g_socket_client_async_connect_complete (data);
1390 address = g_socket_address_enumerator_next_finish (data->enumerator,
1391 result, &tmp_error);
1393 if (address == NULL)
1396 set_last_error (data, tmp_error);
1397 else if (data->last_error == NULL)
1398 g_set_error_literal (&data->last_error, G_IO_ERROR, G_IO_ERROR_FAILED,
1399 _("Unknown error on connect"));
1401 g_socket_client_async_connect_complete (data);
1405 if (G_IS_PROXY_ADDRESS (address) &&
1406 data->client->priv->enable_proxy)
1407 data->proxy_addr = g_object_ref (G_PROXY_ADDRESS (address));
1409 g_clear_error (&data->last_error);
1411 socket = create_socket (data->client, address, &data->last_error);
1414 g_socket_set_blocking (socket, FALSE);
1415 if (g_socket_connect (socket, address, data->cancellable, &tmp_error))
1417 data->current_socket = socket;
1418 g_socket_client_socket_connected (data);
1420 g_object_unref (address);
1423 else if (g_error_matches (tmp_error, G_IO_ERROR, G_IO_ERROR_PENDING))
1427 data->current_socket = socket;
1428 data->current_addr = address;
1429 g_error_free (tmp_error);
1431 source = g_socket_create_source (socket, G_IO_OUT,
1433 g_source_set_callback (source,
1434 (GSourceFunc) g_socket_client_socket_callback,
1436 g_source_attach (source, g_main_context_get_thread_default ());
1437 g_source_unref (source);
1442 clarify_connect_error (tmp_error, data->connectable, address);
1443 data->last_error = tmp_error;
1444 g_object_unref (socket);
1448 g_object_unref (address);
1449 enumerator_next_async (data);
1453 * g_socket_client_connect_async:
1454 * @client: a #GSocketClient
1455 * @connectable: a #GSocketConnectable specifying the remote address.
1456 * @cancellable: (allow-none): a #GCancellable, or %NULL
1457 * @callback: (scope async): a #GAsyncReadyCallback
1458 * @user_data: (closure): user data for the callback
1460 * This is the asynchronous version of g_socket_client_connect().
1462 * When the operation is finished @callback will be
1463 * called. You can then call g_socket_client_connect_finish() to get
1464 * the result of the operation.
1469 g_socket_client_connect_async (GSocketClient *client,
1470 GSocketConnectable *connectable,
1471 GCancellable *cancellable,
1472 GAsyncReadyCallback callback,
1475 GSocketClientAsyncConnectData *data;
1477 g_return_if_fail (G_IS_SOCKET_CLIENT (client));
1479 data = g_slice_new0 (GSocketClientAsyncConnectData);
1481 data->result = g_simple_async_result_new (G_OBJECT (client),
1482 callback, user_data,
1483 g_socket_client_connect_async);
1484 data->client = client;
1486 data->cancellable = g_object_ref (cancellable);
1488 data->cancellable = NULL;
1489 data->last_error = NULL;
1490 data->connectable = g_object_ref (connectable);
1492 if (can_use_proxy (client))
1493 data->enumerator = g_socket_connectable_proxy_enumerate (connectable);
1495 data->enumerator = g_socket_connectable_enumerate (connectable);
1497 enumerator_next_async (data);
1501 * g_socket_client_connect_to_host_async:
1502 * @client: a #GSocketClient
1503 * @host_and_port: the name and optionally the port of the host to connect to
1504 * @default_port: the default port to connect to
1505 * @cancellable: (allow-none): a #GCancellable, or %NULL
1506 * @callback: (scope async): a #GAsyncReadyCallback
1507 * @user_data: (closure): user data for the callback
1509 * This is the asynchronous version of g_socket_client_connect_to_host().
1511 * When the operation is finished @callback will be
1512 * called. You can then call g_socket_client_connect_to_host_finish() to get
1513 * the result of the operation.
1518 g_socket_client_connect_to_host_async (GSocketClient *client,
1519 const gchar *host_and_port,
1520 guint16 default_port,
1521 GCancellable *cancellable,
1522 GAsyncReadyCallback callback,
1525 GSocketConnectable *connectable;
1529 connectable = g_network_address_parse (host_and_port, default_port,
1531 if (connectable == NULL)
1533 g_simple_async_report_take_gerror_in_idle (G_OBJECT (client),
1534 callback, user_data, error);
1538 g_socket_client_connect_async (client,
1539 connectable, cancellable,
1540 callback, user_data);
1541 g_object_unref (connectable);
1546 * g_socket_client_connect_to_service_async:
1547 * @client: a #GSocketClient
1548 * @domain: a domain name
1549 * @service: the name of the service to connect to
1550 * @cancellable: (allow-none): a #GCancellable, or %NULL
1551 * @callback: (scope async): a #GAsyncReadyCallback
1552 * @user_data: (closure): user data for the callback
1554 * This is the asynchronous version of
1555 * g_socket_client_connect_to_service().
1560 g_socket_client_connect_to_service_async (GSocketClient *client,
1561 const gchar *domain,
1562 const gchar *service,
1563 GCancellable *cancellable,
1564 GAsyncReadyCallback callback,
1567 GSocketConnectable *connectable;
1569 connectable = g_network_service_new (service, "tcp", domain);
1570 g_socket_client_connect_async (client,
1571 connectable, cancellable,
1572 callback, user_data);
1573 g_object_unref (connectable);
1577 * g_socket_client_connect_to_uri_async:
1578 * @client: a #GSocketClient
1579 * @uri: a network uri
1580 * @default_port: the default port to connect to
1581 * @cancellable: (allow-none): a #GCancellable, or %NULL
1582 * @callback: (scope async): a #GAsyncReadyCallback
1583 * @user_data: (closure): user data for the callback
1585 * This is the asynchronous version of g_socket_client_connect_to_uri().
1587 * When the operation is finished @callback will be
1588 * called. You can then call g_socket_client_connect_to_uri_finish() to get
1589 * the result of the operation.
1594 g_socket_client_connect_to_uri_async (GSocketClient *client,
1596 guint16 default_port,
1597 GCancellable *cancellable,
1598 GAsyncReadyCallback callback,
1601 GSocketConnectable *connectable;
1605 connectable = g_network_address_parse_uri (uri, default_port, &error);
1606 if (connectable == NULL)
1608 g_simple_async_report_take_gerror_in_idle (G_OBJECT (client),
1609 callback, user_data, error);
1613 g_socket_client_connect_async (client,
1614 connectable, cancellable,
1615 callback, user_data);
1616 g_object_unref (connectable);
1622 * g_socket_client_connect_finish:
1623 * @client: a #GSocketClient.
1624 * @result: a #GAsyncResult.
1625 * @error: a #GError location to store the error occurring, or %NULL to
1628 * Finishes an async connect operation. See g_socket_client_connect_async()
1630 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1635 g_socket_client_connect_finish (GSocketClient *client,
1636 GAsyncResult *result,
1639 GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
1641 if (g_simple_async_result_propagate_error (simple, error))
1644 return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
1648 * g_socket_client_connect_to_host_finish:
1649 * @client: a #GSocketClient.
1650 * @result: a #GAsyncResult.
1651 * @error: a #GError location to store the error occurring, or %NULL to
1654 * Finishes an async connect operation. See g_socket_client_connect_to_host_async()
1656 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1661 g_socket_client_connect_to_host_finish (GSocketClient *client,
1662 GAsyncResult *result,
1665 return g_socket_client_connect_finish (client, result, error);
1669 * g_socket_client_connect_to_service_finish:
1670 * @client: a #GSocketClient.
1671 * @result: a #GAsyncResult.
1672 * @error: a #GError location to store the error occurring, or %NULL to
1675 * Finishes an async connect operation. See g_socket_client_connect_to_service_async()
1677 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1682 g_socket_client_connect_to_service_finish (GSocketClient *client,
1683 GAsyncResult *result,
1686 return g_socket_client_connect_finish (client, result, error);
1690 * g_socket_client_connect_to_uri_finish:
1691 * @client: a #GSocketClient.
1692 * @result: a #GAsyncResult.
1693 * @error: a #GError location to store the error occurring, or %NULL to
1696 * Finishes an async connect operation. See g_socket_client_connect_to_uri_async()
1698 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1703 g_socket_client_connect_to_uri_finish (GSocketClient *client,
1704 GAsyncResult *result,
1707 return g_socket_client_connect_finish (client, result, error);
1711 * g_socket_client_add_application_proxy:
1712 * @client: a #GSocketClient
1713 * @protocol: The proxy protocol
1715 * Enable proxy protocols to be handled by the application. When the
1716 * indicated proxy protocol is returned by the #GProxyResolver,
1717 * #GSocketClient will consider this protocol as supported but will
1718 * not try to find a #GProxy instance to handle handshaking. The
1719 * application must check for this case by calling
1720 * g_socket_connection_get_remote_address() on the returned
1721 * #GSocketConnection, and seeing if it's a #GProxyAddress of the
1722 * appropriate type, to determine whether or not it needs to handle
1723 * the proxy handshaking itself.
1725 * This should be used for proxy protocols that are dialects of
1726 * another protocol such as HTTP proxy. It also allows cohabitation of
1727 * proxy protocols that are reused between protocols. A good example
1728 * is HTTP. It can be used to proxy HTTP, FTP and Gopher and can also
1729 * be use as generic socket proxy through the HTTP CONNECT method.
1731 * When the proxy is detected as being an application proxy, TLS handshake
1732 * will be skipped. This is required to let the application do the proxy
1733 * specific handshake.
1736 g_socket_client_add_application_proxy (GSocketClient *client,
1737 const gchar *protocol)
1739 g_hash_table_insert (client->priv->app_proxies, g_strdup (protocol), NULL);