Merge remote branch 'gvdb/master'
[platform/upstream/glib.git] / 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"