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_object_unref (data->current_socket);
 680       g_simple_async_result_set_op_res_gpointer (data->result,
 681                                                  connection,
 682                                                  g_object_unref);
 683     }
 684
 685   g_simple_async_result_complete (data->result);
 686   g_object_unref (data->result);
 687   g_object_unref (data->enumerator);
 688   g_slice_free (GSocketClientAsyncConnectData, data);
 689 }
 690
 691
 692 static void
 693 g_socket_client_enumerator_callback (GObject      *object,
 694                                      GAsyncResult *result,
 695                                      gpointer      user_data);
 696
 697 static void
 698 set_last_error (GSocketClientAsyncConnectData *data,
 699                 GError *error)
 700 {
 701   g_clear_error (&data->last_error);
 702   data->last_error = error;
 703 }
 704
 705 static gboolean
 706 g_socket_client_socket_callback (GSocket *socket,
 707                                  GIOCondition condition,
 708                                  GSocketClientAsyncConnectData *data)
 709 {
 710   GError *error = NULL;
 711
 712   if (g_cancellable_is_cancelled (data->cancellable))
 713     {
 714       /* Cancelled, return done with last error being cancelled */
 715       g_clear_error (&data->last_error);
 716       g_object_unref (data->current_socket);
 717       data->current_socket = NULL;
 718       g_cancellable_set_error_if_cancelled (data->cancellable,
 719                                             &data->last_error);
 720     }
 721   else
 722     {
 723       /* socket is ready for writing means connect done, did it succeed? */
 724       if (!g_socket_check_connect_result (data->current_socket, &error))
 725         {
 726           set_last_error (data, error);
 727
 728           /* try next one */
 729           g_socket_address_enumerator_next_async (data->enumerator,
 730                                                   data->cancellable,
 731                                                   g_socket_client_enumerator_callback,
 732                                                   data);
 733
 734           return FALSE;
 735         }
 736     }
 737
 738   g_socket_client_async_connect_complete (data);
 739
 740   return FALSE;
 741 }
 742
 743 static void
 744 g_socket_client_enumerator_callback (GObject      *object,
 745                                      GAsyncResult *result,
 746                                      gpointer      user_data)
 747 {
 748   GSocketClientAsyncConnectData *data = user_data;
 749   GSocketAddress *address;
 750   GSocket *socket;
 751   GError *tmp_error = NULL;
 752
 753   if (g_cancellable_is_cancelled (data->cancellable))
 754     {
 755       g_clear_error (&data->last_error);
 756       g_cancellable_set_error_if_cancelled (data->cancellable, &data->last_error);
 757       g_socket_client_async_connect_complete (data);
 758       return;
 759     }
 760
 761   address = g_socket_address_enumerator_next_finish (data->enumerator,
 762                                                      result, &tmp_error);
 763
 764   if (address == NULL)
 765     {
 766       if (tmp_error)
 767         set_last_error (data, tmp_error);
 768       else if (data->last_error == NULL)
 769         g_set_error_literal (&data->last_error, G_IO_ERROR, G_IO_ERROR_FAILED,
 770                              _("Unknown error on connect"));
 771
 772       g_socket_client_async_connect_complete (data);
 773       return;
 774     }
 775
 776   g_clear_error (&data->last_error);
 777
 778   socket = create_socket (data->client, address, &data->last_error);
 779   if (socket != NULL)
 780     {
 781       g_socket_set_blocking (socket, FALSE);
 782       if (g_socket_connect (socket, address, data->cancellable, &tmp_error))
 783         {
 784           data->current_socket = socket;
 785           g_socket_client_async_connect_complete (data);
 786
 787           g_object_unref (address);
 788           return;
 789         }
 790       else if (g_error_matches (tmp_error, G_IO_ERROR, G_IO_ERROR_PENDING))
 791         {
 792           GSource *source;
 793
 794           data->current_socket = socket;
 795           g_error_free (tmp_error);
 796
 797           source = g_socket_create_source (socket, G_IO_OUT,
 798                                            data->cancellable);
 799           g_source_set_callback (source,
 800                                  (GSourceFunc) g_socket_client_socket_callback,
 801                                  data, NULL);
 802           g_source_attach (source, g_main_context_get_thread_default ());
 803           g_source_unref (source);
 804
 805           g_object_unref (address);
 806           return;
 807         }
 808       else
 809         {
 810           data->last_error = tmp_error;
 811           g_object_unref (socket);
 812         }
 813       g_object_unref (address);
 814     }
 815
 816   g_socket_address_enumerator_next_async (data->enumerator,
 817                                           data->cancellable,
 818                                           g_socket_client_enumerator_callback,
 819                                           data);
 820 }
 821
 822 /**
 823  * g_socket_client_connect_async:
 824  * @client: a #GTcpClient
 825  * @connectable: a #GSocketConnectable specifying the remote address.
 826  * @cancellable: a #GCancellable, or %NULL
 827  * @callback: a #GAsyncReadyCallback
 828  * @user_data: user data for the callback
 829  *
 830  * This is the asynchronous version of g_socket_client_connect().
 831  *
 832  * When the operation is finished @callback will be
 833  * called. You can then call g_socket_client_connect_finish() to get
 834  * the result of the operation.
 835  *
 836  * Since: 2.22
 837  */
 838 void
 839 g_socket_client_connect_async (GSocketClient       *client,
 840                                GSocketConnectable  *connectable,
 841                                GCancellable        *cancellable,
 842                                GAsyncReadyCallback  callback,
 843                                gpointer             user_data)
 844 {
 845   GSocketClientAsyncConnectData *data;
 846
 847   g_return_if_fail (G_IS_SOCKET_CLIENT (client));
 848
 849   data = g_slice_new (GSocketClientAsyncConnectData);
 850
 851   data->result = g_simple_async_result_new (G_OBJECT (client),
 852                                             callback, user_data,
 853                                             g_socket_client_connect_async);
 854   data->client = client;
 855   if (cancellable)
 856     data->cancellable = g_object_ref (cancellable);
 857   else
 858     data->cancellable = NULL;
 859   data->last_error = NULL;
 860   data->enumerator = g_socket_connectable_enumerate (connectable);
 861
 862   g_socket_address_enumerator_next_async (data->enumerator, cancellable,
 863                                           g_socket_client_enumerator_callback,
 864                                           data);
 865 }
 866
 867 /**
 868  * g_socket_client_connect_to_host_async:
 869  * @client: a #GTcpClient
 870  * @host_and_port: the name and optionally the port of the host to connect to
 871  * @default_port: the default port to connect to
 872  * @cancellable: a #GCancellable, or %NULL
 873  * @callback: a #GAsyncReadyCallback
 874  * @user_data: user data for the callback
 875  *
 876  * This is the asynchronous version of g_socket_client_connect_to_host().
 877  *
 878  * When the operation is finished @callback will be
 879  * called. You can then call g_socket_client_connect_to_host_finish() to get
 880  * the result of the operation.
 881  *
 882  * Since: 2.22
 883  */
 884 void
 885 g_socket_client_connect_to_host_async (GSocketClient        *client,
 886                                        const gchar          *host_and_port,
 887                                        guint16               default_port,
 888                                        GCancellable         *cancellable,
 889                                        GAsyncReadyCallback   callback,
 890                                        gpointer              user_data)
 891 {
 892   GSocketConnectable *connectable;
 893   GError *error;
 894
 895   error = NULL;
 896   connectable = g_network_address_parse (host_and_port, default_port,
 897                                          &error);
 898   if (connectable == NULL)
 899     {
 900       g_simple_async_report_gerror_in_idle (G_OBJECT (client),
 901                                             callback, user_data, error);
 902       g_error_free (error);
 903     }
 904   else
 905     {
 906       g_socket_client_connect_async (client,
 907                                      connectable, cancellable,
 908                                      callback, user_data);
 909       g_object_unref (connectable);
 910     }
 911 }
 912
 913 /**
 914  * g_socket_client_connect_to_service_async:
 915  * @client: a #GSocketClient
 916  * @domain: a domain name
 917  * @service: the name of the service to connect to
 918  * @cancellable: a #GCancellable, or %NULL
 919  * @callback: a #GAsyncReadyCallback
 920  * @user_data: user data for the callback
 921  *
 922  * This is the asynchronous version of
 923  * g_socket_client_connect_to_service().
 924  *
 925  * Since: 2.22
 926  */
 927 void
 928 g_socket_client_connect_to_service_async (GSocketClient       *client,
 929                                           const gchar         *domain,
 930                                           const gchar         *service,
 931                                           GCancellable        *cancellable,
 932                                           GAsyncReadyCallback  callback,
 933                                           gpointer             user_data)
 934 {
 935   GSocketConnectable *connectable;
 936
 937   connectable = g_network_service_new (service, "tcp", domain);
 938   g_socket_client_connect_async (client,
 939                                  connectable, cancellable,
 940                                  callback, user_data);
 941   g_object_unref (connectable);
 942 }
 943
 944 /**
 945  * g_socket_client_connect_finish:
 946  * @client: a #GSocketClient.
 947  * @result: a #GAsyncResult.
 948  * @error: a #GError location to store the error occuring, or %NULL to
 949  * ignore.
 950  *
 951  * Finishes an async connect operation. See g_socket_client_connect_async()
 952  *
 953  * Returns: a #GSocketConnection on success, %NULL on error.
 954  *
 955  * Since: 2.22
 956  */
 957 GSocketConnection *
 958 g_socket_client_connect_finish (GSocketClient  *client,
 959                                 GAsyncResult   *result,
 960                                 GError        **error)
 961 {
 962   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 963
 964   if (g_simple_async_result_propagate_error (simple, error))
 965     return NULL;
 966
 967   return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
 968 }
 969
 970 /**
 971  * g_socket_client_connect_to_host_finish:
 972  * @client: a #GSocketClient.
 973  * @result: a #GAsyncResult.
 974  * @error: a #GError location to store the error occuring, or %NULL to
 975  * ignore.
 976  *
 977  * Finishes an async connect operation. See g_socket_client_connect_to_host_async()
 978  *
 979  * Returns: a #GSocketConnection on success, %NULL on error.
 980  *
 981  * Since: 2.22
 982  */
 983 GSocketConnection *
 984 g_socket_client_connect_to_host_finish (GSocketClient  *client,
 985                                         GAsyncResult   *result,
 986                                         GError        **error)
 987 {
 988   return g_socket_client_connect_finish (client, result, error);
 989 }
 990
 991 /**
 992  * g_socket_client_connect_to_service_finish:
 993  * @client: a #GSocketClient.
 994  * @result: a #GAsyncResult.
 995  * @error: a #GError location to store the error occuring, or %NULL to
 996  * ignore.
 997  *
 998  * Finishes an async connect operation. See g_socket_client_connect_to_service_async()
 999  *
1000  * Returns: a #GSocketConnection on success, %NULL on error.
1001  *
1002  * Since: 2.22
1003  */
1004 GSocketConnection *
1005 g_socket_client_connect_to_service_finish (GSocketClient  *client,
1006                                            GAsyncResult   *result,
1007                                            GError        **error)
1008 {
1009   return g_socket_client_connect_finish (client, result, error);
1010 }
1011
1012 #define __G_SOCKET_CLIENT_C__
1013 #include "gioaliasdef.c"