gio/gsocketclient.c

   1 /*  GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright © 2008, 2009 codethink
   4  * Copyright © 2009 Red Hat, Inc
   5  *
   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.
  10  *
  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.
  15  *
  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/>.
  18  *
  19  * Authors: Ryan Lortie <desrt@desrt.ca>
  20  *          Alexander Larsson <alexl@redhat.com>
  21  */
  22
  23 #include "config.h"
  24 #include "gsocketclient.h"
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  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>
  50 #include "glibintl.h"
  51
  52
  53 /**
  54  * SECTION:gsocketclient
  55  * @short_description: Helper for connecting to a network service
  56  * @include: gio/gio.h
  57  * @see_also: #GSocketConnection, #GSocketListener
  58  *
  59  * #GSocketClient is a lightweight high-level utility class for connecting to
  60  * a network host using a connection oriented socket type.
  61  *
  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.
  65  *
  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.
  69  *
  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.
  72  *
  73  * Since: 2.22
  74  */
  75
  76
  77 enum
  78 {
  79   EVENT,
  80   LAST_SIGNAL
  81 };
  82
  83 static guint signals[LAST_SIGNAL] = { 0 };
  84
  85 enum
  86 {
  87   PROP_NONE,
  88   PROP_FAMILY,
  89   PROP_TYPE,
  90   PROP_PROTOCOL,
  91   PROP_LOCAL_ADDRESS,
  92   PROP_TIMEOUT,
  93   PROP_ENABLE_PROXY,
  94   PROP_TLS,
  95   PROP_TLS_VALIDATION_FLAGS,
  96   PROP_PROXY_RESOLVER
  97 };
  98
  99 struct _GSocketClientPrivate
 100 {
 101   GSocketFamily family;
 102   GSocketType type;
 103   GSocketProtocol protocol;
 104   GSocketAddress *local_address;
 105   guint timeout;
 106   gboolean enable_proxy;
 107   GHashTable *app_proxies;
 108   gboolean tls;
 109   GTlsCertificateFlags tls_validation_flags;
 110   GProxyResolver *proxy_resolver;
 111 };
 112
 113 G_DEFINE_TYPE_WITH_PRIVATE (GSocketClient, g_socket_client, G_TYPE_OBJECT)
 114
 115 static GSocket *
 116 create_socket (GSocketClient  *client,
 117                GSocketAddress *dest_address,
 118                GError        **error)
 119 {
 120   GSocketFamily family;
 121   GSocket *socket;
 122
 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);
 129
 130   socket = g_socket_new (family,
 131                          client->priv->type,
 132                          client->priv->protocol,
 133                          error);
 134   if (socket == NULL)
 135     return NULL;
 136
 137   if (client->priv->local_address)
 138     {
 139       if (!g_socket_bind (socket,
 140                           client->priv->local_address,
 141                           FALSE,
 142                           error))
 143         {
 144           g_object_unref (socket);
 145           return NULL;
 146         }
 147     }
 148
 149   if (client->priv->timeout)
 150     g_socket_set_timeout (socket, client->priv->timeout);
 151
 152   return socket;
 153 }
 154
 155 static gboolean
 156 can_use_proxy (GSocketClient *client)
 157 {
 158   GSocketClientPrivate *priv = client->priv;
 159
 160   return priv->enable_proxy
 161           && priv->type == G_SOCKET_TYPE_STREAM;
 162 }
 163
 164 static void
 165 clarify_connect_error (GError             *error,
 166                        GSocketConnectable *connectable,
 167                        GSocketAddress     *address)
 168 {
 169   const char *name;
 170   char *tmp_name = NULL;
 171
 172   if (G_IS_PROXY_ADDRESS (address))
 173     {
 174       name = tmp_name = g_inet_address_to_string (g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (address)));
 175
 176       g_prefix_error (&error, _("Could not connect to proxy server %s: "), name);
 177     }
 178   else
 179     {
 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)));
 186       else
 187         name = NULL;
 188
 189       if (name)
 190         g_prefix_error (&error, _("Could not connect to %s: "), name);
 191       else
 192         g_prefix_error (&error, _("Could not connect: "));
 193     }
 194
 195   g_free (tmp_name);
 196 }
 197
 198 static void
 199 g_socket_client_init (GSocketClient *client)
 200 {
 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,
 204                                                      g_str_equal,
 205                                                      g_free,
 206                                                      NULL);
 207 }
 208
 209 /**
 210  * g_socket_client_new:
 211  *
 212  * Creates a new #GSocketClient with the default options.
 213  *
 214  * Returns: a #GSocketClient.
 215  *     Free the returned object with g_object_unref().
 216  *
 217  * Since: 2.22
 218  */
 219 GSocketClient *
 220 g_socket_client_new (void)
 221 {
 222   return g_object_new (G_TYPE_SOCKET_CLIENT, NULL);
 223 }
 224
 225 static void
 226 g_socket_client_finalize (GObject *object)
 227 {
 228   GSocketClient *client = G_SOCKET_CLIENT (object);
 229
 230   g_clear_object (&client->priv->local_address);
 231   g_clear_object (&client->priv->proxy_resolver);
 232
 233   G_OBJECT_CLASS (g_socket_client_parent_class)->finalize (object);
 234
 235   g_hash_table_unref (client->priv->app_proxies);
 236 }
 237
 238 static void
 239 g_socket_client_get_property (GObject    *object,
 240                               guint       prop_id,
 241                               GValue     *value,
 242                               GParamSpec *pspec)
 243 {
 244   GSocketClient *client = G_SOCKET_CLIENT (object);
 245
 246   switch (prop_id)
 247     {
 248       case PROP_FAMILY:
 249         g_value_set_enum (value, client->priv->family);
 250         break;
 251
 252       case PROP_TYPE:
 253         g_value_set_enum (value, client->priv->type);
 254         break;
 255
 256       case PROP_PROTOCOL:
 257         g_value_set_enum (value, client->priv->protocol);
 258         break;
 259
 260       case PROP_LOCAL_ADDRESS:
 261         g_value_set_object (value, client->priv->local_address);
 262         break;
 263
 264       case PROP_TIMEOUT:
 265         g_value_set_uint (value, client->priv->timeout);
 266         break;
 267
 268       case PROP_ENABLE_PROXY:
 269         g_value_set_boolean (value, client->priv->enable_proxy);
 270         break;
 271
 272       case PROP_TLS:
 273         g_value_set_boolean (value, g_socket_client_get_tls (client));
 274         break;
 275
 276       case PROP_TLS_VALIDATION_FLAGS:
 277         g_value_set_flags (value, g_socket_client_get_tls_validation_flags (client));
 278         break;
 279
 280       case PROP_PROXY_RESOLVER:
 281         g_value_set_object (value, g_socket_client_get_proxy_resolver (client));
 282         break;
 283
 284       default:
 285         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 286     }
 287 }
 288
 289 static void
 290 g_socket_client_set_property (GObject      *object,
 291                               guint         prop_id,
 292                               const GValue *value,
 293                               GParamSpec   *pspec)
 294 {
 295   GSocketClient *client = G_SOCKET_CLIENT (object);
 296
 297   switch (prop_id)
 298     {
 299     case PROP_FAMILY:
 300       g_socket_client_set_family (client, g_value_get_enum (value));
 301       break;
 302
 303     case PROP_TYPE:
 304       g_socket_client_set_socket_type (client, g_value_get_enum (value));
 305       break;
 306
 307     case PROP_PROTOCOL:
 308       g_socket_client_set_protocol (client, g_value_get_enum (value));
 309       break;
 310
 311     case PROP_LOCAL_ADDRESS:
 312       g_socket_client_set_local_address (client, g_value_get_object (value));
 313       break;
 314
 315     case PROP_TIMEOUT:
 316       g_socket_client_set_timeout (client, g_value_get_uint (value));
 317       break;
 318
 319     case PROP_ENABLE_PROXY:
 320       g_socket_client_set_enable_proxy (client, g_value_get_boolean (value));
 321       break;
 322
 323     case PROP_TLS:
 324       g_socket_client_set_tls (client, g_value_get_boolean (value));
 325       break;
 326
 327     case PROP_TLS_VALIDATION_FLAGS:
 328       g_socket_client_set_tls_validation_flags (client, g_value_get_flags (value));
 329       break;
 330
 331     case PROP_PROXY_RESOLVER:
 332       g_socket_client_set_proxy_resolver (client, g_value_get_object (value));
 333       break;
 334
 335     default:
 336       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 337     }
 338 }
 339
 340 /**
 341  * g_socket_client_get_family:
 342  * @client: a #GSocketClient.
 343  *
 344  * Gets the socket family of the socket client.
 345  *
 346  * See g_socket_client_set_family() for details.
 347  *
 348  * Returns: a #GSocketFamily
 349  *
 350  * Since: 2.22
 351  */
 352 GSocketFamily
 353 g_socket_client_get_family (GSocketClient *client)
 354 {
 355   return client->priv->family;
 356 }
 357
 358 /**
 359  * g_socket_client_set_family:
 360  * @client: a #GSocketClient.
 361  * @family: a #GSocketFamily
 362  *
 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
 366  * family.
 367  *
 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.
 371  *
 372  * Since: 2.22
 373  */
 374 void
 375 g_socket_client_set_family (GSocketClient *client,
 376                             GSocketFamily  family)
 377 {
 378   if (client->priv->family == family)
 379     return;
 380
 381   client->priv->family = family;
 382   g_object_notify (G_OBJECT (client), "family");
 383 }
 384
 385 /**
 386  * g_socket_client_get_socket_type:
 387  * @client: a #GSocketClient.
 388  *
 389  * Gets the socket type of the socket client.
 390  *
 391  * See g_socket_client_set_socket_type() for details.
 392  *
 393  * Returns: a #GSocketFamily
 394  *
 395  * Since: 2.22
 396  */
 397 GSocketType
 398 g_socket_client_get_socket_type (GSocketClient *client)
 399 {
 400   return client->priv->type;
 401 }
 402
 403 /**
 404  * g_socket_client_set_socket_type:
 405  * @client: a #GSocketClient.
 406  * @type: a #GSocketType
 407  *
 408  * Sets the socket type of the socket client.
 409  * The sockets created by this object will be of the specified
 410  * type.
 411  *
 412  * It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,
 413  * as GSocketClient is used for connection oriented services.
 414  *
 415  * Since: 2.22
 416  */
 417 void
 418 g_socket_client_set_socket_type (GSocketClient *client,
 419                                  GSocketType    type)
 420 {
 421   if (client->priv->type == type)
 422     return;
 423
 424   client->priv->type = type;
 425   g_object_notify (G_OBJECT (client), "type");
 426 }
 427
 428 /**
 429  * g_socket_client_get_protocol:
 430  * @client: a #GSocketClient
 431  *
 432  * Gets the protocol name type of the socket client.
 433  *
 434  * See g_socket_client_set_protocol() for details.
 435  *
 436  * Returns: a #GSocketProtocol
 437  *
 438  * Since: 2.22
 439  */
 440 GSocketProtocol
 441 g_socket_client_get_protocol (GSocketClient *client)
 442 {
 443   return client->priv->protocol;
 444 }
 445
 446 /**
 447  * g_socket_client_set_protocol:
 448  * @client: a #GSocketClient.
 449  * @protocol: a #GSocketProtocol
 450  *
 451  * Sets the protocol of the socket client.
 452  * The sockets created by this object will use of the specified
 453  * protocol.
 454  *
 455  * If @protocol is %0 that means to use the default
 456  * protocol for the socket family and type.
 457  *
 458  * Since: 2.22
 459  */
 460 void
 461 g_socket_client_set_protocol (GSocketClient   *client,
 462                               GSocketProtocol  protocol)
 463 {
 464   if (client->priv->protocol == protocol)
 465     return;
 466
 467   client->priv->protocol = protocol;
 468   g_object_notify (G_OBJECT (client), "protocol");
 469 }
 470
 471 /**
 472  * g_socket_client_get_local_address:
 473  * @client: a #GSocketClient.
 474  *
 475  * Gets the local address of the socket client.
 476  *
 477  * See g_socket_client_set_local_address() for details.
 478  *
 479  * Returns: (transfer none): a #GSocketAddress or %NULL. Do not free.
 480  *
 481  * Since: 2.22
 482  */
 483 GSocketAddress *
 484 g_socket_client_get_local_address (GSocketClient *client)
 485 {
 486   return client->priv->local_address;
 487 }
 488
 489 /**
 490  * g_socket_client_set_local_address:
 491  * @client: a #GSocketClient.
 492  * @address: (allow-none): a #GSocketAddress, or %NULL
 493  *
 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.
 497  *
 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.
 501  *
 502  * Since: 2.22
 503  */
 504 void
 505 g_socket_client_set_local_address (GSocketClient  *client,
 506                                    GSocketAddress *address)
 507 {
 508   if (address)
 509     g_object_ref (address);
 510
 511   if (client->priv->local_address)
 512     {
 513       g_object_unref (client->priv->local_address);
 514     }
 515   client->priv->local_address = address;
 516   g_object_notify (G_OBJECT (client), "local-address");
 517 }
 518
 519 /**
 520  * g_socket_client_get_timeout:
 521  * @client: a #GSocketClient
 522  *
 523  * Gets the I/O timeout time for sockets created by @client.
 524  *
 525  * See g_socket_client_set_timeout() for details.
 526  *
 527  * Returns: the timeout in seconds
 528  *
 529  * Since: 2.26
 530  */
 531 guint
 532 g_socket_client_get_timeout (GSocketClient *client)
 533 {
 534   return client->priv->timeout;
 535 }
 536
 537
 538 /**
 539  * g_socket_client_set_timeout:
 540  * @client: a #GSocketClient.
 541  * @timeout: the timeout
 542  *
 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).
 545  *
 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.
 549  *
 550  * Since: 2.26
 551  */
 552 void
 553 g_socket_client_set_timeout (GSocketClient *client,
 554                              guint          timeout)
 555 {
 556   if (client->priv->timeout == timeout)
 557     return;
 558
 559   client->priv->timeout = timeout;
 560   g_object_notify (G_OBJECT (client), "timeout");
 561 }
 562
 563 /**
 564  * g_socket_client_get_enable_proxy:
 565  * @client: a #GSocketClient.
 566  *
 567  * Gets the proxy enable state; see g_socket_client_set_enable_proxy()
 568  *
 569  * Returns: whether proxying is enabled
 570  *
 571  * Since: 2.26
 572  */
 573 gboolean
 574 g_socket_client_get_enable_proxy (GSocketClient *client)
 575 {
 576   return client->priv->enable_proxy;
 577 }
 578
 579 /**
 580  * g_socket_client_set_enable_proxy:
 581  * @client: a #GSocketClient.
 582  * @enable: whether to enable proxies
 583  *
 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.
 588  *
 589  * See also g_socket_client_set_proxy_resolver().
 590  *
 591  * Since: 2.26
 592  */
 593 void
 594 g_socket_client_set_enable_proxy (GSocketClient *client,
 595                                   gboolean       enable)
 596 {
 597   enable = !!enable;
 598   if (client->priv->enable_proxy == enable)
 599     return;
 600
 601   client->priv->enable_proxy = enable;
 602   g_object_notify (G_OBJECT (client), "enable-proxy");
 603 }
 604
 605 /**
 606  * g_socket_client_get_tls:
 607  * @client: a #GSocketClient.
 608  *
 609  * Gets whether @client creates TLS connections. See
 610  * g_socket_client_set_tls() for details.
 611  *
 612  * Returns: whether @client uses TLS
 613  *
 614  * Since: 2.28
 615  */
 616 gboolean
 617 g_socket_client_get_tls (GSocketClient *client)
 618 {
 619   return client->priv->tls;
 620 }
 621
 622 /**
 623  * g_socket_client_set_tls:
 624  * @client: a #GSocketClient.
 625  * @tls: whether to use TLS
 626  *
 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.
 630  *
 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.
 637  *
 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
 644  * starts.
 645  *
 646  * Since: 2.28
 647  */
 648 void
 649 g_socket_client_set_tls (GSocketClient *client,
 650                          gboolean       tls)
 651 {
 652   tls = !!tls;
 653   if (tls == client->priv->tls)
 654     return;
 655
 656   client->priv->tls = tls;
 657   g_object_notify (G_OBJECT (client), "tls");
 658 }
 659
 660 /**
 661  * g_socket_client_get_tls_validation_flags:
 662  * @client: a #GSocketClient.
 663  *
 664  * Gets the TLS validation flags used creating TLS connections via
 665  * @client.
 666  *
 667  * Returns: the TLS validation flags
 668  *
 669  * Since: 2.28
 670  */
 671 GTlsCertificateFlags
 672 g_socket_client_get_tls_validation_flags (GSocketClient *client)
 673 {
 674   return client->priv->tls_validation_flags;
 675 }
 676
 677 /**
 678  * g_socket_client_set_tls_validation_flags:
 679  * @client: a #GSocketClient.
 680  * @flags: the validation flags
 681  *
 682  * Sets the TLS validation flags used when creating TLS connections
 683  * via @client. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
 684  *
 685  * Since: 2.28
 686  */
 687 void
 688 g_socket_client_set_tls_validation_flags (GSocketClient        *client,
 689                                           GTlsCertificateFlags  flags)
 690 {
 691   if (client->priv->tls_validation_flags != flags)
 692     {
 693       client->priv->tls_validation_flags = flags;
 694       g_object_notify (G_OBJECT (client), "tls-validation-flags");
 695     }
 696 }
 697
 698 /**
 699  * g_socket_client_get_proxy_resolver:
 700  * @client: a #GSocketClient.
 701  *
 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().
 705  *
 706  * Returns: (transfer none): The #GProxyResolver being used by
 707  *   @client.
 708  *
 709  * Since: 2.36
 710  */
 711 GProxyResolver *
 712 g_socket_client_get_proxy_resolver (GSocketClient *client)
 713 {
 714   if (client->priv->proxy_resolver)
 715     return client->priv->proxy_resolver;
 716   else
 717     return g_proxy_resolver_get_default ();
 718 }
 719
 720 /**
 721  * g_socket_client_set_proxy_resolver:
 722  * @client: a #GSocketClient.
 723  * @proxy_resolver: (allow-none): a #GProxyResolver, or %NULL for the
 724  *   default.
 725  *
 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.
 729  *
 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)
 733  *
 734  * Since: 2.36
 735  */
 736 void
 737 g_socket_client_set_proxy_resolver (GSocketClient  *client,
 738                                     GProxyResolver *proxy_resolver)
 739 {
 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,
 744    * tests/gsettings).
 745    */
 746
 747   if (client->priv->proxy_resolver)
 748     g_object_unref (client->priv->proxy_resolver);
 749
 750   client->priv->proxy_resolver = proxy_resolver;
 751
 752   if (client->priv->proxy_resolver)
 753     g_object_ref (client->priv->proxy_resolver);
 754 }
 755
 756 static void
 757 g_socket_client_class_init (GSocketClientClass *class)
 758 {
 759   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 760
 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;
 764
 765   /**
 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
 771    *
 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:
 776    *
 777    * - %G_SOCKET_CLIENT_RESOLVING: @client is about to look up @connectable
 778    *   in DNS. @connection will be %NULL.
 779    *
 780    * - %G_SOCKET_CLIENT_RESOLVED:  @client has successfully resolved
 781    *   @connectable in DNS. @connection will be %NULL.
 782    *
 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().
 788    *
 789    * - %G_SOCKET_CLIENT_CONNECTED: @client has successfully connected
 790    *   to a remote host. @connection is the connected #GSocketConnection.
 791    *
 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.
 795    *
 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.
 800    *
 801    * - %G_SOCKET_CLIENT_TLS_HANDSHAKING: @client is about to begin a TLS
 802    *   handshake. @connection is a #GTlsClientConnection.
 803    *
 804    * - %G_SOCKET_CLIENT_TLS_HANDSHAKED: @client has successfully completed
 805    *   the TLS handshake. @connection is a #GTlsClientConnection.
 806    *
 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).
 811    *
 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.
 818    *
 819    * Note that there may be additional #GSocketClientEvent values in
 820    * the future; unrecognized @event values should be ignored.
 821    *
 822    * Since: 2.32
 823    */
 824   signals[EVENT] =
 825     g_signal_new (I_("event"),
 826                   G_TYPE_FROM_CLASS (gobject_class),
 827                   G_SIGNAL_RUN_LAST,
 828                   G_STRUCT_OFFSET (GSocketClientClass, event),
 829                   NULL, NULL,
 830                   NULL,
 831                   G_TYPE_NONE, 3,
 832                   G_TYPE_SOCKET_CLIENT_EVENT,
 833                   G_TYPE_SOCKET_CONNECTABLE,
 834                   G_TYPE_IO_STREAM);
 835
 836   g_object_class_install_property (gobject_class, PROP_FAMILY,
 837                                    g_param_spec_enum ("family",
 838                                                       P_("Socket family"),
 839                                                       P_("The sockets address family to use for socket construction"),
 840                                                       G_TYPE_SOCKET_FAMILY,
 841                                                       G_SOCKET_FAMILY_INVALID,
 842                                                       G_PARAM_CONSTRUCT |
 843                                                       G_PARAM_READWRITE |
 844                                                       G_PARAM_STATIC_STRINGS));
 845
 846   g_object_class_install_property (gobject_class, PROP_TYPE,
 847                                    g_param_spec_enum ("type",
 848                                                       P_("Socket type"),
 849                                                       P_("The sockets type to use for socket construction"),
 850                                                       G_TYPE_SOCKET_TYPE,
 851                                                       G_SOCKET_TYPE_STREAM,
 852                                                       G_PARAM_CONSTRUCT |
 853                                                       G_PARAM_READWRITE |
 854                                                       G_PARAM_STATIC_STRINGS));
 855
 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,
 862                                                       G_PARAM_CONSTRUCT |
 863                                                       G_PARAM_READWRITE |
 864                                                       G_PARAM_STATIC_STRINGS));
 865
 866   g_object_class_install_property (gobject_class, PROP_LOCAL_ADDRESS,
 867                                    g_param_spec_object ("local-address",
 868                                                         P_("Local address"),
 869                                                         P_("The local address constructed sockets will be bound to"),
 870                                                         G_TYPE_SOCKET_ADDRESS,
 871                                                         G_PARAM_CONSTRUCT |
 872                                                         G_PARAM_READWRITE |
 873                                                         G_PARAM_STATIC_STRINGS));
 874
 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"),
 879                                                       0, G_MAXUINT, 0,
 880                                                       G_PARAM_CONSTRUCT |
 881                                                       G_PARAM_READWRITE |
 882                                                       G_PARAM_STATIC_STRINGS));
 883
 884    g_object_class_install_property (gobject_class, PROP_ENABLE_PROXY,
 885                                     g_param_spec_boolean ("enable-proxy",
 886                                                           P_("Enable proxy"),
 887                                                           P_("Enable proxy support"),
 888                                                           TRUE,
 889                                                           G_PARAM_CONSTRUCT |
 890                                                           G_PARAM_READWRITE |
 891                                                           G_PARAM_STATIC_STRINGS));
 892
 893   g_object_class_install_property (gobject_class, PROP_TLS,
 894                                    g_param_spec_boolean ("tls",
 895                                                          P_("TLS"),
 896                                                          P_("Whether to create TLS connections"),
 897                                                          FALSE,
 898                                                          G_PARAM_CONSTRUCT |
 899                                                          G_PARAM_READWRITE |
 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,
 907                                                        G_PARAM_CONSTRUCT |
 908                                                        G_PARAM_READWRITE |
 909                                                        G_PARAM_STATIC_STRINGS));
 910
 911   /**
 912    * GSocketClient:proxy-resolver:
 913    *
 914    * The proxy resolver to use
 915    *
 916    * Since: 2.36
 917    */
 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,
 923                                                         G_PARAM_CONSTRUCT |
 924                                                         G_PARAM_READWRITE |
 925                                                         G_PARAM_STATIC_STRINGS));
 926 }
 927
 928 static void
 929 g_socket_client_emit_event (GSocketClient       *client,
 930                             GSocketClientEvent  event,
 931                             GSocketConnectable  *connectable,
 932                             GIOStream           *connection)
 933 {
 934   g_signal_emit (client, signals[EVENT], 0,
 935                  event, connectable, connection);
 936 }
 937
 938 /**
 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.
 944  *
 945  * Tries to resolve the @connectable and make a network connection to it.
 946  *
 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.
 950  *
 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.
 954  *
 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().
 960  *
 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.
 963  *
 964  * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
 965  *
 966  * Since: 2.22
 967  */
 968 GSocketConnection *
 969 g_socket_client_connect (GSocketClient       *client,
 970                          GSocketConnectable  *connectable,
 971                          GCancellable        *cancellable,
 972                          GError             **error)
 973 {
 974   GIOStream *connection = NULL;
 975   GSocketAddressEnumerator *enumerator = NULL;
 976   GError *last_error, *tmp_error;
 977
 978   last_error = NULL;
 979
 980   if (can_use_proxy (client))
 981     {
 982       enumerator = g_socket_connectable_proxy_enumerate (connectable);
 983       if (client->priv->proxy_resolver &&
 984           G_IS_PROXY_ADDRESS_ENUMERATOR (enumerator))
 985         {
 986           g_object_set (G_OBJECT (enumerator),
 987                         "proxy-resolver", client->priv->proxy_resolver,
 988                         NULL);
 989         }
 990     }
 991   else
 992     enumerator = g_socket_connectable_enumerate (connectable);
 993
 994   while (connection == NULL)
 995     {
 996       GSocketAddress *address = NULL;
 997       gboolean application_proxy = FALSE;
 998       GSocket *socket;
 999       gboolean using_proxy;
1000
1001       if (g_cancellable_is_cancelled (cancellable))
1002         {
1003           g_clear_error (error);
1004           g_cancellable_set_error_if_cancelled (cancellable, error);
1005           break;
1006         }
1007
1008       tmp_error = NULL;
1009       g_socket_client_emit_event (client, G_SOCKET_CLIENT_RESOLVING,
1010                                   connectable, NULL);
1011       address = g_socket_address_enumerator_next (enumerator, cancellable,
1012                                                   &tmp_error);
1013
1014       if (address == NULL)
1015         {
1016           if (tmp_error)
1017             {
1018               g_clear_error (&last_error);
1019               g_propagate_error (error, tmp_error);
1020             }
1021           else if (last_error)
1022             {
1023               g_propagate_error (error, last_error);
1024             }
1025           else
1026             g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
1027                                  _("Unknown error on connect"));
1028           break;
1029         }
1030       g_socket_client_emit_event (client, G_SOCKET_CLIENT_RESOLVED,
1031                                   connectable, NULL);
1032
1033       using_proxy = (G_IS_PROXY_ADDRESS (address) &&
1034                      client->priv->enable_proxy);
1035
1036       /* clear error from previous attempt */
1037       g_clear_error (&last_error);
1038
1039       socket = create_socket (client, address, &last_error);
1040       if (socket == NULL)
1041         {
1042           g_object_unref (address);
1043           continue;
1044         }
1045
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);
1049
1050       if (g_socket_connection_connect (G_SOCKET_CONNECTION (connection),
1051                                        address, cancellable, &last_error))
1052         {
1053           g_socket_connection_set_cached_remote_address ((GSocketConnection*)connection, NULL);
1054           g_socket_client_emit_event (client, G_SOCKET_CLIENT_CONNECTED, connectable, connection);
1055         }
1056       else
1057         {
1058           clarify_connect_error (last_error, connectable, address);
1059           g_object_unref (connection);
1060           connection = NULL;
1061         }
1062
1063       if (connection && using_proxy)
1064         {
1065           GProxyAddress *proxy_addr = G_PROXY_ADDRESS (address);
1066           const gchar *protocol;
1067           GProxy *proxy;
1068
1069           protocol = g_proxy_address_get_protocol (proxy_addr);
1070           proxy = g_proxy_get_default_for_protocol (protocol);
1071
1072           /* The connection should not be anything else then TCP Connection,
1073            * but let's put a safety guard in case
1074            */
1075           if (!G_IS_TCP_CONNECTION (connection))
1076             {
1077               g_critical ("Trying to proxy over non-TCP connection, this is "
1078                           "most likely a bug in GLib IO library.");
1079
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."));
1083
1084               g_object_unref (connection);
1085               connection = NULL;
1086             }
1087           else if (proxy)
1088             {
1089               GIOStream *proxy_connection;
1090
1091               g_socket_client_emit_event (client, G_SOCKET_CLIENT_PROXY_NEGOTIATING, connectable, connection);
1092               proxy_connection = g_proxy_connect (proxy,
1093                                                   connection,
1094                                                   proxy_addr,
1095                                                   cancellable,
1096                                                   &last_error);
1097               g_object_unref (connection);
1098               connection = proxy_connection;
1099               g_object_unref (proxy);
1100
1101               if (connection)
1102                 g_socket_client_emit_event (client, G_SOCKET_CLIENT_PROXY_NEGOTIATED, connectable, connection);
1103             }
1104           else if (!g_hash_table_lookup_extended (client->priv->app_proxies,
1105                                                   protocol, NULL, NULL))
1106             {
1107               g_set_error (&last_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
1108                            _("Proxy protocol '%s' is not supported."),
1109                            protocol);
1110               g_object_unref (connection);
1111               connection = NULL;
1112             }
1113           else
1114             {
1115               application_proxy = TRUE;
1116             }
1117         }
1118
1119       if (!application_proxy && connection && client->priv->tls)
1120         {
1121           GIOStream *tlsconn;
1122
1123           tlsconn = g_tls_client_connection_new (connection, connectable, &last_error);
1124           g_object_unref (connection);
1125           connection = tlsconn;
1126
1127           if (tlsconn)
1128             {
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))
1134                 {
1135                   g_socket_client_emit_event (client, G_SOCKET_CLIENT_TLS_HANDSHAKED, connectable, connection);
1136                 }
1137               else
1138                 {
1139                   g_object_unref (tlsconn);
1140                   connection = NULL;
1141                 }
1142             }
1143         }
1144
1145       if (connection && !G_IS_SOCKET_CONNECTION (connection))
1146         {
1147           GSocketConnection *wrapper_connection;
1148
1149           wrapper_connection = g_tcp_wrapper_connection_new (connection, socket);
1150           g_object_unref (connection);
1151           connection = (GIOStream *)wrapper_connection;
1152         }
1153
1154       g_object_unref (socket);
1155       g_object_unref (address);
1156     }
1157   g_object_unref (enumerator);
1158
1159   g_socket_client_emit_event (client, G_SOCKET_CLIENT_COMPLETE, connectable, connection);
1160   return G_SOCKET_CONNECTION (connection);
1161 }
1162
1163 /**
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
1170  *
1171  * This is a helper function for g_socket_client_connect().
1172  *
1173  * Attempts to create a TCP connection to the named host.
1174  *
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).
1181  *
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.
1184  *
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.
1188  *
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.
1193  *
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.
1197  *
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
1200  * accordingly.
1201  *
1202  * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1203  *
1204  * Since: 2.22
1205  */
1206 GSocketConnection *
1207 g_socket_client_connect_to_host (GSocketClient  *client,
1208                                  const gchar    *host_and_port,
1209                                  guint16         default_port,
1210                                  GCancellable   *cancellable,
1211                                  GError        **error)
1212 {
1213   GSocketConnectable *connectable;
1214   GSocketConnection *connection;
1215
1216   connectable = g_network_address_parse (host_and_port, default_port, error);
1217   if (connectable == NULL)
1218     return NULL;
1219
1220   connection = g_socket_client_connect (client, connectable,
1221                                         cancellable, error);
1222   g_object_unref (connectable);
1223
1224   return connection;
1225 }
1226
1227 /**
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
1234  *
1235  * Attempts to create a TCP connection to a service.
1236  *
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.
1241  *
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.
1245  *
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
1248  * accordingly.
1249  *
1250  * Returns: (transfer full): a #GSocketConnection if successful, or %NULL on error
1251  */
1252 GSocketConnection *
1253 g_socket_client_connect_to_service (GSocketClient  *client,
1254                                     const gchar    *domain,
1255                                     const gchar    *service,
1256                                     GCancellable   *cancellable,
1257                                     GError        **error)
1258 {
1259   GSocketConnectable *connectable;
1260   GSocketConnection *connection;
1261
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);
1266
1267   return connection;
1268 }
1269
1270 /**
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
1277  *
1278  * This is a helper function for g_socket_client_connect().
1279  *
1280  * Attempts to create a TCP connection with a network URI.
1281  *
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.)
1287  *
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.
1291  *
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.
1295  *
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
1298  * accordingly.
1299  *
1300  * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1301  *
1302  * Since: 2.26
1303  */
1304 GSocketConnection *
1305 g_socket_client_connect_to_uri (GSocketClient  *client,
1306                                 const gchar    *uri,
1307                                 guint16         default_port,
1308                                 GCancellable   *cancellable,
1309                                 GError        **error)
1310 {
1311   GSocketConnectable *connectable;
1312   GSocketConnection *connection;
1313
1314   connectable = g_network_address_parse_uri (uri, default_port, error);
1315   if (connectable == NULL)
1316     return NULL;
1317
1318   connection = g_socket_client_connect (client, connectable,
1319                                         cancellable, error);
1320   g_object_unref (connectable);
1321
1322   return connection;
1323 }
1324
1325 typedef struct
1326 {
1327   GTask *task;
1328   GSocketClient *client;
1329
1330   GSocketConnectable *connectable;
1331   GSocketAddressEnumerator *enumerator;
1332   GProxyAddress *proxy_addr;
1333   GSocketAddress *current_addr;
1334   GSocket *current_socket;
1335   GIOStream *connection;
1336
1337   GError *last_error;
1338 } GSocketClientAsyncConnectData;
1339
1340 static void
1341 g_socket_client_async_connect_data_free (GSocketClientAsyncConnectData *data)
1342 {
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);
1349
1350   g_clear_error (&data->last_error);
1351
1352   g_slice_free (GSocketClientAsyncConnectData, data);
1353 }
1354
1355 static void
1356 g_socket_client_async_connect_complete (GSocketClientAsyncConnectData *data)
1357 {
1358   g_assert (data->connection);
1359
1360   if (!G_IS_SOCKET_CONNECTION (data->connection))
1361     {
1362       GSocketConnection *wrapper_connection;
1363
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;
1368     }
1369
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);
1374 }
1375
1376
1377 static void
1378 g_socket_client_enumerator_callback (GObject      *object,
1379                                      GAsyncResult *result,
1380                                      gpointer      user_data);
1381
1382 static void
1383 set_last_error (GSocketClientAsyncConnectData *data,
1384                 GError *error)
1385 {
1386   g_clear_error (&data->last_error);
1387   data->last_error = error;
1388 }
1389
1390 static void
1391 enumerator_next_async (GSocketClientAsyncConnectData *data)
1392 {
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);
1398
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,
1403                                           data);
1404 }
1405
1406 static void
1407 g_socket_client_tls_handshake_callback (GObject      *object,
1408                                         GAsyncResult *result,
1409                                         gpointer      user_data)
1410 {
1411   GSocketClientAsyncConnectData *data = user_data;
1412
1413   if (g_tls_connection_handshake_finish (G_TLS_CONNECTION (object),
1414                                          result,
1415                                          &data->last_error))
1416     {
1417       g_object_unref (data->connection);
1418       data->connection = G_IO_STREAM (object);
1419
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);
1422     }
1423   else
1424     {
1425       g_object_unref (object);
1426       enumerator_next_async (data);
1427     }
1428 }
1429
1430 static void
1431 g_socket_client_tls_handshake (GSocketClientAsyncConnectData *data)
1432 {
1433   GIOStream *tlsconn;
1434
1435   if (!data->client->priv->tls)
1436     {
1437       g_socket_client_async_connect_complete (data);
1438       return;
1439     }
1440
1441   tlsconn = g_tls_client_connection_new (data->connection,
1442                                          data->connectable,
1443                                          &data->last_error);
1444   if (tlsconn)
1445     {
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),
1450                                         G_PRIORITY_DEFAULT,
1451                                         g_task_get_cancellable (data->task),
1452                                         g_socket_client_tls_handshake_callback,
1453                                         data);
1454     }
1455   else
1456     {
1457       enumerator_next_async (data);
1458     }
1459 }
1460
1461 static void
1462 g_socket_client_proxy_connect_callback (GObject      *object,
1463                                         GAsyncResult *result,
1464                                         gpointer      user_data)
1465 {
1466   GSocketClientAsyncConnectData *data = user_data;
1467
1468   g_object_unref (data->connection);
1469   data->connection = g_proxy_connect_finish (G_PROXY (object),
1470                                              result,
1471                                              &data->last_error);
1472   if (data->connection)
1473     {
1474       g_socket_client_emit_event (data->client, G_SOCKET_CLIENT_PROXY_NEGOTIATED, data->connectable, data->connection);
1475     }
1476   else
1477     {
1478       enumerator_next_async (data);
1479       return;
1480     }
1481
1482   g_socket_client_tls_handshake (data);
1483 }
1484
1485 static void
1486 g_socket_client_connected_callback (GObject      *source,
1487                                     GAsyncResult *result,
1488                                     gpointer      user_data)
1489 {
1490   GSocketClientAsyncConnectData *data = user_data;
1491   GError *error = NULL;
1492   GProxy *proxy;
1493   const gchar *protocol;
1494
1495   if (g_task_return_error_if_cancelled (data->task))
1496     {
1497       g_object_unref (data->task);
1498       return;
1499     }
1500
1501   if (!g_socket_connection_connect_finish (G_SOCKET_CONNECTION (source),
1502                                            result, &error))
1503     {
1504       clarify_connect_error (error, data->connectable,
1505                              data->current_addr);
1506       set_last_error (data, error);
1507
1508       /* try next one */
1509       enumerator_next_async (data);
1510       return;
1511     }
1512
1513   g_socket_connection_set_cached_remote_address ((GSocketConnection*)data->connection, NULL);
1514   g_socket_client_emit_event (data->client, G_SOCKET_CLIENT_CONNECTED, data->connectable, data->connection);
1515
1516   /* wrong, but backward compatible */
1517   g_socket_set_blocking (data->current_socket, TRUE);
1518
1519   if (!data->proxy_addr)
1520     {
1521       g_socket_client_tls_handshake (data);
1522       return;
1523     }
1524
1525   protocol = g_proxy_address_get_protocol (data->proxy_addr);
1526   proxy = g_proxy_get_default_for_protocol (protocol);
1527
1528   /* The connection should not be anything other than TCP,
1529    * but let's put a safety guard in case
1530    */
1531   if (!G_IS_TCP_CONNECTION (data->connection))
1532     {
1533       g_critical ("Trying to proxy over non-TCP connection, this is "
1534           "most likely a bug in GLib IO library.");
1535
1536       g_set_error_literal (&data->last_error,
1537           G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
1538           _("Proxying over a non-TCP connection is not supported."));
1539
1540       enumerator_next_async (data);
1541     }
1542   else if (proxy)
1543     {
1544       g_socket_client_emit_event (data->client, G_SOCKET_CLIENT_PROXY_NEGOTIATING, data->connectable, data->connection);
1545       g_proxy_connect_async (proxy,
1546                              data->connection,
1547                              data->proxy_addr,
1548                              g_task_get_cancellable (data->task),
1549                              g_socket_client_proxy_connect_callback,
1550                              data);
1551       g_object_unref (proxy);
1552     }
1553   else if (!g_hash_table_lookup_extended (data->client->priv->app_proxies,
1554                                           protocol, NULL, NULL))
1555     {
1556       g_clear_error (&data->last_error);
1557
1558       g_set_error (&data->last_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
1559           _("Proxy protocol '%s' is not supported."),
1560           protocol);
1561
1562       enumerator_next_async (data);
1563     }
1564   else
1565     {
1566       /* Simply complete the connection, we don't want to do TLS handshake
1567        * as the application proxy handling may need proxy handshake first */
1568       g_socket_client_async_connect_complete (data);
1569     }
1570 }
1571
1572 static void
1573 g_socket_client_enumerator_callback (GObject      *object,
1574                                      GAsyncResult *result,
1575                                      gpointer      user_data)
1576 {
1577   GSocketClientAsyncConnectData *data = user_data;
1578   GSocketAddress *address = NULL;
1579   GSocket *socket;
1580   GError *error = NULL;
1581
1582   if (g_task_return_error_if_cancelled (data->task))
1583     {
1584       g_object_unref (data->task);
1585       return;
1586     }
1587
1588   address = g_socket_address_enumerator_next_finish (data->enumerator,
1589                                                      result, &error);
1590   if (address == NULL)
1591     {
1592       g_socket_client_emit_event (data->client, G_SOCKET_CLIENT_COMPLETE, data->connectable, NULL);
1593       if (!error)
1594         {
1595           if (data->last_error)
1596             {
1597               error = data->last_error;
1598               data->last_error = NULL;
1599             }
1600           else
1601             {
1602               g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_FAILED,
1603                                    _("Unknown error on connect"));
1604             }
1605         }
1606       g_task_return_error (data->task, error);
1607       g_object_unref (data->task);
1608       return;
1609     }
1610
1611   g_socket_client_emit_event (data->client, G_SOCKET_CLIENT_RESOLVED,
1612                               data->connectable, NULL);
1613
1614   if (G_IS_PROXY_ADDRESS (address) &&
1615       data->client->priv->enable_proxy)
1616     data->proxy_addr = g_object_ref (G_PROXY_ADDRESS (address));
1617
1618   g_clear_error (&data->last_error);
1619
1620   socket = create_socket (data->client, address, &data->last_error);
1621   if (socket == NULL)
1622     {
1623       g_object_unref (address);
1624       enumerator_next_async (data);
1625       return;
1626     }
1627
1628   data->current_socket = socket;
1629   data->current_addr = address;
1630   data->connection = (GIOStream *) g_socket_connection_factory_create_connection (socket);
1631
1632   g_socket_connection_set_cached_remote_address ((GSocketConnection*)data->connection, address);
1633   g_socket_client_emit_event (data->client, G_SOCKET_CLIENT_CONNECTING, data->connectable, data->connection);
1634   g_socket_connection_connect_async (G_SOCKET_CONNECTION (data->connection),
1635                                      address,
1636                                      g_task_get_cancellable (data->task),
1637                                      g_socket_client_connected_callback, data);
1638 }
1639
1640 /**
1641  * g_socket_client_connect_async:
1642  * @client: a #GSocketClient
1643  * @connectable: a #GSocketConnectable specifying the remote address.
1644  * @cancellable: (allow-none): a #GCancellable, or %NULL
1645  * @callback: (scope async): a #GAsyncReadyCallback
1646  * @user_data: (closure): user data for the callback
1647  *
1648  * This is the asynchronous version of g_socket_client_connect().
1649  *
1650  * When the operation is finished @callback will be
1651  * called. You can then call g_socket_client_connect_finish() to get
1652  * the result of the operation.
1653  *
1654  * Since: 2.22
1655  */
1656 void
1657 g_socket_client_connect_async (GSocketClient       *client,
1658                                GSocketConnectable  *connectable,
1659                                GCancellable        *cancellable,
1660                                GAsyncReadyCallback  callback,
1661                                gpointer             user_data)
1662 {
1663   GSocketClientAsyncConnectData *data;
1664
1665   g_return_if_fail (G_IS_SOCKET_CLIENT (client));
1666
1667   data = g_slice_new0 (GSocketClientAsyncConnectData);
1668   data->client = client;
1669   data->connectable = g_object_ref (connectable);
1670
1671   if (can_use_proxy (client))
1672     {
1673       data->enumerator = g_socket_connectable_proxy_enumerate (connectable);
1674       if (client->priv->proxy_resolver &&
1675           G_IS_PROXY_ADDRESS_ENUMERATOR (data->enumerator))
1676         {
1677           g_object_set (G_OBJECT (data->enumerator),
1678                         "proxy-resolver", client->priv->proxy_resolver,
1679                         NULL);
1680         }
1681     }
1682   else
1683     data->enumerator = g_socket_connectable_enumerate (connectable);
1684
1685   data->task = g_task_new (client, cancellable, callback, user_data);
1686   g_task_set_task_data (data->task, data, (GDestroyNotify)g_socket_client_async_connect_data_free);
1687
1688   enumerator_next_async (data);
1689 }
1690
1691 /**
1692  * g_socket_client_connect_to_host_async:
1693  * @client: a #GSocketClient
1694  * @host_and_port: the name and optionally the port of the host to connect to
1695  * @default_port: the default port to connect to
1696  * @cancellable: (allow-none): a #GCancellable, or %NULL
1697  * @callback: (scope async): a #GAsyncReadyCallback
1698  * @user_data: (closure): user data for the callback
1699  *
1700  * This is the asynchronous version of g_socket_client_connect_to_host().
1701  *
1702  * When the operation is finished @callback will be
1703  * called. You can then call g_socket_client_connect_to_host_finish() to get
1704  * the result of the operation.
1705  *
1706  * Since: 2.22
1707  */
1708 void
1709 g_socket_client_connect_to_host_async (GSocketClient        *client,
1710                                        const gchar          *host_and_port,
1711                                        guint16               default_port,
1712                                        GCancellable         *cancellable,
1713                                        GAsyncReadyCallback   callback,
1714                                        gpointer              user_data)
1715 {
1716   GSocketConnectable *connectable;
1717   GError *error;
1718
1719   error = NULL;
1720   connectable = g_network_address_parse (host_and_port, default_port,
1721                                          &error);
1722   if (connectable == NULL)
1723     {
1724       g_task_report_error (client, callback, user_data,
1725                            g_socket_client_connect_to_host_async,
1726                            error);
1727     }
1728   else
1729     {
1730       g_socket_client_connect_async (client,
1731                                      connectable, cancellable,
1732                                      callback, user_data);
1733       g_object_unref (connectable);
1734     }
1735 }
1736
1737 /**
1738  * g_socket_client_connect_to_service_async:
1739  * @client: a #GSocketClient
1740  * @domain: a domain name
1741  * @service: the name of the service to connect to
1742  * @cancellable: (allow-none): a #GCancellable, or %NULL
1743  * @callback: (scope async): a #GAsyncReadyCallback
1744  * @user_data: (closure): user data for the callback
1745  *
1746  * This is the asynchronous version of
1747  * g_socket_client_connect_to_service().
1748  *
1749  * Since: 2.22
1750  */
1751 void
1752 g_socket_client_connect_to_service_async (GSocketClient       *client,
1753                                           const gchar         *domain,
1754                                           const gchar         *service,
1755                                           GCancellable        *cancellable,
1756                                           GAsyncReadyCallback  callback,
1757                                           gpointer             user_data)
1758 {
1759   GSocketConnectable *connectable;
1760
1761   connectable = g_network_service_new (service, "tcp", domain);
1762   g_socket_client_connect_async (client,
1763                                  connectable, cancellable,
1764                                  callback, user_data);
1765   g_object_unref (connectable);
1766 }
1767
1768 /**
1769  * g_socket_client_connect_to_uri_async:
1770  * @client: a #GSocketClient
1771  * @uri: a network uri
1772  * @default_port: the default port to connect to
1773  * @cancellable: (allow-none): a #GCancellable, or %NULL
1774  * @callback: (scope async): a #GAsyncReadyCallback
1775  * @user_data: (closure): user data for the callback
1776  *
1777  * This is the asynchronous version of g_socket_client_connect_to_uri().
1778  *
1779  * When the operation is finished @callback will be
1780  * called. You can then call g_socket_client_connect_to_uri_finish() to get
1781  * the result of the operation.
1782  *
1783  * Since: 2.26
1784  */
1785 void
1786 g_socket_client_connect_to_uri_async (GSocketClient        *client,
1787                                       const gchar          *uri,
1788                                       guint16               default_port,
1789                                       GCancellable         *cancellable,
1790                                       GAsyncReadyCallback   callback,
1791                                       gpointer              user_data)
1792 {
1793   GSocketConnectable *connectable;
1794   GError *error;
1795
1796   error = NULL;
1797   connectable = g_network_address_parse_uri (uri, default_port, &error);
1798   if (connectable == NULL)
1799     {
1800       g_task_report_error (client, callback, user_data,
1801                            g_socket_client_connect_to_uri_async,
1802                            error);
1803     }
1804   else
1805     {
1806       g_socket_client_connect_async (client,
1807                                      connectable, cancellable,
1808                                      callback, user_data);
1809       g_object_unref (connectable);
1810     }
1811 }
1812
1813
1814 /**
1815  * g_socket_client_connect_finish:
1816  * @client: a #GSocketClient.
1817  * @result: a #GAsyncResult.
1818  * @error: a #GError location to store the error occurring, or %NULL to
1819  * ignore.
1820  *
1821  * Finishes an async connect operation. See g_socket_client_connect_async()
1822  *
1823  * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1824  *
1825  * Since: 2.22
1826  */
1827 GSocketConnection *
1828 g_socket_client_connect_finish (GSocketClient  *client,
1829                                 GAsyncResult   *result,
1830                                 GError        **error)
1831 {
1832   g_return_val_if_fail (g_task_is_valid (result, client), NULL);
1833
1834   return g_task_propagate_pointer (G_TASK (result), error);
1835 }
1836
1837 /**
1838  * g_socket_client_connect_to_host_finish:
1839  * @client: a #GSocketClient.
1840  * @result: a #GAsyncResult.
1841  * @error: a #GError location to store the error occurring, or %NULL to
1842  * ignore.
1843  *
1844  * Finishes an async connect operation. See g_socket_client_connect_to_host_async()
1845  *
1846  * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1847  *
1848  * Since: 2.22
1849  */
1850 GSocketConnection *
1851 g_socket_client_connect_to_host_finish (GSocketClient  *client,
1852                                         GAsyncResult   *result,
1853                                         GError        **error)
1854 {
1855   return g_socket_client_connect_finish (client, result, error);
1856 }
1857
1858 /**
1859  * g_socket_client_connect_to_service_finish:
1860  * @client: a #GSocketClient.
1861  * @result: a #GAsyncResult.
1862  * @error: a #GError location to store the error occurring, or %NULL to
1863  * ignore.
1864  *
1865  * Finishes an async connect operation. See g_socket_client_connect_to_service_async()
1866  *
1867  * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1868  *
1869  * Since: 2.22
1870  */
1871 GSocketConnection *
1872 g_socket_client_connect_to_service_finish (GSocketClient  *client,
1873                                            GAsyncResult   *result,
1874                                            GError        **error)
1875 {
1876   return g_socket_client_connect_finish (client, result, error);
1877 }
1878
1879 /**
1880  * g_socket_client_connect_to_uri_finish:
1881  * @client: a #GSocketClient.
1882  * @result: a #GAsyncResult.
1883  * @error: a #GError location to store the error occurring, or %NULL to
1884  * ignore.
1885  *
1886  * Finishes an async connect operation. See g_socket_client_connect_to_uri_async()
1887  *
1888  * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
1889  *
1890  * Since: 2.26
1891  */
1892 GSocketConnection *
1893 g_socket_client_connect_to_uri_finish (GSocketClient  *client,
1894                                        GAsyncResult   *result,
1895                                        GError        **error)
1896 {
1897   return g_socket_client_connect_finish (client, result, error);
1898 }
1899
1900 /**
1901  * g_socket_client_add_application_proxy:
1902  * @client: a #GSocketClient
1903  * @protocol: The proxy protocol
1904  *
1905  * Enable proxy protocols to be handled by the application. When the
1906  * indicated proxy protocol is returned by the #GProxyResolver,
1907  * #GSocketClient will consider this protocol as supported but will
1908  * not try to find a #GProxy instance to handle handshaking. The
1909  * application must check for this case by calling
1910  * g_socket_connection_get_remote_address() on the returned
1911  * #GSocketConnection, and seeing if it's a #GProxyAddress of the
1912  * appropriate type, to determine whether or not it needs to handle
1913  * the proxy handshaking itself.
1914  *
1915  * This should be used for proxy protocols that are dialects of
1916  * another protocol such as HTTP proxy. It also allows cohabitation of
1917  * proxy protocols that are reused between protocols. A good example
1918  * is HTTP. It can be used to proxy HTTP, FTP and Gopher and can also
1919  * be use as generic socket proxy through the HTTP CONNECT method.
1920  *
1921  * When the proxy is detected as being an application proxy, TLS handshake
1922  * will be skipped. This is required to let the application do the proxy
1923  * specific handshake.
1924  */
1925 void
1926 g_socket_client_add_application_proxy (GSocketClient *client,
1927                                        const gchar   *protocol)
1928 {
1929   g_hash_table_insert (client->priv->app_proxies, g_strdup (protocol), NULL);
1930 }