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, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  * Authors: Ryan Lortie <desrt@desrt.ca>
  22  *          Alexander Larsson <alexl@redhat.com>
  23  */
  24
  25 #include "config.h"
  26 #include "gsocketclient.h"
  27
  28 #include <stdlib.h>
  29
  30 #include <gio/gioenumtypes.h>
  31 #include <gio/gsocketaddressenumerator.h>
  32 #include <gio/gsocketconnectable.h>
  33 #include <gio/gsocketconnection.h>
  34 #include <gio/gsimpleasyncresult.h>
  35 #include <gio/gcancellable.h>
  36 #include <gio/gioerror.h>
  37 #include <gio/gsocket.h>
  38 #include <gio/gnetworkaddress.h>
  39 #include <gio/gnetworkservice.h>
  40 #include <gio/gsocketaddress.h>
  41 #include "glibintl.h"
  42
  43 #include "gioalias.h"
  44
  45 /**
  46  * SECTION:gsocketclient
  47  * @short_description: Helper for connecting to a network service
  48  * @include: gio/gio.h
  49  * @see_also: #GSocketConnection, #GSocketListener
  50  *
  51  * #GSocketClient is a high-level utility class for connecting to a
  52  * network host using a connection oriented socket type.
  53  *
  54  * You create a #GSocketClient object, set any options you want, then
  55  * call a sync or async connect operation, which returns a #GSocketConnection
  56  * subclass on success.
  57  *
  58  * The type of the #GSocketConnection object returned depends on the type of
  59  * the underlying socket that is in use. For instance, for a TCP/IP connection
  60  * it will be a #GTcpConnection.
  61  *
  62  * Since: 2.22
  63  */
  64
  65
  66 G_DEFINE_TYPE (GSocketClient, g_socket_client, G_TYPE_OBJECT);
  67
  68 enum
  69 {
  70   PROP_NONE,
  71   PROP_FAMILY,
  72   PROP_TYPE,
  73   PROP_PROTOCOL,
  74   PROP_LOCAL_ADDRESS
  75 };
  76
  77 struct _GSocketClientPrivate
  78 {
  79   GSocketFamily family;
  80   GSocketType type;
  81   GSocketProtocol protocol;
  82   GSocketAddress *local_address;
  83 };
  84
  85 static GSocket *
  86 create_socket (GSocketClient  *client,
  87                GSocketAddress *dest_address,
  88                GError        **error)
  89 {
  90   GSocketFamily family;
  91   GSocket *socket;
  92
  93   family = client->priv->family;
  94   if (family == G_SOCKET_FAMILY_INVALID &&
  95       client->priv->local_address != NULL)
  96     family = g_socket_address_get_family (client->priv->local_address);
  97   if (family == G_SOCKET_FAMILY_INVALID)
  98     family = g_socket_address_get_family (dest_address);
  99
 100   socket = g_socket_new (family,
 101                          client->priv->type,
 102                          client->priv->protocol,
 103                          error);
 104   if (socket == NULL)
 105     return NULL;
 106
 107   if (client->priv->local_address)
 108     {
 109       if (!g_socket_bind (socket,
 110                           client->priv->local_address,
 111                           FALSE,
 112                           error))
 113         {
 114           g_object_unref (socket);
 115           return NULL;
 116         }
 117     }
 118
 119   return socket;
 120 }
 121
 122 static void
 123 g_socket_client_init (GSocketClient *client)
 124 {
 125   client->priv = G_TYPE_INSTANCE_GET_PRIVATE (client,
 126                                               G_TYPE_SOCKET_CLIENT,
 127                                               GSocketClientPrivate);
 128   client->priv->type = G_SOCKET_TYPE_STREAM;
 129 }
 130
 131 /**
 132  * g_socket_client_new:
 133  *
 134  * Creates a new #GSocketClient with the default options.
 135  *
 136  * Returns: a #GSocketClient.
 137  *     Free the returned object with g_object_unref().
 138  *
 139  * Since: 2.22
 140  */
 141 GSocketClient *
 142 g_socket_client_new (void)
 143 {
 144   return g_object_new (G_TYPE_SOCKET_CLIENT, NULL);
 145 }
 146
 147 static void
 148 g_socket_client_finalize (GObject *object)
 149 {
 150   GSocketClient *client = G_SOCKET_CLIENT (object);
 151
 152   if (client->priv->local_address)
 153     g_object_unref (client->priv->local_address);
 154
 155   if (G_OBJECT_CLASS (g_socket_client_parent_class)->finalize)
 156     (*G_OBJECT_CLASS (g_socket_client_parent_class)->finalize) (object);
 157 }
 158
 159 static void
 160 g_socket_client_get_property (GObject    *object,
 161                               guint       prop_id,
 162                               GValue     *value,
 163                               GParamSpec *pspec)
 164 {
 165   GSocketClient *client = G_SOCKET_CLIENT (object);
 166
 167   switch (prop_id)
 168     {
 169       case PROP_FAMILY:
 170         g_value_set_enum (value, client->priv->family);
 171         break;
 172
 173       case PROP_TYPE:
 174         g_value_set_enum (value, client->priv->type);
 175         break;
 176
 177       case PROP_PROTOCOL:
 178         g_value_set_enum (value, client->priv->protocol);
 179         break;
 180
 181       case PROP_LOCAL_ADDRESS:
 182         g_value_set_object (value, client->priv->local_address);
 183         break;
 184
 185       default:
 186         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 187     }
 188 }
 189
 190 static void
 191 g_socket_client_set_property (GObject      *object,
 192                               guint         prop_id,
 193                               const GValue *value,
 194                               GParamSpec   *pspec)
 195 {
 196   GSocketClient *client = G_SOCKET_CLIENT (object);
 197
 198   switch (prop_id)
 199     {
 200     case PROP_FAMILY:
 201       g_socket_client_set_family (client, g_value_get_enum (value));
 202       break;
 203
 204     case PROP_TYPE:
 205       g_socket_client_set_socket_type (client, g_value_get_enum (value));
 206       break;
 207
 208     case PROP_PROTOCOL:
 209       g_socket_client_set_protocol (client, g_value_get_enum (value));
 210       break;
 211
 212     case PROP_LOCAL_ADDRESS:
 213       g_socket_client_set_local_address (client, g_value_get_object (value));
 214       break;
 215
 216     default:
 217       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 218     }
 219 }
 220
 221 /**
 222  * g_socket_client_get_family:
 223  * @client: a #GSocketClient.
 224  *
 225  * Gets the socket family of the socket client.
 226  *
 227  * See g_socket_client_set_family() for details.
 228  *
 229  * Returns: a #GSocketFamily
 230  *
 231  * Since: 2.22
 232  */
 233 GSocketFamily
 234 g_socket_client_get_family (GSocketClient *client)
 235 {
 236   return client->priv->family;
 237 }
 238
 239 /**
 240  * g_socket_client_set_family:
 241  * @client: a #GSocketClient.
 242  * @family: a #GSocketFamily
 243  *
 244  * Sets the socket family of the socket client.
 245  * If this is set to something other than %G_SOCKET_FAMILY_INVALID
 246  * then the sockets created by this object will be of the specified
 247  * family.
 248  *
 249  * This might be useful for instance if you want to force the local
 250  * connection to be an ipv4 socket, even though the address might
 251  * be an ipv6 mapped to ipv4 address.
 252  *
 253  * Since: 2.22
 254  */
 255 void
 256 g_socket_client_set_family (GSocketClient *client,
 257                             GSocketFamily  family)
 258 {
 259   if (client->priv->family == family)
 260     return;
 261
 262   client->priv->family = family;
 263   g_object_notify (G_OBJECT (client), "family");
 264 }
 265
 266 /**
 267  * g_socket_client_get_socket_type:
 268  * @client: a #GSocketClient.
 269  *
 270  * Gets the socket type of the socket client.
 271  *
 272  * See g_socket_client_set_socket_type() for details.
 273  *
 274  * Returns: a #GSocketFamily
 275  *
 276  * Since: 2.22
 277  */
 278 GSocketType
 279 g_socket_client_get_socket_type (GSocketClient *client)
 280 {
 281   return client->priv->type;
 282 }
 283
 284 /**
 285  * g_socket_client_set_socket_type:
 286  * @client: a #GSocketClient.
 287  * @type: a #GSocketType
 288  *
 289  * Sets the socket type of the socket client.
 290  * The sockets created by this object will be of the specified
 291  * type.
 292  *
 293  * It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,
 294  * as GSocketClient is used for connection oriented services.
 295  *
 296  * Since: 2.22
 297  */
 298 void
 299 g_socket_client_set_socket_type (GSocketClient *client,
 300                                  GSocketType    type)
 301 {
 302   if (client->priv->type == type)
 303     return;
 304
 305   client->priv->type = type;
 306   g_object_notify (G_OBJECT (client), "type");
 307 }
 308
 309 /**
 310  * g_socket_client_get_protocol:
 311  * @client: a #GSocketClient
 312  *
 313  * Gets the protocol name type of the socket client.
 314  *
 315  * See g_socket_client_set_protocol() for details.
 316  *
 317  * Returns: a #GSocketProtocol
 318  *
 319  * Since: 2.22
 320  */
 321 GSocketProtocol
 322 g_socket_client_get_protocol (GSocketClient *client)
 323 {
 324   return client->priv->protocol;
 325 }
 326
 327 /**
 328  * g_socket_client_set_protocol:
 329  * @client: a #GSocketClient.
 330  * @protocol: a #GSocketProtocol
 331  *
 332  * Sets the protocol of the socket client.
 333  * The sockets created by this object will use of the specified
 334  * protocol.
 335  *
 336  * If @protocol is %0 that means to use the default
 337  * protocol for the socket family and type.
 338  *
 339  * Since: 2.22
 340  */
 341 void
 342 g_socket_client_set_protocol (GSocketClient   *client,
 343                               GSocketProtocol  protocol)
 344 {
 345   if (client->priv->protocol == protocol)
 346     return;
 347
 348   client->priv->protocol = protocol;
 349   g_object_notify (G_OBJECT (client), "protocol");
 350 }
 351
 352 /**
 353  * g_socket_client_get_local_address:
 354  * @client: a #GSocketClient.
 355  *
 356  * Gets the local address of the socket client.
 357  *
 358  * See g_socket_client_set_local_address() for details.
 359  *
 360  * Returns: a #GSocketAddres or %NULL. don't free
 361  *
 362  * Since: 2.22
 363  */
 364 GSocketAddress *
 365 g_socket_client_get_local_address (GSocketClient *client)
 366 {
 367   return client->priv->local_address;
 368 }
 369
 370 /**
 371  * g_socket_client_set_local_address:
 372  * @client: a #GSocketClient.
 373  * @address: a #GSocketAddress, or %NULL
 374  *
 375  * Sets the local address of the socket client.
 376  * The sockets created by this object will bound to the
 377  * specified address (if not %NULL) before connecting.
 378  *
 379  * This is useful if you want to ensure the the local
 380  * side of the connection is on a specific port, or on
 381  * a specific interface.
 382  *
 383  * Since: 2.22
 384  */
 385 void
 386 g_socket_client_set_local_address (GSocketClient  *client,
 387                                    GSocketAddress *address)
 388 {
 389   if (address)
 390   g_object_ref (address);
 391
 392   if (client->priv->local_address)
 393     {
 394       g_object_unref (client->priv->local_address);
 395     }
 396   client->priv->local_address = address;
 397   g_object_notify (G_OBJECT (client), "local-address");
 398 }
 399
 400 static void
 401 g_socket_client_class_init (GSocketClientClass *class)
 402 {
 403   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 404
 405   g_type_class_add_private (class, sizeof (GSocketClientPrivate));
 406
 407   gobject_class->finalize = g_socket_client_finalize;
 408   gobject_class->set_property = g_socket_client_set_property;
 409   gobject_class->get_property = g_socket_client_get_property;
 410
 411   g_object_class_install_property (gobject_class, PROP_FAMILY,
 412                                    g_param_spec_enum ("family",
 413                                                       P_("Socket family"),
 414                                                       P_("The sockets address family to use for socket construction"),
 415                                                       G_TYPE_SOCKET_FAMILY,
 416                                                       G_SOCKET_FAMILY_INVALID,
 417                                                       G_PARAM_CONSTRUCT |
 418                                                       G_PARAM_READWRITE |
 419                                                       G_PARAM_STATIC_STRINGS));
 420
 421   g_object_class_install_property (gobject_class, PROP_TYPE,
 422                                    g_param_spec_enum ("type",
 423                                                       P_("Socket type"),
 424                                                       P_("The sockets type to use for socket construction"),
 425                                                       G_TYPE_SOCKET_TYPE,
 426                                                       G_SOCKET_TYPE_STREAM,
 427                                                       G_PARAM_CONSTRUCT |
 428                                                       G_PARAM_READWRITE |
 429                                                       G_PARAM_STATIC_STRINGS));
 430
 431   g_object_class_install_property (gobject_class, PROP_PROTOCOL,
 432                                    g_param_spec_enum ("protocol",
 433                                                       P_("Socket protocol"),
 434                                                       P_("The protocol to use for socket construction, or 0 for default"),
 435                                                       G_TYPE_SOCKET_PROTOCOL,
 436                                                       G_SOCKET_PROTOCOL_DEFAULT,
 437                                                       G_PARAM_CONSTRUCT |
 438                                                       G_PARAM_READWRITE |
 439                                                       G_PARAM_STATIC_STRINGS));
 440
 441   g_object_class_install_property (gobject_class, PROP_LOCAL_ADDRESS,
 442                                    g_param_spec_object ("local-address",
 443                                                         P_("Local address"),
 444                                                         P_("The local address constructed sockets will be bound to"),
 445                                                         G_TYPE_SOCKET_ADDRESS,
 446                                                         G_PARAM_CONSTRUCT |
 447                                                         G_PARAM_READWRITE |
 448                                                         G_PARAM_STATIC_STRINGS));
 449 }
 450
 451 /**
 452  * g_socket_client_connect:
 453  * @client: a #GSocketClient.
 454  * @connectable: a #GSocketConnectable specifying the remote address.
 455  * @cancellable: optional #GCancellable object, %NULL to ignore.
 456  * @error: #GError for error reporting, or %NULL to ignore.
 457  *
 458  * Tries to resolve the @connectable and make a network connection to it..
 459  *
 460  * Upon a successful connection, a new #GSocketConnection is constructed
 461  * and returned.  The caller owns this new object and must drop their
 462  * reference to it when finished with it.
 463  *
 464  * The type of the #GSocketConnection object returned depends on the type of
 465  * the underlying socket that is used. For instance, for a TCP/IP connection
 466  * it will be a #GTcpConnection.
 467  *
 468  * The socket created will be the same family as the the address that the
 469  * @connectable resolves to, unless family is set with g_socket_client_set_family()
 470  * or indirectly via g_socket_client_set_local_address(). The socket type
 471  * defaults to %G_SOCKET_TYPE_STREAM but can be set with
 472  * g_socket_client_set_socket_type().
 473  *
 474  * If a local address is specified with g_socket_client_set_local_address() the
 475  * socket will be bound to this address before connecting.
 476  *
 477  * Returns: a #GSocketConnection on success, %NULL on error.
 478  *
 479  * Since: 2.22
 480  */
 481 GSocketConnection *
 482 g_socket_client_connect (GSocketClient       *client,
 483                          GSocketConnectable  *connectable,
 484                          GCancellable        *cancellable,
 485                          GError             **error)
 486 {
 487   GSocketConnection *connection = NULL;
 488   GSocketAddressEnumerator *enumerator;
 489   GError *last_error, *tmp_error;
 490
 491   last_error = NULL;
 492   enumerator = g_socket_connectable_enumerate (connectable);
 493   while (connection == NULL)
 494     {
 495       GSocketAddress *address;
 496       GSocket *socket;
 497
 498       if (g_cancellable_is_cancelled (cancellable))
 499         {
 500           g_clear_error (error);
 501           g_cancellable_set_error_if_cancelled (cancellable, error);
 502           break;
 503         }
 504
 505       tmp_error = NULL;
 506       address = g_socket_address_enumerator_next (enumerator, cancellable,
 507                                                   &tmp_error);
 508       if (address == NULL)
 509         {
 510           if (tmp_error)
 511             {
 512               g_clear_error (&last_error);
 513               g_propagate_error (error, tmp_error);
 514             }
 515           else if (last_error)
 516             {
 517               g_propagate_error (error, last_error);
 518             }
 519           else
 520             g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 521                                  _("Unknown error on connect"));
 522           break;
 523         }
 524
 525       /* clear error from previous attempt */
 526       g_clear_error (&last_error);
 527
 528       socket = create_socket (client, address, &last_error);
 529       if (socket != NULL)
 530         {
 531           if (g_socket_connect (socket, address, cancellable, &last_error))
 532             connection = g_socket_connection_factory_create_connection (socket);
 533
 534           g_object_unref (socket);
 535         }
 536
 537       g_object_unref (address);
 538     }
 539   g_object_unref (enumerator);
 540
 541   return connection;
 542 }
 543
 544 /**
 545  * g_socket_client_connect_to_host:
 546  * @client: a #SocketClient
 547  * @host_and_port: the name and optionally port of the host to connect to
 548  * @default_port: the default port to connect to
 549  * @cancellable: a #GCancellable, or %NULL
 550  * @error: a pointer to a #GError, or %NULL
 551  *
 552  * This is a helper function for g_socket_client_connect().
 553  *
 554  * Attempts to create a TCP connection to the named host.
 555  *
 556  * @host_and_port may be in any of a number of recognised formats: an IPv6
 557  * address, an IPv4 address, or a domain name (in which case a DNS
 558  * lookup is performed).  Quoting with [] is supported for all address
 559  * types.  A port override may be specified in the usual way with a
 560  * colon.  Ports may be given as decimal numbers or symbolic names (in
 561  * which case an /etc/services lookup is performed).
 562  *
 563  * If no port override is given in @host_and_port then @default_port will be
 564  * used as the port number to connect to.
 565  *
 566  * In general, @host_and_port is expected to be provided by the user (allowing
 567  * them to give the hostname, and a port overide if necessary) and
 568  * @default_port is expected to be provided by the application.
 569  *
 570  * In the case that an IP address is given, a single connection
 571  * attempt is made.  In the case that a name is given, multiple
 572  * connection attempts may be made, in turn and according to the
 573  * number of address records in DNS, until a connection succeeds.
 574  *
 575  * Upon a successful connection, a new #GSocketConnection is constructed
 576  * and returned.  The caller owns this new object and must drop their
 577  * reference to it when finished with it.
 578  *
 579  * In the event of any failure (DNS error, service not found, no hosts
 580  * connectable) %NULL is returned and @error (if non-%NULL) is set
 581  * accordingly.
 582  *
 583  Returns: a #GSocketConnection on success, %NULL on error.
 584  *
 585  * Since: 2.22
 586  */
 587 GSocketConnection *
 588 g_socket_client_connect_to_host (GSocketClient  *client,
 589                                  const gchar    *host_and_port,
 590                                  guint16         default_port,
 591                                  GCancellable   *cancellable,
 592                                  GError        **error)
 593 {
 594   GSocketConnectable *connectable;
 595   GSocketConnection *connection;
 596
 597   connectable = g_network_address_parse (host_and_port, default_port, error);
 598   if (connectable == NULL)
 599     return NULL;
 600
 601   connection = g_socket_client_connect (client, connectable,
 602                                         cancellable, error);
 603   g_object_unref (connectable);
 604
 605   return connection;
 606 }
 607
 608 /**
 609  * g_socket_client_connect_to_service:
 610  * @client: a #GSocketConnection
 611  * @domain: a domain name
 612  * @service: the name of the service to connect to
 613  * @cancellable: a #GCancellable, or %NULL
 614  * @error: a pointer to a #GError, or %NULL
 615  * @returns: a #GSocketConnection if successful, or %NULL on error
 616  *
 617  * Attempts to create a TCP connection to a service.
 618  *
 619  * This call looks up the SRV record for @service at @domain for the
 620  * "tcp" protocol.  It then attempts to connect, in turn, to each of
 621  * the hosts providing the service until either a connection succeeds
 622  * or there are no hosts remaining.
 623  *
 624  * Upon a successful connection, a new #GSocketConnection is constructed
 625  * and returned.  The caller owns this new object and must drop their
 626  * reference to it when finished with it.
 627  *
 628  * In the event of any failure (DNS error, service not found, no hosts
 629  * connectable) %NULL is returned and @error (if non-%NULL) is set
 630  * accordingly.
 631  */
 632 GSocketConnection *
 633 g_socket_client_connect_to_service (GSocketClient  *client,
 634                                     const gchar    *domain,
 635                                     const gchar    *service,
 636                                     GCancellable   *cancellable,
 637                                     GError        **error)
 638 {
 639   GSocketConnectable *connectable;
 640   GSocketConnection *connection;
 641
 642   connectable = g_network_service_new (service, "tcp", domain);
 643   connection = g_socket_client_connect (client, connectable,
 644                                         cancellable, error);
 645   g_object_unref (connectable);
 646
 647   return connection;
 648 }
 649
 650 typedef struct
 651 {
 652   GSimpleAsyncResult *result;
 653   GCancellable *cancellable;
 654   GSocketClient *client;
 655
 656   GSocketAddressEnumerator *enumerator;
 657   GSocket *current_socket;
 658
 659   GError *last_error;
 660 } GSocketClientAsyncConnectData;
 661
 662 static void
 663 g_socket_client_async_connect_complete (GSocketClientAsyncConnectData *data)
 664 {
 665   GSocketConnection *connection;
 666
 667   if (data->last_error)
 668     {
 669       g_simple_async_result_set_from_error (data->result, data->last_error);
 670       g_error_free (data->last_error);
 671     }
 672   else
 673     {
 674       g_assert (data->current_socket);
 675
 676       g_socket_set_blocking (data->current_socket, TRUE);
 677
 678       connection = g_socket_connection_factory_create_connection (data->current_socket);
 679       g_simple_async_result_set_op_res_gpointer (data->result,
 680                                                  connection,
 681                                                  g_object_unref);
 682     }
 683
 684   g_simple_async_result_complete (data->result);
 685   g_object_unref (data->result);
 686 }
 687
 688
 689 static void
 690 g_socket_client_enumerator_callback (GObject      *object,
 691                                      GAsyncResult *result,
 692                                      gpointer      user_data);
 693
 694 static void
 695 set_last_error (GSocketClientAsyncConnectData *data,
 696                 GError *error)
 697 {
 698   g_clear_error (&data->last_error);
 699   data->last_error = error;
 700 }
 701
 702 static gboolean
 703 g_socket_client_socket_callback (GSocket *socket,
 704                                  GIOCondition condition,
 705                                  GSocketClientAsyncConnectData *data)
 706 {
 707   GError *error = NULL;
 708
 709   if (g_cancellable_is_cancelled (data->cancellable))
 710     {
 711       /* Cancelled, return done with last error being cancelled */
 712       g_clear_error (&data->last_error);
 713       g_object_unref (data->current_socket);
 714       data->current_socket = NULL;
 715       g_cancellable_set_error_if_cancelled (data->cancellable,
 716                                             &data->last_error);
 717     }
 718   else
 719     {
 720       /* socket is ready for writing means connect done, did it succeed? */
 721       if (!g_socket_check_connect_result (data->current_socket, &error))
 722         {
 723           set_last_error (data, error);
 724
 725           /* try next one */
 726           g_socket_address_enumerator_next_async (data->enumerator,
 727                                                   data->cancellable,
 728                                                   g_socket_client_enumerator_callback,
 729                                                   data);
 730
 731           return FALSE;
 732         }
 733     }
 734
 735   g_socket_client_async_connect_complete (data);
 736
 737   return FALSE;
 738 }
 739
 740 static void
 741 g_socket_client_enumerator_callback (GObject      *object,
 742                                      GAsyncResult *result,
 743                                      gpointer      user_data)
 744 {
 745   GSocketClientAsyncConnectData *data = user_data;
 746   GSocketAddress *address;
 747   GSocket *socket;
 748   GError *tmp_error = NULL;
 749
 750   if (g_cancellable_is_cancelled (data->cancellable))
 751     {
 752       g_clear_error (&data->last_error);
 753       g_cancellable_set_error_if_cancelled (data->cancellable, &data->last_error);
 754       g_socket_client_async_connect_complete (data);
 755       return;
 756     }
 757
 758   address = g_socket_address_enumerator_next_finish (data->enumerator,
 759                                                      result, &tmp_error);
 760
 761   if (address == NULL)
 762     {
 763       if (tmp_error)
 764         set_last_error (data, tmp_error);
 765       else if (data->last_error == NULL)
 766         g_set_error_literal (&data->last_error, G_IO_ERROR, G_IO_ERROR_FAILED,
 767                              _("Unknown error on connect"));
 768
 769       g_socket_client_async_connect_complete (data);
 770       return;
 771     }
 772
 773   g_clear_error (&data->last_error);
 774
 775   socket = create_socket (data->client, address, &data->last_error);
 776   if (socket != NULL)
 777     {
 778       g_socket_set_blocking (socket, FALSE);
 779       if (g_socket_connect (socket, address, data->cancellable, &tmp_error))
 780         {
 781           data->current_socket = socket;
 782           g_socket_client_async_connect_complete (data);
 783
 784           g_object_unref (address);
 785           return;
 786         }
 787       else if (g_error_matches (tmp_error, G_IO_ERROR, G_IO_ERROR_PENDING))
 788         {
 789           GSource *source;
 790
 791           data->current_socket = socket;
 792           g_error_free (tmp_error);
 793
 794           source = g_socket_create_source (socket, G_IO_OUT,
 795                                            data->cancellable);
 796           g_source_set_callback (source,
 797                                  (GSourceFunc) g_socket_client_socket_callback,
 798                                  data, NULL);
 799           g_source_attach (source, g_main_context_get_thread_default ());
 800           g_source_unref (source);
 801
 802           g_object_unref (address);
 803           return;
 804         }
 805       else
 806         {
 807           data->last_error = tmp_error;
 808           g_object_unref (socket);
 809         }
 810       g_object_unref (address);
 811     }
 812
 813   g_socket_address_enumerator_next_async (data->enumerator,
 814                                           data->cancellable,
 815                                           g_socket_client_enumerator_callback,
 816                                           data);
 817 }
 818
 819 /**
 820  * g_socket_client_connect_async:
 821  * @client: a #GTcpClient
 822  * @connectable: a #GSocketConnectable specifying the remote address.
 823  * @cancellable: a #GCancellable, or %NULL
 824  * @callback: a #GAsyncReadyCallback
 825  * @user_data: user data for the callback
 826  *
 827  * This is the asynchronous version of g_socket_client_connect().
 828  *
 829  * When the operation is finished @callback will be
 830  * called. You can then call g_socket_client_connect_finish() to get
 831  * the result of the operation.
 832  *
 833  * Since: 2.22
 834  */
 835 void
 836 g_socket_client_connect_async (GSocketClient       *client,
 837                                GSocketConnectable  *connectable,
 838                                GCancellable        *cancellable,
 839                                GAsyncReadyCallback  callback,
 840                                gpointer             user_data)
 841 {
 842   GSocketClientAsyncConnectData *data;
 843
 844   g_return_if_fail (G_IS_SOCKET_CLIENT (client));
 845
 846   data = g_slice_new (GSocketClientAsyncConnectData);
 847
 848   data->result = g_simple_async_result_new (G_OBJECT (client),
 849                                             callback, user_data,
 850                                             g_socket_client_connect_async);
 851   data->client = client;
 852   if (cancellable)
 853     data->cancellable = g_object_ref (cancellable);
 854   else
 855     data->cancellable = NULL;
 856   data->last_error = NULL;
 857   data->enumerator = g_socket_connectable_enumerate (connectable);
 858
 859   g_socket_address_enumerator_next_async (data->enumerator, cancellable,
 860                                           g_socket_client_enumerator_callback,
 861                                           data);
 862 }
 863
 864 /**
 865  * g_socket_client_connect_to_host_async:
 866  * @client: a #GTcpClient
 867  * @host_and_port: the name and optionally the port of the host to connect to
 868  * @default_port: the default port to connect to
 869  * @cancellable: a #GCancellable, or %NULL
 870  * @callback: a #GAsyncReadyCallback
 871  * @user_data: user data for the callback
 872  *
 873  * This is the asynchronous version of g_socket_client_connect_to_host().
 874  *
 875  * When the operation is finished @callback will be
 876  * called. You can then call g_socket_client_connect_to_host_finish() to get
 877  * the result of the operation.
 878  *
 879  * Since: 2.22
 880  */
 881 void
 882 g_socket_client_connect_to_host_async (GSocketClient        *client,
 883                                        const gchar          *host_and_port,
 884                                        guint16               default_port,
 885                                        GCancellable         *cancellable,
 886                                        GAsyncReadyCallback   callback,
 887                                        gpointer              user_data)
 888 {
 889   GSocketConnectable *connectable;
 890   GError *error;
 891
 892   error = NULL;
 893   connectable = g_network_address_parse (host_and_port, default_port,
 894                                          &error);
 895   if (connectable == NULL)
 896     {
 897       g_simple_async_report_gerror_in_idle (G_OBJECT (client),
 898                                             callback, user_data, error);
 899       g_error_free (error);
 900     }
 901   else
 902     {
 903       g_socket_client_connect_async (client,
 904                                      connectable, cancellable,
 905                                      callback, user_data);
 906       g_object_unref (connectable);
 907     }
 908 }
 909
 910 /**
 911  * g_socket_client_connect_to_service_async:
 912  * @client: a #GSocketClient
 913  * @domain: a domain name
 914  * @service: the name of the service to connect to
 915  * @cancellable: a #GCancellable, or %NULL
 916  * @callback: a #GAsyncReadyCallback
 917  * @user_data: user data for the callback
 918  *
 919  * This is the asynchronous version of
 920  * g_socket_client_connect_to_service().
 921  *
 922  * Since: 2.22
 923  */
 924 void
 925 g_socket_client_connect_to_service_async (GSocketClient       *client,
 926                                           const gchar         *domain,
 927                                           const gchar         *service,
 928                                           GCancellable        *cancellable,
 929                                           GAsyncReadyCallback  callback,
 930                                           gpointer             user_data)
 931 {
 932   GSocketConnectable *connectable;
 933
 934   connectable = g_network_service_new (service, "tcp", domain);
 935   g_socket_client_connect_async (client,
 936                                  connectable, cancellable,
 937                                  callback, user_data);
 938   g_object_unref (connectable);
 939 }
 940
 941 /**
 942  * g_socket_client_connect_finish:
 943  * @client: a #GSocketClient.
 944  * @result: a #GAsyncResult.
 945  * @error: a #GError location to store the error occuring, or %NULL to
 946  * ignore.
 947  *
 948  * Finishes an async connect operation. See g_socket_client_connect_async()
 949  *
 950  * Returns: a #GSocketConnection on success, %NULL on error.
 951  *
 952  * Since: 2.22
 953  */
 954 GSocketConnection *
 955 g_socket_client_connect_finish (GSocketClient  *client,
 956                                 GAsyncResult   *result,
 957                                 GError        **error)
 958 {
 959   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 960
 961   if (g_simple_async_result_propagate_error (simple, error))
 962     return NULL;
 963
 964   return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
 965 }
 966
 967 /**
 968  * g_socket_client_connect_to_host_finish:
 969  * @client: a #GSocketClient.
 970  * @result: a #GAsyncResult.
 971  * @error: a #GError location to store the error occuring, or %NULL to
 972  * ignore.
 973  *
 974  * Finishes an async connect operation. See g_socket_client_connect_to_host_async()
 975  *
 976  * Returns: a #GSocketConnection on success, %NULL on error.
 977  *
 978  * Since: 2.22
 979  */
 980 GSocketConnection *
 981 g_socket_client_connect_to_host_finish (GSocketClient  *client,
 982                                         GAsyncResult   *result,
 983                                         GError        **error)
 984 {
 985   return g_socket_client_connect_finish (client, result, error);
 986 }
 987
 988 /**
 989  * g_socket_client_connect_to_service_finish:
 990  * @client: a #GSocketClient.
 991  * @result: a #GAsyncResult.
 992  * @error: a #GError location to store the error occuring, or %NULL to
 993  * ignore.
 994  *
 995  * Finishes an async connect operation. See g_socket_client_connect_to_service_async()
 996  *
 997  * Returns: a #GSocketConnection on success, %NULL on error.
 998  *
 999  * Since: 2.22
1000  */
1001 GSocketConnection *
1002 g_socket_client_connect_to_service_finish (GSocketClient  *client,
1003                                            GAsyncResult   *result,
1004                                            GError        **error)
1005 {
1006   return g_socket_client_connect_finish (client, result, error);
1007 }
1008
1009 #define __G_SOCKET_CLIENT_C__
1010 #include "gioaliasdef.c"