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, see <http://www.gnu.org/licenses/>.
19 * Authors: Ryan Lortie <desrt@desrt.ca>
20 * Alexander Larsson <alexl@redhat.com>
24 #include "gsocketclient.h"
29 #include <gio/gioenumtypes.h>
30 #include <gio/gsocketaddressenumerator.h>
31 #include <gio/gsocketconnectable.h>
32 #include <gio/gsocketconnection.h>
33 #include <gio/gioprivate.h>
34 #include <gio/gproxyaddressenumerator.h>
35 #include <gio/gproxyaddress.h>
36 #include <gio/gtask.h>
37 #include <gio/gcancellable.h>
38 #include <gio/gioerror.h>
39 #include <gio/gsocket.h>
40 #include <gio/gnetworkaddress.h>
41 #include <gio/gnetworkservice.h>
42 #include <gio/gproxy.h>
43 #include <gio/gproxyresolver.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 lightweight high-level utility class for connecting to
60 * a 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.
70 * As #GSocketClient is a lightweight object, you don't need to cache it. You
71 * can just create a new one any time you need one.
83 static guint signals
[LAST_SIGNAL
] = { 0 };
95 PROP_TLS_VALIDATION_FLAGS
,
99 struct _GSocketClientPrivate
101 GSocketFamily family
;
103 GSocketProtocol protocol
;
104 GSocketAddress
*local_address
;
106 gboolean enable_proxy
;
107 GHashTable
*app_proxies
;
109 GTlsCertificateFlags tls_validation_flags
;
110 GProxyResolver
*proxy_resolver
;
113 G_DEFINE_TYPE_WITH_PRIVATE (GSocketClient
, g_socket_client
, G_TYPE_OBJECT
)
116 create_socket (GSocketClient
*client
,
117 GSocketAddress
*dest_address
,
120 GSocketFamily family
;
123 family
= client
->priv
->family
;
124 if (family
== G_SOCKET_FAMILY_INVALID
&&
125 client
->priv
->local_address
!= NULL
)
126 family
= g_socket_address_get_family (client
->priv
->local_address
);
127 if (family
== G_SOCKET_FAMILY_INVALID
)
128 family
= g_socket_address_get_family (dest_address
);
130 socket
= g_socket_new (family
,
132 client
->priv
->protocol
,
137 if (client
->priv
->local_address
)
139 if (!g_socket_bind (socket
,
140 client
->priv
->local_address
,
144 g_object_unref (socket
);
149 if (client
->priv
->timeout
)
150 g_socket_set_timeout (socket
, client
->priv
->timeout
);
156 can_use_proxy (GSocketClient
*client
)
158 GSocketClientPrivate
*priv
= client
->priv
;
160 return priv
->enable_proxy
161 && priv
->type
== G_SOCKET_TYPE_STREAM
;
165 clarify_connect_error (GError
*error
,
166 GSocketConnectable
*connectable
,
167 GSocketAddress
*address
)
170 char *tmp_name
= NULL
;
172 if (G_IS_PROXY_ADDRESS (address
))
174 name
= tmp_name
= g_inet_address_to_string (g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (address
)));
176 g_prefix_error (&error
, _("Could not connect to proxy server %s: "), name
);
180 if (G_IS_NETWORK_ADDRESS (connectable
))
181 name
= g_network_address_get_hostname (G_NETWORK_ADDRESS (connectable
));
182 else if (G_IS_NETWORK_SERVICE (connectable
))
183 name
= g_network_service_get_domain (G_NETWORK_SERVICE (connectable
));
184 else if (G_IS_INET_SOCKET_ADDRESS (connectable
))
185 name
= tmp_name
= g_inet_address_to_string (g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (connectable
)));
190 g_prefix_error (&error
, _("Could not connect to %s: "), name
);
192 g_prefix_error (&error
, _("Could not connect: "));
199 g_socket_client_init (GSocketClient
*client
)
201 client
->priv
= g_socket_client_get_instance_private (client
);
202 client
->priv
->type
= G_SOCKET_TYPE_STREAM
;
203 client
->priv
->app_proxies
= g_hash_table_new_full (g_str_hash
,
210 * g_socket_client_new:
212 * Creates a new #GSocketClient with the default options.
214 * Returns: a #GSocketClient.
215 * Free the returned object with g_object_unref().
220 g_socket_client_new (void)
222 return g_object_new (G_TYPE_SOCKET_CLIENT
, NULL
);
226 g_socket_client_finalize (GObject
*object
)
228 GSocketClient
*client
= G_SOCKET_CLIENT (object
);
230 g_clear_object (&client
->priv
->local_address
);
231 g_clear_object (&client
->priv
->proxy_resolver
);
233 G_OBJECT_CLASS (g_socket_client_parent_class
)->finalize (object
);
235 g_hash_table_unref (client
->priv
->app_proxies
);
239 g_socket_client_get_property (GObject
*object
,
244 GSocketClient
*client
= G_SOCKET_CLIENT (object
);
249 g_value_set_enum (value
, client
->priv
->family
);
253 g_value_set_enum (value
, client
->priv
->type
);
257 g_value_set_enum (value
, client
->priv
->protocol
);
260 case PROP_LOCAL_ADDRESS
:
261 g_value_set_object (value
, client
->priv
->local_address
);
265 g_value_set_uint (value
, client
->priv
->timeout
);
268 case PROP_ENABLE_PROXY
:
269 g_value_set_boolean (value
, client
->priv
->enable_proxy
);
273 g_value_set_boolean (value
, g_socket_client_get_tls (client
));
276 case PROP_TLS_VALIDATION_FLAGS
:
277 g_value_set_flags (value
, g_socket_client_get_tls_validation_flags (client
));
280 case PROP_PROXY_RESOLVER
:
281 g_value_set_object (value
, g_socket_client_get_proxy_resolver (client
));
285 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
290 g_socket_client_set_property (GObject
*object
,
295 GSocketClient
*client
= G_SOCKET_CLIENT (object
);
300 g_socket_client_set_family (client
, g_value_get_enum (value
));
304 g_socket_client_set_socket_type (client
, g_value_get_enum (value
));
308 g_socket_client_set_protocol (client
, g_value_get_enum (value
));
311 case PROP_LOCAL_ADDRESS
:
312 g_socket_client_set_local_address (client
, g_value_get_object (value
));
316 g_socket_client_set_timeout (client
, g_value_get_uint (value
));
319 case PROP_ENABLE_PROXY
:
320 g_socket_client_set_enable_proxy (client
, g_value_get_boolean (value
));
324 g_socket_client_set_tls (client
, g_value_get_boolean (value
));
327 case PROP_TLS_VALIDATION_FLAGS
:
328 g_socket_client_set_tls_validation_flags (client
, g_value_get_flags (value
));
331 case PROP_PROXY_RESOLVER
:
332 g_socket_client_set_proxy_resolver (client
, g_value_get_object (value
));
336 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
341 * g_socket_client_get_family:
342 * @client: a #GSocketClient.
344 * Gets the socket family of the socket client.
346 * See g_socket_client_set_family() for details.
348 * Returns: a #GSocketFamily
353 g_socket_client_get_family (GSocketClient
*client
)
355 return client
->priv
->family
;
359 * g_socket_client_set_family:
360 * @client: a #GSocketClient.
361 * @family: a #GSocketFamily
363 * Sets the socket family of the socket client.
364 * If this is set to something other than %G_SOCKET_FAMILY_INVALID
365 * then the sockets created by this object will be of the specified
368 * This might be useful for instance if you want to force the local
369 * connection to be an ipv4 socket, even though the address might
370 * be an ipv6 mapped to ipv4 address.
375 g_socket_client_set_family (GSocketClient
*client
,
376 GSocketFamily family
)
378 if (client
->priv
->family
== family
)
381 client
->priv
->family
= family
;
382 g_object_notify (G_OBJECT (client
), "family");
386 * g_socket_client_get_socket_type:
387 * @client: a #GSocketClient.
389 * Gets the socket type of the socket client.
391 * See g_socket_client_set_socket_type() for details.
393 * Returns: a #GSocketFamily
398 g_socket_client_get_socket_type (GSocketClient
*client
)
400 return client
->priv
->type
;
404 * g_socket_client_set_socket_type:
405 * @client: a #GSocketClient.
406 * @type: a #GSocketType
408 * Sets the socket type of the socket client.
409 * The sockets created by this object will be of the specified
412 * It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,
413 * as GSocketClient is used for connection oriented services.
418 g_socket_client_set_socket_type (GSocketClient
*client
,
421 if (client
->priv
->type
== type
)
424 client
->priv
->type
= type
;
425 g_object_notify (G_OBJECT (client
), "type");
429 * g_socket_client_get_protocol:
430 * @client: a #GSocketClient
432 * Gets the protocol name type of the socket client.
434 * See g_socket_client_set_protocol() for details.
436 * Returns: a #GSocketProtocol
441 g_socket_client_get_protocol (GSocketClient
*client
)
443 return client
->priv
->protocol
;
447 * g_socket_client_set_protocol:
448 * @client: a #GSocketClient.
449 * @protocol: a #GSocketProtocol
451 * Sets the protocol of the socket client.
452 * The sockets created by this object will use of the specified
455 * If @protocol is %0 that means to use the default
456 * protocol for the socket family and type.
461 g_socket_client_set_protocol (GSocketClient
*client
,
462 GSocketProtocol protocol
)
464 if (client
->priv
->protocol
== protocol
)
467 client
->priv
->protocol
= protocol
;
468 g_object_notify (G_OBJECT (client
), "protocol");
472 * g_socket_client_get_local_address:
473 * @client: a #GSocketClient.
475 * Gets the local address of the socket client.
477 * See g_socket_client_set_local_address() for details.
479 * Returns: (transfer none): a #GSocketAddress or %NULL. Do not free.
484 g_socket_client_get_local_address (GSocketClient
*client
)
486 return client
->priv
->local_address
;
490 * g_socket_client_set_local_address:
491 * @client: a #GSocketClient.
492 * @address: (allow-none): a #GSocketAddress, or %NULL
494 * Sets the local address of the socket client.
495 * The sockets created by this object will bound to the
496 * specified address (if not %NULL) before connecting.
498 * This is useful if you want to ensure that the local
499 * side of the connection is on a specific port, or on
500 * a specific interface.
505 g_socket_client_set_local_address (GSocketClient
*client
,
506 GSocketAddress
*address
)
509 g_object_ref (address
);
511 if (client
->priv
->local_address
)
513 g_object_unref (client
->priv
->local_address
);
515 client
->priv
->local_address
= address
;
516 g_object_notify (G_OBJECT (client
), "local-address");
520 * g_socket_client_get_timeout:
521 * @client: a #GSocketClient
523 * Gets the I/O timeout time for sockets created by @client.
525 * See g_socket_client_set_timeout() for details.
527 * Returns: the timeout in seconds
532 g_socket_client_get_timeout (GSocketClient
*client
)
534 return client
->priv
->timeout
;
539 * g_socket_client_set_timeout:
540 * @client: a #GSocketClient.
541 * @timeout: the timeout
543 * Sets the I/O timeout for sockets created by @client. @timeout is a
544 * time in seconds, or 0 for no timeout (the default).
546 * The timeout value affects the initial connection attempt as well,
547 * so setting this may cause calls to g_socket_client_connect(), etc,
548 * to fail with %G_IO_ERROR_TIMED_OUT.
553 g_socket_client_set_timeout (GSocketClient
*client
,
556 if (client
->priv
->timeout
== timeout
)
559 client
->priv
->timeout
= timeout
;
560 g_object_notify (G_OBJECT (client
), "timeout");
564 * g_socket_client_get_enable_proxy:
565 * @client: a #GSocketClient.
567 * Gets the proxy enable state; see g_socket_client_set_enable_proxy()
569 * Returns: whether proxying is enabled
574 g_socket_client_get_enable_proxy (GSocketClient
*client
)
576 return client
->priv
->enable_proxy
;
580 * g_socket_client_set_enable_proxy:
581 * @client: a #GSocketClient.
582 * @enable: whether to enable proxies
584 * Sets whether or not @client attempts to make connections via a
585 * proxy server. When enabled (the default), #GSocketClient will use a
586 * #GProxyResolver to determine if a proxy protocol such as SOCKS is
587 * needed, and automatically do the necessary proxy negotiation.
589 * See also g_socket_client_set_proxy_resolver().
594 g_socket_client_set_enable_proxy (GSocketClient
*client
,
598 if (client
->priv
->enable_proxy
== enable
)
601 client
->priv
->enable_proxy
= enable
;
602 g_object_notify (G_OBJECT (client
), "enable-proxy");
606 * g_socket_client_get_tls:
607 * @client: a #GSocketClient.
609 * Gets whether @client creates TLS connections. See
610 * g_socket_client_set_tls() for details.
612 * Returns: whether @client uses TLS
617 g_socket_client_get_tls (GSocketClient
*client
)
619 return client
->priv
->tls
;
623 * g_socket_client_set_tls:
624 * @client: a #GSocketClient.
625 * @tls: whether to use TLS
627 * Sets whether @client creates TLS (aka SSL) connections. If @tls is
628 * %TRUE, @client will wrap its connections in a #GTlsClientConnection
629 * and perform a TLS handshake when connecting.
631 * Note that since #GSocketClient must return a #GSocketConnection,
632 * but #GTlsClientConnection is not a #GSocketConnection, this
633 * actually wraps the resulting #GTlsClientConnection in a
634 * #GTcpWrapperConnection when returning it. You can use
635 * g_tcp_wrapper_connection_get_base_io_stream() on the return value
636 * to extract the #GTlsClientConnection.
638 * If you need to modify the behavior of the TLS handshake (eg, by
639 * setting a client-side certificate to use, or connecting to the
640 * #GTlsConnection::accept-certificate signal), you can connect to
641 * @client's #GSocketClient::event signal and wait for it to be
642 * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, which will give you
643 * a chance to see the #GTlsClientConnection before the handshake
649 g_socket_client_set_tls (GSocketClient
*client
,
653 if (tls
== client
->priv
->tls
)
656 client
->priv
->tls
= tls
;
657 g_object_notify (G_OBJECT (client
), "tls");
661 * g_socket_client_get_tls_validation_flags:
662 * @client: a #GSocketClient.
664 * Gets the TLS validation flags used creating TLS connections via
667 * Returns: the TLS validation flags
672 g_socket_client_get_tls_validation_flags (GSocketClient
*client
)
674 return client
->priv
->tls_validation_flags
;
678 * g_socket_client_set_tls_validation_flags:
679 * @client: a #GSocketClient.
680 * @flags: the validation flags
682 * Sets the TLS validation flags used when creating TLS connections
683 * via @client. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
688 g_socket_client_set_tls_validation_flags (GSocketClient
*client
,
689 GTlsCertificateFlags flags
)
691 if (client
->priv
->tls_validation_flags
!= flags
)
693 client
->priv
->tls_validation_flags
= flags
;
694 g_object_notify (G_OBJECT (client
), "tls-validation-flags");
699 * g_socket_client_get_proxy_resolver:
700 * @client: a #GSocketClient.
702 * Gets the #GProxyResolver being used by @client. Normally, this will
703 * be the resolver returned by g_proxy_resolver_get_default(), but you
704 * can override it with g_socket_client_set_proxy_resolver().
706 * Returns: (transfer none): The #GProxyResolver being used by
712 g_socket_client_get_proxy_resolver (GSocketClient
*client
)
714 if (client
->priv
->proxy_resolver
)
715 return client
->priv
->proxy_resolver
;
717 return g_proxy_resolver_get_default ();
721 * g_socket_client_set_proxy_resolver:
722 * @client: a #GSocketClient.
723 * @proxy_resolver: (allow-none): a #GProxyResolver, or %NULL for the
726 * Overrides the #GProxyResolver used by @client. You can call this if
727 * you want to use specific proxies, rather than using the system
728 * default proxy settings.
730 * Note that whether or not the proxy resolver is actually used
731 * depends on the setting of #GSocketClient:enable-proxy, which is not
732 * changed by this function (but which is %TRUE by default)
737 g_socket_client_set_proxy_resolver (GSocketClient
*client
,
738 GProxyResolver
*proxy_resolver
)
740 /* We have to be careful to avoid calling
741 * g_proxy_resolver_get_default() until we're sure we need it,
742 * because trying to load the default proxy resolver module will
743 * break some test programs that aren't expecting it (eg,
747 if (client
->priv
->proxy_resolver
)
748 g_object_unref (client
->priv
->proxy_resolver
);
750 client
->priv
->proxy_resolver
= proxy_resolver
;
752 if (client
->priv
->proxy_resolver
)
753 g_object_ref (client
->priv
->proxy_resolver
);
757 g_socket_client_class_init (GSocketClientClass
*class)
759 GObjectClass
*gobject_class
= G_OBJECT_CLASS (class);
761 gobject_class
->finalize
= g_socket_client_finalize
;
762 gobject_class
->set_property
= g_socket_client_set_property
;
763 gobject_class
->get_property
= g_socket_client_get_property
;
766 * GSocketClient::event:
767 * @client: the #GSocketClient
768 * @event: the event that is occurring
769 * @connectable: the #GSocketConnectable that @event is occurring on
770 * @connection: the current representation of the connection
772 * Emitted when @client's activity on @connectable changes state.
773 * Among other things, this can be used to provide progress
774 * information about a network connection in the UI. The meanings of
775 * the different @event values are as follows:
777 * - %G_SOCKET_CLIENT_RESOLVING: @client is about to look up @connectable
778 * in DNS. @connection will be %NULL.
780 * - %G_SOCKET_CLIENT_RESOLVED: @client has successfully resolved
781 * @connectable in DNS. @connection will be %NULL.
783 * - %G_SOCKET_CLIENT_CONNECTING: @client is about to make a connection
784 * to a remote host; either a proxy server or the destination server
785 * itself. @connection is the #GSocketConnection, which is not yet
786 * connected. Since GLib 2.40, you can access the remote
787 * address via g_socket_connection_get_remote_address().
789 * - %G_SOCKET_CLIENT_CONNECTED: @client has successfully connected
790 * to a remote host. @connection is the connected #GSocketConnection.
792 * - %G_SOCKET_CLIENT_PROXY_NEGOTIATING: @client is about to negotiate
793 * with a proxy to get it to connect to @connectable. @connection is
794 * the #GSocketConnection to the proxy server.
796 * - %G_SOCKET_CLIENT_PROXY_NEGOTIATED: @client has negotiated a
797 * connection to @connectable through a proxy server. @connection is
798 * the stream returned from g_proxy_connect(), which may or may not
799 * be a #GSocketConnection.
801 * - %G_SOCKET_CLIENT_TLS_HANDSHAKING: @client is about to begin a TLS
802 * handshake. @connection is a #GTlsClientConnection.
804 * - %G_SOCKET_CLIENT_TLS_HANDSHAKED: @client has successfully completed
805 * the TLS handshake. @connection is a #GTlsClientConnection.
807 * - %G_SOCKET_CLIENT_COMPLETE: @client has either successfully connected
808 * to @connectable (in which case @connection is the #GSocketConnection
809 * that it will be returning to the caller) or has failed (in which
810 * case @connection is %NULL and the client is about to return an error).
812 * Each event except %G_SOCKET_CLIENT_COMPLETE may be emitted
813 * multiple times (or not at all) for a given connectable (in
814 * particular, if @client ends up attempting to connect to more than
815 * one address). However, if @client emits the #GSocketClient::event
816 * signal at all for a given connectable, that it will always emit
817 * it with %G_SOCKET_CLIENT_COMPLETE when it is done.
819 * Note that there may be additional #GSocketClientEvent values in
820 * the future; unrecognized @event values should be ignored.
825 g_signal_new (I_("event"),
826 G_TYPE_FROM_CLASS (gobject_class
),
828 G_STRUCT_OFFSET (GSocketClientClass
, event
),
832 G_TYPE_SOCKET_CLIENT_EVENT
,
833 G_TYPE_SOCKET_CONNECTABLE
,
836 g_object_class_install_property (gobject_class
, PROP_FAMILY
,
837 g_param_spec_enum ("family",
839 P_("The sockets address family to use for socket construction"),
840 G_TYPE_SOCKET_FAMILY
,
841 G_SOCKET_FAMILY_INVALID
,
844 G_PARAM_STATIC_STRINGS
));
846 g_object_class_install_property (gobject_class
, PROP_TYPE
,
847 g_param_spec_enum ("type",
849 P_("The sockets type to use for socket construction"),
851 G_SOCKET_TYPE_STREAM
,
854 G_PARAM_STATIC_STRINGS
));
856 g_object_class_install_property (gobject_class
, PROP_PROTOCOL
,
857 g_param_spec_enum ("protocol",
858 P_("Socket protocol"),
859 P_("The protocol to use for socket construction, or 0 for default"),
860 G_TYPE_SOCKET_PROTOCOL
,
861 G_SOCKET_PROTOCOL_DEFAULT
,
864 G_PARAM_STATIC_STRINGS
));
866 g_object_class_install_property (gobject_class
, PROP_LOCAL_ADDRESS
,
867 g_param_spec_object ("local-address",
869 P_("The local address constructed sockets will be bound to"),
870 G_TYPE_SOCKET_ADDRESS
,
873 G_PARAM_STATIC_STRINGS
));
875 g_object_class_install_property (gobject_class
, PROP_TIMEOUT
,
876 g_param_spec_uint ("timeout",
877 P_("Socket timeout"),
878 P_("The I/O timeout for sockets, or 0 for none"),
882 G_PARAM_STATIC_STRINGS
));
884 g_object_class_install_property (gobject_class
, PROP_ENABLE_PROXY
,
885 g_param_spec_boolean ("enable-proxy",
887 P_("Enable proxy support"),
891 G_PARAM_STATIC_STRINGS
));
893 g_object_class_install_property (gobject_class
, PROP_TLS
,
894 g_param_spec_boolean ("tls",
896 P_("Whether to create TLS connections"),
900 G_PARAM_STATIC_STRINGS
));
901 g_object_class_install_property (gobject_class
, PROP_TLS_VALIDATION_FLAGS
,
902 g_param_spec_flags ("tls-validation-flags",
903 P_("TLS validation flags"),
904 P_("TLS validation flags to use"),
905 G_TYPE_TLS_CERTIFICATE_FLAGS
,
906 G_TLS_CERTIFICATE_VALIDATE_ALL
,
909 G_PARAM_STATIC_STRINGS
));
912 * GSocketClient:proxy-resolver:
914 * The proxy resolver to use
918 g_object_class_install_property (gobject_class
, PROP_PROXY_RESOLVER
,
919 g_param_spec_object ("proxy-resolver",
920 P_("Proxy resolver"),
921 P_("The proxy resolver to use"),
922 G_TYPE_PROXY_RESOLVER
,
925 G_PARAM_STATIC_STRINGS
));
929 g_socket_client_emit_event (GSocketClient
*client
,
930 GSocketClientEvent event
,
931 GSocketConnectable
*connectable
,
932 GIOStream
*connection
)
934 g_signal_emit (client
, signals
[EVENT
], 0,
935 event
, connectable
, connection
);
939 * g_socket_client_connect:
940 * @client: a #GSocketClient.
941 * @connectable: a #GSocketConnectable specifying the remote address.
942 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
943 * @error: #GError for error reporting, or %NULL to ignore.
945 * Tries to resolve the @connectable and make a network connection to it.
947 * Upon a successful connection, a new #GSocketConnection is constructed
948 * and returned. The caller owns this new object and must drop their
949 * reference to it when finished with it.
951 * The type of the #GSocketConnection object returned depends on the type of
952 * the underlying socket that is used. For instance, for a TCP/IP connection
953 * it will be a #GTcpConnection.
955 * The socket created will be the same family as the address that the
956 * @connectable resolves to, unless family is set with g_socket_client_set_family()
957 * or indirectly via g_socket_client_set_local_address(). The socket type
958 * defaults to %G_SOCKET_TYPE_STREAM but can be set with
959 * g_socket_client_set_socket_type().
961 * If a local address is specified with g_socket_client_set_local_address() the
962 * socket will be bound to this address before connecting.
964 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
969 g_socket_client_connect (GSocketClient
*client
,
970 GSocketConnectable
*connectable
,
971 GCancellable
*cancellable
,
974 GIOStream
*connection
= NULL
;
975 GSocketAddressEnumerator
*enumerator
= NULL
;
976 GError
*last_error
, *tmp_error
;
980 if (can_use_proxy (client
))
982 enumerator
= g_socket_connectable_proxy_enumerate (connectable
);
983 if (client
->priv
->proxy_resolver
&&
984 G_IS_PROXY_ADDRESS_ENUMERATOR (enumerator
))
986 g_object_set (G_OBJECT (enumerator
),
987 "proxy-resolver", client
->priv
->proxy_resolver
,
992 enumerator
= g_socket_connectable_enumerate (connectable
);
994 while (connection
== NULL
)
996 GSocketAddress
*address
= NULL
;
997 gboolean application_proxy
= FALSE
;
999 gboolean using_proxy
;
1001 if (g_cancellable_is_cancelled (cancellable
))
1003 g_clear_error (error
);
1004 g_cancellable_set_error_if_cancelled (cancellable
, error
);
1009 g_socket_client_emit_event (client
, G_SOCKET_CLIENT_RESOLVING
,
1011 address
= g_socket_address_enumerator_next (enumerator
, cancellable
,
1014 if (address
== NULL
)
1018 g_clear_error (&last_error
);
1019 g_propagate_error (error
, tmp_error
);
1021 else if (last_error
)
1023 g_propagate_error (error
, last_error
);
1026 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_FAILED
,
1027 _("Unknown error on connect"));
1030 g_socket_client_emit_event (client
, G_SOCKET_CLIENT_RESOLVED
,
1033 using_proxy
= (G_IS_PROXY_ADDRESS (address
) &&
1034 client
->priv
->enable_proxy
);
1036 /* clear error from previous attempt */
1037 g_clear_error (&last_error
);
1039 socket
= create_socket (client
, address
, &last_error
);
1042 g_object_unref (address
);
1046 connection
= (GIOStream
*)g_socket_connection_factory_create_connection (socket
);
1047 g_socket_connection_set_cached_remote_address ((GSocketConnection
*)connection
, address
);
1048 g_socket_client_emit_event (client
, G_SOCKET_CLIENT_CONNECTING
, connectable
, connection
);
1050 if (g_socket_connection_connect (G_SOCKET_CONNECTION (connection
),
1051 address
, cancellable
, &last_error
))
1053 g_socket_connection_set_cached_remote_address ((GSocketConnection
*)connection
, NULL
);
1054 g_socket_client_emit_event (client
, G_SOCKET_CLIENT_CONNECTED
, connectable
, connection
);
1058 clarify_connect_error (last_error
, connectable
, address
);
1059 g_object_unref (connection
);
1063 if (connection
&& using_proxy
)
1065 GProxyAddress
*proxy_addr
= G_PROXY_ADDRESS (address
);
1066 const gchar
*protocol
;
1069 protocol
= g_proxy_address_get_protocol (proxy_addr
);
1070 proxy
= g_proxy_get_default_for_protocol (protocol
);
1072 /* The connection should not be anything else then TCP Connection,
1073 * but let's put a safety guard in case
1075 if (!G_IS_TCP_CONNECTION (connection
))
1077 g_critical ("Trying to proxy over non-TCP connection, this is "
1078 "most likely a bug in GLib IO library.");
1080 g_set_error_literal (&last_error
,
1081 G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
1082 _("Proxying over a non-TCP connection is not supported."));
1084 g_object_unref (connection
);
1089 GIOStream
*proxy_connection
;
1091 g_socket_client_emit_event (client
, G_SOCKET_CLIENT_PROXY_NEGOTIATING
, connectable
, connection
);
1092 proxy_connection
= g_proxy_connect (proxy
,
1097 g_object_unref (connection
);
1098 connection
= proxy_connection
;
1099 g_object_unref (proxy
);
1102 g_socket_client_emit_event (client
, G_SOCKET_CLIENT_PROXY_NEGOTIATED
, connectable
, connection
);
1104 else if (!g_hash_table_lookup_extended (client
->priv
->app_proxies
,
1105 protocol
, NULL
, NULL
))
1107 g_set_error (&last_error
, G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
1108 _("Proxy protocol '%s' is not supported."),
1110 g_object_unref (connection
);
1115 application_proxy
= TRUE
;
1119 if (!application_proxy
&& connection
&& client
->priv
->tls
)
1123 tlsconn
= g_tls_client_connection_new (connection
, connectable
, &last_error
);
1124 g_object_unref (connection
);
1125 connection
= tlsconn
;
1129 g_tls_client_connection_set_validation_flags (G_TLS_CLIENT_CONNECTION (tlsconn
),
1130 client
->priv
->tls_validation_flags
);
1131 g_socket_client_emit_event (client
, G_SOCKET_CLIENT_TLS_HANDSHAKING
, connectable
, connection
);
1132 if (g_tls_connection_handshake (G_TLS_CONNECTION (tlsconn
),
1133 cancellable
, &last_error
))
1135 g_socket_client_emit_event (client
, G_SOCKET_CLIENT_TLS_HANDSHAKED
, connectable
, connection
);
1139 g_object_unref (tlsconn
);
1145 if (connection
&& !G_IS_SOCKET_CONNECTION (connection
))
1147 GSocketConnection
*wrapper_connection
;
1149 wrapper_connection
= g_tcp_wrapper_connection_new (connection
, socket
);
1150 g_object_unref (connection
);
1151 connection
= (GIOStream
*)wrapper_connection
;
1154 g_object_unref (socket
);
1155 g_object_unref (address
);
1157 g_object_unref (enumerator
);
1159 g_socket_client_emit_event (client
, G_SOCKET_CLIENT_COMPLETE
, connectable
, connection
);
1160 return G_SOCKET_CONNECTION (connection
);
1164 * g_socket_client_connect_to_host:
1165 * @client: a #GSocketClient
1166 * @host_and_port: the name and optionally port of the host to connect to
1167 * @default_port: the default port to connect to
1168 * @cancellable: (allow-none): a #GCancellable, or %NULL
1169 * @error: a pointer to a #GError, or %NULL
1171 * This is a helper function for g_socket_client_connect().
1173 * Attempts to create a TCP connection to the named host.
1175 * @host_and_port may be in any of a number of recognized formats; an IPv6
1176 * address, an IPv4 address, or a domain name (in which case a DNS
1177 * lookup is performed). Quoting with [] is supported for all address
1178 * types. A port override may be specified in the usual way with a
1179 * colon. Ports may be given as decimal numbers or symbolic names (in
1180 * which case an /etc/services lookup is performed).
1182 * If no port override is given in @host_and_port then @default_port will be
1183 * used as the port number to connect to.
1185 * In general, @host_and_port is expected to be provided by the user (allowing
1186 * them to give the hostname, and a port override if necessary) and
1187 * @default_port is expected to be provided by the application.
1189 * In the case that an IP address is given, a single connection
1190 * attempt is made. In the case that a name is given, multiple
1191 * connection attempts may be made, in turn and according to the
1192 * number of address records in DNS, until a connection succeeds.
1194 * Upon a successful connection, a new #GSocketConnection is constructed
1195 * and returned. The caller owns this new object and must drop their
1196 * reference to it when finished with it.
1198 * In the event of any failure (DNS error, service not found, no hosts
1199 * connectable) %NULL is returned and @error (if non-%NULL) is set
1202 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1207 g_socket_client_connect_to_host (GSocketClient
*client
,
1208 const gchar
*host_and_port
,
1209 guint16 default_port
,
1210 GCancellable
*cancellable
,
1213 GSocketConnectable
*connectable
;
1214 GSocketConnection
*connection
;
1216 connectable
= g_network_address_parse (host_and_port
, default_port
, error
);
1217 if (connectable
== NULL
)
1220 connection
= g_socket_client_connect (client
, connectable
,
1221 cancellable
, error
);
1222 g_object_unref (connectable
);
1228 * g_socket_client_connect_to_service:
1229 * @client: a #GSocketConnection
1230 * @domain: a domain name
1231 * @service: the name of the service to connect to
1232 * @cancellable: (allow-none): a #GCancellable, or %NULL
1233 * @error: a pointer to a #GError, or %NULL
1235 * Attempts to create a TCP connection to a service.
1237 * This call looks up the SRV record for @service at @domain for the
1238 * "tcp" protocol. It then attempts to connect, in turn, to each of
1239 * the hosts providing the service until either a connection succeeds
1240 * or there are no hosts remaining.
1242 * Upon a successful connection, a new #GSocketConnection is constructed
1243 * and returned. The caller owns this new object and must drop their
1244 * reference to it when finished with it.
1246 * In the event of any failure (DNS error, service not found, no hosts
1247 * connectable) %NULL is returned and @error (if non-%NULL) is set
1250 * Returns: (transfer full): a #GSocketConnection if successful, or %NULL on error
1253 g_socket_client_connect_to_service (GSocketClient
*client
,
1254 const gchar
*domain
,
1255 const gchar
*service
,
1256 GCancellable
*cancellable
,
1259 GSocketConnectable
*connectable
;
1260 GSocketConnection
*connection
;
1262 connectable
= g_network_service_new (service
, "tcp", domain
);
1263 connection
= g_socket_client_connect (client
, connectable
,
1264 cancellable
, error
);
1265 g_object_unref (connectable
);
1271 * g_socket_client_connect_to_uri:
1272 * @client: a #GSocketClient
1273 * @uri: A network URI
1274 * @default_port: the default port to connect to
1275 * @cancellable: (allow-none): a #GCancellable, or %NULL
1276 * @error: a pointer to a #GError, or %NULL
1278 * This is a helper function for g_socket_client_connect().
1280 * Attempts to create a TCP connection with a network URI.
1282 * @uri may be any valid URI containing an "authority" (hostname/port)
1283 * component. If a port is not specified in the URI, @default_port
1284 * will be used. TLS will be negotiated if #GSocketClient:tls is %TRUE.
1285 * (#GSocketClient does not know to automatically assume TLS for
1286 * certain URI schemes.)
1288 * Using this rather than g_socket_client_connect() or
1289 * g_socket_client_connect_to_host() allows #GSocketClient to
1290 * determine when to use application-specific proxy protocols.
1292 * Upon a successful connection, a new #GSocketConnection is constructed
1293 * and returned. The caller owns this new object and must drop their
1294 * reference to it when finished with it.
1296 * In the event of any failure (DNS error, service not found, no hosts
1297 * connectable) %NULL is returned and @error (if non-%NULL) is set
1300 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1305 g_socket_client_connect_to_uri (GSocketClient
*client
,
1307 guint16 default_port
,
1308 GCancellable
*cancellable
,
1311 GSocketConnectable
*connectable
;
1312 GSocketConnection
*connection
;
1314 connectable
= g_network_address_parse_uri (uri
, default_port
, error
);
1315 if (connectable
== NULL
)
1318 connection
= g_socket_client_connect (client
, connectable
,
1319 cancellable
, error
);
1320 g_object_unref (connectable
);
1328 GSocketClient
*client
;
1330 GSocketConnectable
*connectable
;
1331 GSocketAddressEnumerator
*enumerator
;
1332 GProxyAddress
*proxy_addr
;
1333 GSocketAddress
*current_addr
;
1334 GSocket
*current_socket
;
1335 GIOStream
*connection
;
1338 } GSocketClientAsyncConnectData
;
1341 g_socket_client_async_connect_data_free (GSocketClientAsyncConnectData
*data
)
1343 g_clear_object (&data
->connectable
);
1344 g_clear_object (&data
->enumerator
);
1345 g_clear_object (&data
->proxy_addr
);
1346 g_clear_object (&data
->current_addr
);
1347 g_clear_object (&data
->current_socket
);
1348 g_clear_object (&data
->connection
);
1350 g_clear_error (&data
->last_error
);
1352 g_slice_free (GSocketClientAsyncConnectData
, data
);
1356 g_socket_client_async_connect_complete (GSocketClientAsyncConnectData
*data
)
1358 g_assert (data
->connection
);
1360 if (!G_IS_SOCKET_CONNECTION (data
->connection
))
1362 GSocketConnection
*wrapper_connection
;
1364 wrapper_connection
= g_tcp_wrapper_connection_new (data
->connection
,
1365 data
->current_socket
);
1366 g_object_unref (data
->connection
);
1367 data
->connection
= (GIOStream
*)wrapper_connection
;
1370 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_COMPLETE
, data
->connectable
, data
->connection
);
1371 g_task_return_pointer (data
->task
, data
->connection
, g_object_unref
);
1372 data
->connection
= NULL
;
1373 g_object_unref (data
->task
);
1378 g_socket_client_enumerator_callback (GObject
*object
,
1379 GAsyncResult
*result
,
1380 gpointer user_data
);
1383 set_last_error (GSocketClientAsyncConnectData
*data
,
1386 g_clear_error (&data
->last_error
);
1387 data
->last_error
= error
;
1391 enumerator_next_async (GSocketClientAsyncConnectData
*data
)
1393 /* We need to cleanup the state */
1394 g_clear_object (&data
->current_socket
);
1395 g_clear_object (&data
->current_addr
);
1396 g_clear_object (&data
->proxy_addr
);
1397 g_clear_object (&data
->connection
);
1399 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_RESOLVING
, data
->connectable
, NULL
);
1400 g_socket_address_enumerator_next_async (data
->enumerator
,
1401 g_task_get_cancellable (data
->task
),
1402 g_socket_client_enumerator_callback
,
1407 g_socket_client_tls_handshake_callback (GObject
*object
,
1408 GAsyncResult
*result
,
1411 GSocketClientAsyncConnectData
*data
= user_data
;
1413 if (g_tls_connection_handshake_finish (G_TLS_CONNECTION (object
),
1417 g_object_unref (data
->connection
);
1418 data
->connection
= G_IO_STREAM (object
);
1420 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_TLS_HANDSHAKED
, data
->connectable
, data
->connection
);
1421 g_socket_client_async_connect_complete (data
);
1425 g_object_unref (object
);
1426 enumerator_next_async (data
);
1431 g_socket_client_tls_handshake (GSocketClientAsyncConnectData
*data
)
1435 if (!data
->client
->priv
->tls
)
1437 g_socket_client_async_connect_complete (data
);
1441 tlsconn
= g_tls_client_connection_new (data
->connection
,
1446 g_tls_client_connection_set_validation_flags (G_TLS_CLIENT_CONNECTION (tlsconn
),
1447 data
->client
->priv
->tls_validation_flags
);
1448 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_TLS_HANDSHAKING
, data
->connectable
, G_IO_STREAM (tlsconn
));
1449 g_tls_connection_handshake_async (G_TLS_CONNECTION (tlsconn
),
1451 g_task_get_cancellable (data
->task
),
1452 g_socket_client_tls_handshake_callback
,
1457 enumerator_next_async (data
);
1462 g_socket_client_proxy_connect_callback (GObject
*object
,
1463 GAsyncResult
*result
,
1466 GSocketClientAsyncConnectData
*data
= user_data
;
1468 g_object_unref (data
->connection
);
1469 data
->connection
= g_proxy_connect_finish (G_PROXY (object
),
1472 if (data
->connection
)
1474 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_PROXY_NEGOTIATED
, data
->connectable
, data
->connection
);
1478 enumerator_next_async (data
);
1482 g_socket_client_tls_handshake (data
);
1486 g_socket_client_connected_callback (GObject
*source
,
1487 GAsyncResult
*result
,
1490 GSocketClientAsyncConnectData
*data
= user_data
;
1491 GError
*error
= NULL
;
1493 const gchar
*protocol
;
1495 if (!g_socket_connection_connect_finish (G_SOCKET_CONNECTION (source
),
1498 clarify_connect_error (error
, data
->connectable
,
1499 data
->current_addr
);
1500 set_last_error (data
, error
);
1503 enumerator_next_async (data
);
1507 g_socket_connection_set_cached_remote_address ((GSocketConnection
*)data
->connection
, NULL
);
1508 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_CONNECTED
, data
->connectable
, data
->connection
);
1510 /* wrong, but backward compatible */
1511 g_socket_set_blocking (data
->current_socket
, TRUE
);
1513 if (!data
->proxy_addr
)
1515 g_socket_client_tls_handshake (data
);
1519 protocol
= g_proxy_address_get_protocol (data
->proxy_addr
);
1520 proxy
= g_proxy_get_default_for_protocol (protocol
);
1522 /* The connection should not be anything other than TCP,
1523 * but let's put a safety guard in case
1525 if (!G_IS_TCP_CONNECTION (data
->connection
))
1527 g_critical ("Trying to proxy over non-TCP connection, this is "
1528 "most likely a bug in GLib IO library.");
1530 g_set_error_literal (&data
->last_error
,
1531 G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
1532 _("Proxying over a non-TCP connection is not supported."));
1534 enumerator_next_async (data
);
1538 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_PROXY_NEGOTIATING
, data
->connectable
, data
->connection
);
1539 g_proxy_connect_async (proxy
,
1542 g_task_get_cancellable (data
->task
),
1543 g_socket_client_proxy_connect_callback
,
1545 g_object_unref (proxy
);
1547 else if (!g_hash_table_lookup_extended (data
->client
->priv
->app_proxies
,
1548 protocol
, NULL
, NULL
))
1550 g_clear_error (&data
->last_error
);
1552 g_set_error (&data
->last_error
, G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
1553 _("Proxy protocol '%s' is not supported."),
1556 enumerator_next_async (data
);
1560 /* Simply complete the connection, we don't want to do TLS handshake
1561 * as the application proxy handling may need proxy handshake first */
1562 g_socket_client_async_connect_complete (data
);
1567 g_socket_client_enumerator_callback (GObject
*object
,
1568 GAsyncResult
*result
,
1571 GSocketClientAsyncConnectData
*data
= user_data
;
1572 GSocketAddress
*address
= NULL
;
1574 GError
*error
= NULL
;
1576 if (g_task_return_error_if_cancelled (data
->task
))
1578 g_object_unref (data
->task
);
1582 address
= g_socket_address_enumerator_next_finish (data
->enumerator
,
1584 if (address
== NULL
)
1586 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_COMPLETE
, data
->connectable
, NULL
);
1589 if (data
->last_error
)
1591 error
= data
->last_error
;
1592 data
->last_error
= NULL
;
1596 g_set_error_literal (&error
, G_IO_ERROR
, G_IO_ERROR_FAILED
,
1597 _("Unknown error on connect"));
1600 g_task_return_error (data
->task
, error
);
1601 g_object_unref (data
->task
);
1605 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_RESOLVED
,
1606 data
->connectable
, NULL
);
1608 if (G_IS_PROXY_ADDRESS (address
) &&
1609 data
->client
->priv
->enable_proxy
)
1610 data
->proxy_addr
= g_object_ref (G_PROXY_ADDRESS (address
));
1612 g_clear_error (&data
->last_error
);
1614 socket
= create_socket (data
->client
, address
, &data
->last_error
);
1617 g_object_unref (address
);
1618 enumerator_next_async (data
);
1622 data
->current_socket
= socket
;
1623 data
->current_addr
= address
;
1624 data
->connection
= (GIOStream
*) g_socket_connection_factory_create_connection (socket
);
1626 g_socket_connection_set_cached_remote_address ((GSocketConnection
*)data
->connection
, address
);
1627 g_socket_client_emit_event (data
->client
, G_SOCKET_CLIENT_CONNECTING
, data
->connectable
, data
->connection
);
1628 g_socket_connection_connect_async (G_SOCKET_CONNECTION (data
->connection
),
1630 g_task_get_cancellable (data
->task
),
1631 g_socket_client_connected_callback
, data
);
1635 * g_socket_client_connect_async:
1636 * @client: a #GSocketClient
1637 * @connectable: a #GSocketConnectable specifying the remote address.
1638 * @cancellable: (allow-none): a #GCancellable, or %NULL
1639 * @callback: (scope async): a #GAsyncReadyCallback
1640 * @user_data: (closure): user data for the callback
1642 * This is the asynchronous version of g_socket_client_connect().
1644 * When the operation is finished @callback will be
1645 * called. You can then call g_socket_client_connect_finish() to get
1646 * the result of the operation.
1651 g_socket_client_connect_async (GSocketClient
*client
,
1652 GSocketConnectable
*connectable
,
1653 GCancellable
*cancellable
,
1654 GAsyncReadyCallback callback
,
1657 GSocketClientAsyncConnectData
*data
;
1659 g_return_if_fail (G_IS_SOCKET_CLIENT (client
));
1661 data
= g_slice_new0 (GSocketClientAsyncConnectData
);
1662 data
->client
= client
;
1663 data
->connectable
= g_object_ref (connectable
);
1665 if (can_use_proxy (client
))
1667 data
->enumerator
= g_socket_connectable_proxy_enumerate (connectable
);
1668 if (client
->priv
->proxy_resolver
&&
1669 G_IS_PROXY_ADDRESS_ENUMERATOR (data
->enumerator
))
1671 g_object_set (G_OBJECT (data
->enumerator
),
1672 "proxy-resolver", client
->priv
->proxy_resolver
,
1677 data
->enumerator
= g_socket_connectable_enumerate (connectable
);
1679 data
->task
= g_task_new (client
, cancellable
, callback
, user_data
);
1680 g_task_set_task_data (data
->task
, data
, (GDestroyNotify
)g_socket_client_async_connect_data_free
);
1682 enumerator_next_async (data
);
1686 * g_socket_client_connect_to_host_async:
1687 * @client: a #GSocketClient
1688 * @host_and_port: the name and optionally the port of the host to connect to
1689 * @default_port: the default port to connect to
1690 * @cancellable: (allow-none): a #GCancellable, or %NULL
1691 * @callback: (scope async): a #GAsyncReadyCallback
1692 * @user_data: (closure): user data for the callback
1694 * This is the asynchronous version of g_socket_client_connect_to_host().
1696 * When the operation is finished @callback will be
1697 * called. You can then call g_socket_client_connect_to_host_finish() to get
1698 * the result of the operation.
1703 g_socket_client_connect_to_host_async (GSocketClient
*client
,
1704 const gchar
*host_and_port
,
1705 guint16 default_port
,
1706 GCancellable
*cancellable
,
1707 GAsyncReadyCallback callback
,
1710 GSocketConnectable
*connectable
;
1714 connectable
= g_network_address_parse (host_and_port
, default_port
,
1716 if (connectable
== NULL
)
1718 g_task_report_error (client
, callback
, user_data
,
1719 g_socket_client_connect_to_host_async
,
1724 g_socket_client_connect_async (client
,
1725 connectable
, cancellable
,
1726 callback
, user_data
);
1727 g_object_unref (connectable
);
1732 * g_socket_client_connect_to_service_async:
1733 * @client: a #GSocketClient
1734 * @domain: a domain name
1735 * @service: the name of the service to connect to
1736 * @cancellable: (allow-none): a #GCancellable, or %NULL
1737 * @callback: (scope async): a #GAsyncReadyCallback
1738 * @user_data: (closure): user data for the callback
1740 * This is the asynchronous version of
1741 * g_socket_client_connect_to_service().
1746 g_socket_client_connect_to_service_async (GSocketClient
*client
,
1747 const gchar
*domain
,
1748 const gchar
*service
,
1749 GCancellable
*cancellable
,
1750 GAsyncReadyCallback callback
,
1753 GSocketConnectable
*connectable
;
1755 connectable
= g_network_service_new (service
, "tcp", domain
);
1756 g_socket_client_connect_async (client
,
1757 connectable
, cancellable
,
1758 callback
, user_data
);
1759 g_object_unref (connectable
);
1763 * g_socket_client_connect_to_uri_async:
1764 * @client: a #GSocketClient
1765 * @uri: a network uri
1766 * @default_port: the default port to connect to
1767 * @cancellable: (allow-none): a #GCancellable, or %NULL
1768 * @callback: (scope async): a #GAsyncReadyCallback
1769 * @user_data: (closure): user data for the callback
1771 * This is the asynchronous version of g_socket_client_connect_to_uri().
1773 * When the operation is finished @callback will be
1774 * called. You can then call g_socket_client_connect_to_uri_finish() to get
1775 * the result of the operation.
1780 g_socket_client_connect_to_uri_async (GSocketClient
*client
,
1782 guint16 default_port
,
1783 GCancellable
*cancellable
,
1784 GAsyncReadyCallback callback
,
1787 GSocketConnectable
*connectable
;
1791 connectable
= g_network_address_parse_uri (uri
, default_port
, &error
);
1792 if (connectable
== NULL
)
1794 g_task_report_error (client
, callback
, user_data
,
1795 g_socket_client_connect_to_uri_async
,
1800 g_socket_client_connect_async (client
,
1801 connectable
, cancellable
,
1802 callback
, user_data
);
1803 g_object_unref (connectable
);
1809 * g_socket_client_connect_finish:
1810 * @client: a #GSocketClient.
1811 * @result: a #GAsyncResult.
1812 * @error: a #GError location to store the error occurring, or %NULL to
1815 * Finishes an async connect operation. See g_socket_client_connect_async()
1817 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1822 g_socket_client_connect_finish (GSocketClient
*client
,
1823 GAsyncResult
*result
,
1826 g_return_val_if_fail (g_task_is_valid (result
, client
), NULL
);
1828 return g_task_propagate_pointer (G_TASK (result
), error
);
1832 * g_socket_client_connect_to_host_finish:
1833 * @client: a #GSocketClient.
1834 * @result: a #GAsyncResult.
1835 * @error: a #GError location to store the error occurring, or %NULL to
1838 * Finishes an async connect operation. See g_socket_client_connect_to_host_async()
1840 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1845 g_socket_client_connect_to_host_finish (GSocketClient
*client
,
1846 GAsyncResult
*result
,
1849 return g_socket_client_connect_finish (client
, result
, error
);
1853 * g_socket_client_connect_to_service_finish:
1854 * @client: a #GSocketClient.
1855 * @result: a #GAsyncResult.
1856 * @error: a #GError location to store the error occurring, or %NULL to
1859 * Finishes an async connect operation. See g_socket_client_connect_to_service_async()
1861 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1866 g_socket_client_connect_to_service_finish (GSocketClient
*client
,
1867 GAsyncResult
*result
,
1870 return g_socket_client_connect_finish (client
, result
, error
);
1874 * g_socket_client_connect_to_uri_finish:
1875 * @client: a #GSocketClient.
1876 * @result: a #GAsyncResult.
1877 * @error: a #GError location to store the error occurring, or %NULL to
1880 * Finishes an async connect operation. See g_socket_client_connect_to_uri_async()
1882 * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1887 g_socket_client_connect_to_uri_finish (GSocketClient
*client
,
1888 GAsyncResult
*result
,
1891 return g_socket_client_connect_finish (client
, result
, error
);
1895 * g_socket_client_add_application_proxy:
1896 * @client: a #GSocketClient
1897 * @protocol: The proxy protocol
1899 * Enable proxy protocols to be handled by the application. When the
1900 * indicated proxy protocol is returned by the #GProxyResolver,
1901 * #GSocketClient will consider this protocol as supported but will
1902 * not try to find a #GProxy instance to handle handshaking. The
1903 * application must check for this case by calling
1904 * g_socket_connection_get_remote_address() on the returned
1905 * #GSocketConnection, and seeing if it's a #GProxyAddress of the
1906 * appropriate type, to determine whether or not it needs to handle
1907 * the proxy handshaking itself.
1909 * This should be used for proxy protocols that are dialects of
1910 * another protocol such as HTTP proxy. It also allows cohabitation of
1911 * proxy protocols that are reused between protocols. A good example
1912 * is HTTP. It can be used to proxy HTTP, FTP and Gopher and can also
1913 * be use as generic socket proxy through the HTTP CONNECT method.
1915 * When the proxy is detected as being an application proxy, TLS handshake
1916 * will be skipped. This is required to let the application do the proxy
1917 * specific handshake.
1920 g_socket_client_add_application_proxy (GSocketClient
*client
,
1921 const gchar
*protocol
)
1923 g_hash_table_insert (client
->priv
->app_proxies
, g_strdup (protocol
), NULL
);