Use g_simple_async_result_{new_,}take_error
[platform/upstream/glib.git] / gio / gsocketlistener.c
1 /* GIO - GLib Input, Output and Streaming Library
2  *
3  * Copyright © 2008 Christian Kellner, Samuel Cormier-Iijima
4  * Copyright © 2009 codethink
5  * Copyright © 2009 Red Hat, Inc
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General
18  * Public License along with this library; if not, write to the
19  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20  * Boston, MA 02111-1307, USA.
21  *
22  * Authors: Christian Kellner <gicmo@gnome.org>
23  *          Samuel Cormier-Iijima <sciyoshi@gmail.com>
24  *          Ryan Lortie <desrt@desrt.ca>
25  *          Alexander Larsson <alexl@redhat.com>
26  */
27
28 #include "config.h"
29 #include "gsocketlistener.h"
30
31 #include <gio/gsimpleasyncresult.h>
32 #include <gio/gcancellable.h>
33 #include <gio/gsocketaddress.h>
34 #include <gio/ginetaddress.h>
35 #include <gio/gioerror.h>
36 #include <gio/gsocket.h>
37 #include <gio/gsocketconnection.h>
38 #include <gio/ginetsocketaddress.h>
39 #include "glibintl.h"
40
41
42 /**
43  * SECTION: gsocketlistener
44  * @title: GSocketListener
45  * @short_description: Helper for accepting network client connections
46  * @see_also: #GThreadedSocketService, #GSocketService.
47  *
48  * A #GSocketListener is an object that keeps track of a set
49  * of server sockets and helps you accept sockets from any of the
50  * socket, either sync or async.
51  *
52  * If you want to implement a network server, also look at #GSocketService
53  * and #GThreadedSocketService which are subclass of #GSocketListener
54  * that makes this even easier.
55  *
56  * Since: 2.22
57  */
58
59 G_DEFINE_TYPE (GSocketListener, g_socket_listener, G_TYPE_OBJECT);
60
61 enum
62 {
63   PROP_0,
64   PROP_LISTEN_BACKLOG
65 };
66
67
68 static GQuark source_quark = 0;
69
70 struct _GSocketListenerPrivate
71 {
72   GPtrArray           *sockets;
73   GMainContext        *main_context;
74   int                 listen_backlog;
75   guint               closed : 1;
76 };
77
78 static void
79 g_socket_listener_finalize (GObject *object)
80 {
81   GSocketListener *listener = G_SOCKET_LISTENER (object);
82
83   if (listener->priv->main_context)
84     g_main_context_unref (listener->priv->main_context);
85
86   if (!listener->priv->closed)
87     g_socket_listener_close (listener);
88
89   g_ptr_array_free (listener->priv->sockets, TRUE);
90
91   G_OBJECT_CLASS (g_socket_listener_parent_class)
92     ->finalize (object);
93 }
94
95 static void
96 g_socket_listener_get_property (GObject    *object,
97                                 guint       prop_id,
98                                 GValue     *value,
99                                 GParamSpec *pspec)
100 {
101   GSocketListener *listener = G_SOCKET_LISTENER (object);
102
103   switch (prop_id)
104     {
105       case PROP_LISTEN_BACKLOG:
106         g_value_set_int (value, listener->priv->listen_backlog);
107         break;
108
109       default:
110         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
111     }
112 }
113
114 static void
115 g_socket_listener_set_property (GObject      *object,
116                                 guint         prop_id,
117                                 const GValue *value,
118                                 GParamSpec   *pspec)
119 {
120   GSocketListener *listener = G_SOCKET_LISTENER (object);
121
122   switch (prop_id)
123     {
124       case PROP_LISTEN_BACKLOG:
125         g_socket_listener_set_backlog (listener, g_value_get_int (value));
126         break;
127
128       default:
129         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
130     }
131 }
132
133
134 static void
135 g_socket_listener_class_init (GSocketListenerClass *klass)
136 {
137   GObjectClass *gobject_class G_GNUC_UNUSED = G_OBJECT_CLASS (klass);
138
139   g_type_class_add_private (klass, sizeof (GSocketListenerPrivate));
140
141   gobject_class->finalize = g_socket_listener_finalize;
142   gobject_class->set_property = g_socket_listener_set_property;
143   gobject_class->get_property = g_socket_listener_get_property;
144   g_object_class_install_property (gobject_class, PROP_LISTEN_BACKLOG,
145                                    g_param_spec_int ("listen-backlog",
146                                                      P_("Listen backlog"),
147                                                      P_("outstanding connections in the listen queue"),
148                                                      0,
149                                                      2000,
150                                                      10,
151                                                      G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
152
153   source_quark = g_quark_from_static_string ("g-socket-listener-source");
154 }
155
156 static void
157 g_socket_listener_init (GSocketListener *listener)
158 {
159   listener->priv = G_TYPE_INSTANCE_GET_PRIVATE (listener,
160                                                 G_TYPE_SOCKET_LISTENER,
161                                                 GSocketListenerPrivate);
162   listener->priv->sockets =
163     g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
164   listener->priv->listen_backlog = 10;
165 }
166
167 /**
168  * g_socket_listener_new:
169  *
170  * Creates a new #GSocketListener with no sockets to listen for.
171  * New listeners can be added with e.g. g_socket_listener_add_address()
172  * or g_socket_listener_add_inet_port().
173  *
174  * Returns: a new #GSocketListener.
175  *
176  * Since: 2.22
177  */
178 GSocketListener *
179 g_socket_listener_new (void)
180 {
181   return g_object_new (G_TYPE_SOCKET_LISTENER, NULL);
182 }
183
184 static gboolean
185 check_listener (GSocketListener *listener,
186                 GError **error)
187 {
188   if (listener->priv->closed)
189     {
190       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
191                            _("Listener is already closed"));
192       return FALSE;
193     }
194
195   return TRUE;
196 }
197
198 /**
199  * g_socket_listener_add_socket:
200  * @listener: a #GSocketListener
201  * @socket: a listening #GSocket
202  * @source_object: Optional #GObject identifying this source
203  * @error: #GError for error reporting, or %NULL to ignore.
204  *
205  * Adds @socket to the set of sockets that we try to accept
206  * new clients from. The socket must be bound to a local
207  * address and listened to.
208  *
209  * @source_object will be passed out in the various calls
210  * to accept to identify this particular source, which is
211  * useful if you're listening on multiple addresses and do
212  * different things depending on what address is connected to.
213  *
214  * Returns: %TRUE on success, %FALSE on error.
215  *
216  * Since: 2.22
217  */
218 gboolean
219 g_socket_listener_add_socket (GSocketListener  *listener,
220                               GSocket          *socket,
221                               GObject          *source_object,
222                               GError          **error)
223 {
224   if (!check_listener (listener, error))
225     return FALSE;
226
227   /* TODO: Check that socket it is bound & not closed? */
228
229   if (g_socket_is_closed (socket))
230     {
231       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
232                            _("Added socket is closed"));
233       return FALSE;
234     }
235
236   g_object_ref (socket);
237   g_ptr_array_add (listener->priv->sockets, socket);
238
239   if (source_object)
240     g_object_set_qdata_full (G_OBJECT (socket), source_quark,
241                              g_object_ref (source_object), g_object_unref);
242
243
244   if (G_SOCKET_LISTENER_GET_CLASS (listener)->changed)
245     G_SOCKET_LISTENER_GET_CLASS (listener)->changed (listener);
246
247   return TRUE;
248 }
249
250 /**
251  * g_socket_listener_add_address:
252  * @listener: a #GSocketListener
253  * @address: a #GSocketAddress
254  * @type: a #GSocketType
255  * @protocol: a #GSocketProtocol
256  * @source_object: Optional #GObject identifying this source
257  * @effective_address: (out) (allow-none): location to store the address that was bound to, or %NULL.
258  * @error: #GError for error reporting, or %NULL to ignore.
259  *
260  * Creates a socket of type @type and protocol @protocol, binds
261  * it to @address and adds it to the set of sockets we're accepting
262  * sockets from.
263  *
264  * Note that adding an IPv6 address, depending on the platform,
265  * may or may not result in a listener that also accepts IPv4
266  * connections.  For more determinstic behaviour, see
267  * g_socket_listener_add_inet_port().
268  *
269  * @source_object will be passed out in the various calls
270  * to accept to identify this particular source, which is
271  * useful if you're listening on multiple addresses and do
272  * different things depending on what address is connected to.
273  *
274  * If successful and @effective_address is non-%NULL then it will
275  * be set to the address that the binding actually occured at.  This
276  * is helpful for determining the port number that was used for when
277  * requesting a binding to port 0 (ie: "any port").  This address, if
278  * requested, belongs to the caller and must be freed.
279  *
280  * Returns: %TRUE on success, %FALSE on error.
281  *
282  * Since: 2.22
283  */
284 gboolean
285 g_socket_listener_add_address (GSocketListener  *listener,
286                                GSocketAddress   *address,
287                                GSocketType       type,
288                                GSocketProtocol   protocol,
289                                GObject          *source_object,
290                                GSocketAddress  **effective_address,
291                                GError          **error)
292 {
293   GSocketAddress *local_address;
294   GSocketFamily family;
295   GSocket *socket;
296
297   if (!check_listener (listener, error))
298     return FALSE;
299
300   family = g_socket_address_get_family (address);
301   socket = g_socket_new (family, type, protocol, error);
302   if (socket == NULL)
303     return FALSE;
304
305   g_socket_set_listen_backlog (socket, listener->priv->listen_backlog);
306
307   if (!g_socket_bind (socket, address, TRUE, error) ||
308       !g_socket_listen (socket, error))
309     {
310       g_object_unref (socket);
311       return FALSE;
312     }
313
314   local_address = NULL;
315   if (effective_address)
316     {
317       local_address = g_socket_get_local_address (socket, error);
318       if (local_address == NULL)
319         {
320           g_object_unref (socket);
321           return FALSE;
322         }
323     }
324
325   if (!g_socket_listener_add_socket (listener, socket,
326                                      source_object,
327                                      error))
328     {
329       if (local_address)
330         g_object_unref (local_address);
331       g_object_unref (socket);
332       return FALSE;
333     }
334
335   if (effective_address)
336     *effective_address = local_address;
337
338   g_object_unref (socket); /* add_socket refs this */
339
340   return TRUE;
341 }
342
343 /**
344  * g_socket_listener_add_inet_port:
345  * @listener: a #GSocketListener
346  * @port: an IP port number (non-zero)
347  * @source_object: Optional #GObject identifying this source
348  * @error: #GError for error reporting, or %NULL to ignore.
349  *
350  * Helper function for g_socket_listener_add_address() that
351  * creates a TCP/IP socket listening on IPv4 and IPv6 (if
352  * supported) on the specified port on all interfaces.
353  *
354  * @source_object will be passed out in the various calls
355  * to accept to identify this particular source, which is
356  * useful if you're listening on multiple addresses and do
357  * different things depending on what address is connected to.
358  *
359  * Returns: %TRUE on success, %FALSE on error.
360  *
361  * Since: 2.22
362  */
363 gboolean
364 g_socket_listener_add_inet_port (GSocketListener  *listener,
365                                  guint16           port,
366                                  GObject          *source_object,
367                                  GError          **error)
368 {
369   gboolean need_ipv4_socket = TRUE;
370   GSocket *socket4 = NULL;
371   GSocket *socket6;
372
373   g_return_val_if_fail (listener != NULL, FALSE);
374   g_return_val_if_fail (port != 0, FALSE);
375
376   if (!check_listener (listener, error))
377     return FALSE;
378
379   /* first try to create an IPv6 socket */
380   socket6 = g_socket_new (G_SOCKET_FAMILY_IPV6,
381                           G_SOCKET_TYPE_STREAM,
382                           G_SOCKET_PROTOCOL_DEFAULT,
383                           NULL);
384
385   if (socket6 != NULL)
386     /* IPv6 is supported on this platform, so if we fail now it is
387      * a result of being unable to bind to our port.  Don't fail
388      * silently as a result of this!
389      */
390     {
391       GInetAddress *inet_address;
392       GSocketAddress *address;
393       gboolean result;
394
395       inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV6);
396       address = g_inet_socket_address_new (inet_address, port);
397       g_object_unref (inet_address);
398
399       g_socket_set_listen_backlog (socket6, listener->priv->listen_backlog);
400
401       result = g_socket_bind (socket6, address, TRUE, error) &&
402                g_socket_listen (socket6, error);
403
404       g_object_unref (address);
405
406       if (!result)
407         {
408           g_object_unref (socket6);
409
410           return FALSE;
411         }
412
413       if (source_object)
414         g_object_set_qdata_full (G_OBJECT (socket6), source_quark,
415                                  g_object_ref (source_object),
416                                  g_object_unref);
417
418       /* If this socket already speaks IPv4 then we are done. */
419       if (g_socket_speaks_ipv4 (socket6))
420         need_ipv4_socket = FALSE;
421     }
422
423   if (need_ipv4_socket)
424     /* We are here for exactly one of the following reasons:
425      *
426      *   - our platform doesn't support IPv6
427      *   - we successfully created an IPv6 socket but it's V6ONLY
428      *
429      * In either case, we need to go ahead and create an IPv4 socket
430      * and fail the call if we can't bind to it.
431      */
432     {
433       socket4 = g_socket_new (G_SOCKET_FAMILY_IPV4,
434                               G_SOCKET_TYPE_STREAM,
435                               G_SOCKET_PROTOCOL_DEFAULT,
436                               error);
437
438       if (socket4 != NULL)
439         /* IPv4 is supported on this platform, so if we fail now it is
440          * a result of being unable to bind to our port.  Don't fail
441          * silently as a result of this!
442          */
443         {
444           GInetAddress *inet_address;
445           GSocketAddress *address;
446           gboolean result;
447
448           inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
449           address = g_inet_socket_address_new (inet_address, port);
450           g_object_unref (inet_address);
451
452           g_socket_set_listen_backlog (socket4,
453                                        listener->priv->listen_backlog);
454
455           result = g_socket_bind (socket4, address, TRUE, error) &&
456                    g_socket_listen (socket4, error);
457
458           g_object_unref (address);
459
460           if (!result)
461             {
462               g_object_unref (socket4);
463
464               if (socket6 != NULL)
465                 g_object_unref (socket6);
466
467               return FALSE;
468             }
469
470           if (source_object)
471             g_object_set_qdata_full (G_OBJECT (socket4), source_quark,
472                                      g_object_ref (source_object),
473                                      g_object_unref);
474         }
475       else
476         /* Ok.  So IPv4 is not supported on this platform.  If we
477          * succeeded at creating an IPv6 socket then that's OK, but
478          * otherwise we need to tell the user we failed.
479          */
480         {
481           if (socket6 != NULL)
482             g_clear_error (error);
483           else
484             return FALSE;
485         }
486     }
487
488   g_assert (socket6 != NULL || socket4 != NULL);
489
490   if (socket6 != NULL)
491     g_ptr_array_add (listener->priv->sockets, socket6);
492
493   if (socket4 != NULL)
494     g_ptr_array_add (listener->priv->sockets, socket4);
495
496   if (G_SOCKET_LISTENER_GET_CLASS (listener)->changed)
497     G_SOCKET_LISTENER_GET_CLASS (listener)->changed (listener);
498
499   return TRUE;
500 }
501
502 static GList *
503 add_sources (GSocketListener   *listener,
504              GSocketSourceFunc  callback,
505              gpointer           callback_data,
506              GCancellable      *cancellable,
507              GMainContext      *context)
508 {
509   GSocket *socket;
510   GSource *source;
511   GList *sources;
512   int i;
513
514   sources = NULL;
515   for (i = 0; i < listener->priv->sockets->len; i++)
516     {
517       socket = listener->priv->sockets->pdata[i];
518
519       source = g_socket_create_source (socket, G_IO_IN, cancellable);
520       g_source_set_callback (source,
521                              (GSourceFunc) callback,
522                              callback_data, NULL);
523       g_source_attach (source, context);
524
525       sources = g_list_prepend (sources, source);
526     }
527
528   return sources;
529 }
530
531 static void
532 free_sources (GList *sources)
533 {
534   GSource *source;
535   while (sources != NULL)
536     {
537       source = sources->data;
538       sources = g_list_delete_link (sources, sources);
539       g_source_destroy (source);
540       g_source_unref (source);
541     }
542 }
543
544 struct AcceptData {
545   GMainLoop *loop;
546   GSocket *socket;
547 };
548
549 static gboolean
550 accept_callback (GSocket      *socket,
551                  GIOCondition  condition,
552                  gpointer      user_data)
553 {
554   struct AcceptData *data = user_data;
555
556   data->socket = socket;
557   g_main_loop_quit (data->loop);
558
559   return TRUE;
560 }
561
562 /**
563  * g_socket_listener_accept_socket:
564  * @listener: a #GSocketListener
565  * @source_object: (out) (transfer none) (allow-none): location where #GObject pointer will be stored, or %NULL.
566  * @cancellable: optional #GCancellable object, %NULL to ignore.
567  * @error: #GError for error reporting, or %NULL to ignore.
568  *
569  * Blocks waiting for a client to connect to any of the sockets added
570  * to the listener. Returns the #GSocket that was accepted.
571  *
572  * If you want to accept the high-level #GSocketConnection, not a #GSocket,
573  * which is often the case, then you should use g_socket_listener_accept()
574  * instead.
575  *
576  * If @source_object is not %NULL it will be filled out with the source
577  * object specified when the corresponding socket or address was added
578  * to the listener.
579  *
580  * If @cancellable is not %NULL, then the operation can be cancelled by
581  * triggering the cancellable object from another thread. If the operation
582  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
583  *
584  * Returns: (transfer full): a #GSocket on success, %NULL on error.
585  *
586  * Since: 2.22
587  */
588 GSocket *
589 g_socket_listener_accept_socket (GSocketListener  *listener,
590                                  GObject         **source_object,
591                                  GCancellable     *cancellable,
592                                  GError          **error)
593 {
594   GSocket *accept_socket, *socket;
595
596   g_return_val_if_fail (G_IS_SOCKET_LISTENER (listener), NULL);
597
598   if (!check_listener (listener, error))
599     return NULL;
600
601   if (listener->priv->sockets->len == 1)
602     {
603       accept_socket = listener->priv->sockets->pdata[0];
604       if (!g_socket_condition_wait (accept_socket, G_IO_IN,
605                                     cancellable, error))
606         return NULL;
607     }
608   else
609     {
610       GList *sources;
611       struct AcceptData data;
612       GMainLoop *loop;
613
614       if (listener->priv->main_context == NULL)
615         listener->priv->main_context = g_main_context_new ();
616
617       loop = g_main_loop_new (listener->priv->main_context, FALSE);
618       data.loop = loop;
619       sources = add_sources (listener,
620                              accept_callback,
621                              &data,
622                              cancellable,
623                              listener->priv->main_context);
624       g_main_loop_run (loop);
625       accept_socket = data.socket;
626       free_sources (sources);
627       g_main_loop_unref (loop);
628     }
629
630   if (!(socket = g_socket_accept (accept_socket, cancellable, error)))
631     return NULL;
632
633   if (source_object)
634     *source_object = g_object_get_qdata (G_OBJECT (accept_socket), source_quark);
635
636   return socket;
637 }
638
639 /**
640  * g_socket_listener_accept:
641  * @listener: a #GSocketListener
642  * @source_object: (out) (transfer none) (allow-none): location where #GObject pointer will be stored, or %NULL
643  * @cancellable: optional #GCancellable object, %NULL to ignore.
644  * @error: #GError for error reporting, or %NULL to ignore.
645  *
646  * Blocks waiting for a client to connect to any of the sockets added
647  * to the listener. Returns a #GSocketConnection for the socket that was
648  * accepted.
649  *
650  * If @source_object is not %NULL it will be filled out with the source
651  * object specified when the corresponding socket or address was added
652  * to the listener.
653  *
654  * If @cancellable is not %NULL, then the operation can be cancelled by
655  * triggering the cancellable object from another thread. If the operation
656  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
657  *
658  * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
659  *
660  * Since: 2.22
661  */
662 GSocketConnection *
663 g_socket_listener_accept (GSocketListener  *listener,
664                           GObject         **source_object,
665                           GCancellable     *cancellable,
666                           GError          **error)
667 {
668   GSocketConnection *connection;
669   GSocket *socket;
670
671   socket = g_socket_listener_accept_socket (listener,
672                                             source_object,
673                                             cancellable,
674                                             error);
675   if (socket == NULL)
676     return NULL;
677
678   connection = g_socket_connection_factory_create_connection (socket);
679   g_object_unref (socket);
680
681   return connection;
682 }
683
684 struct AcceptAsyncData {
685   GSimpleAsyncResult *simple;
686   GCancellable *cancellable;
687   GList *sources;
688 };
689
690 static gboolean
691 accept_ready (GSocket      *accept_socket,
692               GIOCondition  condition,
693               gpointer      _data)
694 {
695   struct AcceptAsyncData *data = _data;
696   GError *error = NULL;
697   GSocket *socket;
698   GObject *source_object;
699
700   socket = g_socket_accept (accept_socket, data->cancellable, &error);
701   if (socket)
702     {
703       g_simple_async_result_set_op_res_gpointer (data->simple, socket,
704                                                  g_object_unref);
705       source_object = g_object_get_qdata (G_OBJECT (accept_socket), source_quark);
706       if (source_object)
707         g_object_set_qdata_full (G_OBJECT (data->simple),
708                                  source_quark,
709                                  g_object_ref (source_object), g_object_unref);
710     }
711   else
712     {
713       g_simple_async_result_take_error (data->simple, error);
714     }
715
716   g_simple_async_result_complete_in_idle (data->simple);
717   g_object_unref (data->simple);
718   free_sources (data->sources);
719   g_free (data);
720
721   return FALSE;
722 }
723
724 /**
725  * g_socket_listener_accept_socket_async:
726  * @listener: a #GSocketListener
727  * @cancellable: a #GCancellable, or %NULL
728  * @callback: a #GAsyncReadyCallback
729  * @user_data: user data for the callback
730  *
731  * This is the asynchronous version of g_socket_listener_accept_socket().
732  *
733  * When the operation is finished @callback will be
734  * called. You can then call g_socket_listener_accept_socket_finish()
735  * to get the result of the operation.
736  *
737  * Since: 2.22
738  */
739 void
740 g_socket_listener_accept_socket_async (GSocketListener     *listener,
741                                        GCancellable        *cancellable,
742                                        GAsyncReadyCallback  callback,
743                                        gpointer             user_data)
744 {
745   struct AcceptAsyncData *data;
746   GError *error = NULL;
747
748   if (!check_listener (listener, &error))
749     {
750       g_simple_async_report_gerror_in_idle (G_OBJECT (listener),
751                                             callback, user_data,
752                                             error);
753       g_error_free (error);
754       return;
755     }
756
757   data = g_new0 (struct AcceptAsyncData, 1);
758   data->simple = g_simple_async_result_new (G_OBJECT (listener),
759                                             callback, user_data,
760                                             g_socket_listener_accept_socket_async);
761   data->cancellable = cancellable;
762   data->sources = add_sources (listener,
763                                accept_ready,
764                                data,
765                                cancellable,
766                                g_main_context_get_thread_default ());
767 }
768
769 /**
770  * g_socket_listener_accept_socket_finish:
771  * @listener: a #GSocketListener
772  * @result: a #GAsyncResult.
773  * @source_object: Optional #GObject identifying this source
774  * @error: a #GError location to store the error occuring, or %NULL to
775  * ignore.
776  *
777  * Finishes an async accept operation. See g_socket_listener_accept_socket_async()
778  *
779  * Returns: (transfer full): a #GSocket on success, %NULL on error.
780  *
781  * Since: 2.22
782  */
783 GSocket *
784 g_socket_listener_accept_socket_finish (GSocketListener  *listener,
785                                         GAsyncResult     *result,
786                                         GObject         **source_object,
787                                         GError          **error)
788 {
789   GSocket *socket;
790   GSimpleAsyncResult *simple;
791
792   g_return_val_if_fail (G_IS_SOCKET_LISTENER (listener), NULL);
793
794   simple = G_SIMPLE_ASYNC_RESULT (result);
795
796   if (g_simple_async_result_propagate_error (simple, error))
797     return NULL;
798
799   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_socket_listener_accept_socket_async);
800
801   socket = g_simple_async_result_get_op_res_gpointer (simple);
802
803   if (source_object)
804     *source_object = g_object_get_qdata (G_OBJECT (result), source_quark);
805
806   return g_object_ref (socket);
807 }
808
809 /**
810  * g_socket_listener_accept_async:
811  * @listener: a #GSocketListener
812  * @cancellable: a #GCancellable, or %NULL
813  * @callback: a #GAsyncReadyCallback
814  * @user_data: user data for the callback
815  *
816  * This is the asynchronous version of g_socket_listener_accept().
817  *
818  * When the operation is finished @callback will be
819  * called. You can then call g_socket_listener_accept_socket()
820  * to get the result of the operation.
821  *
822  * Since: 2.22
823  */
824 void
825 g_socket_listener_accept_async (GSocketListener     *listener,
826                                 GCancellable        *cancellable,
827                                 GAsyncReadyCallback  callback,
828                                 gpointer             user_data)
829 {
830   g_socket_listener_accept_socket_async (listener,
831                                          cancellable,
832                                          callback,
833                                          user_data);
834 }
835
836 /**
837  * g_socket_listener_accept_finish:
838  * @listener: a #GSocketListener
839  * @result: a #GAsyncResult.
840  * @source_object: Optional #GObject identifying this source
841  * @error: a #GError location to store the error occuring, or %NULL to
842  * ignore.
843  *
844  * Finishes an async accept operation. See g_socket_listener_accept_async()
845  *
846  * Returns: (transfer full): a #GSocketConnection on success, %NULL on error.
847  *
848  * Since: 2.22
849  */
850 GSocketConnection *
851 g_socket_listener_accept_finish (GSocketListener  *listener,
852                                  GAsyncResult     *result,
853                                  GObject         **source_object,
854                                  GError          **error)
855 {
856   GSocket *socket;
857   GSocketConnection *connection;
858
859   socket = g_socket_listener_accept_socket_finish (listener,
860                                                    result,
861                                                    source_object,
862                                                    error);
863   if (socket == NULL)
864     return NULL;
865
866   connection = g_socket_connection_factory_create_connection (socket);
867   g_object_unref (socket);
868   return connection;
869 }
870
871 /**
872  * g_socket_listener_set_backlog:
873  * @listener: a #GSocketListener
874  * @listen_backlog: an integer
875  *
876  * Sets the listen backlog on the sockets in the listener.
877  *
878  * See g_socket_set_listen_backlog() for details
879  *
880  * Since: 2.22
881  */
882 void
883 g_socket_listener_set_backlog (GSocketListener *listener,
884                                int              listen_backlog)
885 {
886   GSocket *socket;
887   int i;
888
889   if (listener->priv->closed)
890     return;
891
892   listener->priv->listen_backlog = listen_backlog;
893
894   for (i = 0; i < listener->priv->sockets->len; i++)
895     {
896       socket = listener->priv->sockets->pdata[i];
897       g_socket_set_listen_backlog (socket, listen_backlog);
898     }
899 }
900
901 /**
902  * g_socket_listener_close:
903  * @listener: a #GSocketListener
904  *
905  * Closes all the sockets in the listener.
906  *
907  * Since: 2.22
908  */
909 void
910 g_socket_listener_close (GSocketListener *listener)
911 {
912   GSocket *socket;
913   int i;
914
915   g_return_if_fail (G_IS_SOCKET_LISTENER (listener));
916
917   if (listener->priv->closed)
918     return;
919
920   for (i = 0; i < listener->priv->sockets->len; i++)
921     {
922       socket = listener->priv->sockets->pdata[i];
923       g_socket_close (socket, NULL);
924     }
925   listener->priv->closed = TRUE;
926 }
927
928 /**
929  * g_socket_listener_add_any_inet_port:
930  * @listener: a #GSocketListener
931  * @source_object: Optional #GObject identifying this source
932  * @error: a #GError location to store the error occuring, or %NULL to
933  * ignore.
934  *
935  * Listens for TCP connections on any available port number for both
936  * IPv6 and IPv4 (if each are available).
937  *
938  * This is useful if you need to have a socket for incoming connections
939  * but don't care about the specific port number.
940  *
941  * @source_object will be passed out in the various calls
942  * to accept to identify this particular source, which is
943  * useful if you're listening on multiple addresses and do
944  * different things depending on what address is connected to.
945  *
946  * Returns: the port number, or 0 in case of failure.
947  *
948  * Since: 2.24
949  **/
950 guint16
951 g_socket_listener_add_any_inet_port (GSocketListener  *listener,
952                                      GObject          *source_object,
953                                      GError          **error)
954 {
955   GSList *sockets_to_close = NULL;
956   guint16 candidate_port = 0;
957   GSocket *socket6 = NULL;
958   GSocket *socket4 = NULL;
959   gint attempts = 37;
960
961   /*
962    * multi-step process:
963    *  - first, create an IPv6 socket.
964    *  - if that fails, create an IPv4 socket and bind it to port 0 and
965    *    that's it.  no retries if that fails (why would it?).
966    *  - if our IPv6 socket also speaks IPv4 then we are done.
967    *  - if not, then we need to create a IPv4 socket with the same port
968    *    number.  this might fail, of course.  so we try this a bunch of
969    *    times -- leaving the old IPv6 sockets open so that we get a
970    *    different port number to try each time.
971    *  - if all that fails then just give up.
972    */
973
974   while (attempts--)
975     {
976       GInetAddress *inet_address;
977       GSocketAddress *address;
978       gboolean result;
979
980       g_assert (socket6 == NULL);
981       socket6 = g_socket_new (G_SOCKET_FAMILY_IPV6,
982                               G_SOCKET_TYPE_STREAM,
983                               G_SOCKET_PROTOCOL_DEFAULT,
984                               NULL);
985
986       if (socket6 != NULL)
987         {
988           inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV6);
989           address = g_inet_socket_address_new (inet_address, 0);
990           g_object_unref (inet_address);
991           result = g_socket_bind (socket6, address, TRUE, error);
992           g_object_unref (address);
993
994           if (!result ||
995               !(address = g_socket_get_local_address (socket6, error)))
996             {
997               g_object_unref (socket6);
998               socket6 = NULL;
999               break;
1000             }
1001
1002           g_assert (G_IS_INET_SOCKET_ADDRESS (address));
1003           candidate_port =
1004             g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (address));
1005           g_assert (candidate_port != 0);
1006           g_object_unref (address);
1007
1008           if (g_socket_speaks_ipv4 (socket6))
1009             break;
1010         }
1011
1012       g_assert (socket4 == NULL);
1013       socket4 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1014                               G_SOCKET_TYPE_STREAM,
1015                               G_SOCKET_PROTOCOL_DEFAULT,
1016                               socket6 ? NULL : error);
1017
1018       if (socket4 == NULL)
1019         /* IPv4 not supported.
1020          * if IPv6 is supported then candidate_port will be non-zero
1021          *   (and the error parameter above will have been NULL)
1022          * if IPv6 is unsupported then candidate_port will be zero
1023          *   (and error will have been set by the above call)
1024          */
1025         break;
1026
1027       inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1028       address = g_inet_socket_address_new (inet_address, candidate_port);
1029       g_object_unref (inet_address);
1030       /* a note on the 'error' clause below:
1031        *
1032        * if candidate_port is 0 then we report the error right away
1033        * since it is strange that this binding would fail at all.
1034        * otherwise, we ignore the error message (ie: NULL).
1035        *
1036        * the exception to this rule is the last time through the loop
1037        * (ie: attempts == 0) in which case we want to set the error
1038        * because failure here means that the entire call will fail and
1039        * we need something to show to the user.
1040        *
1041        * an english summary of the situation:  "if we gave a candidate
1042        * port number AND we have more attempts to try, then ignore the
1043        * error for now".
1044        */
1045       result = g_socket_bind (socket4, address, TRUE,
1046                               (candidate_port && attempts) ? NULL : error);
1047       g_object_unref (address);
1048
1049       if (candidate_port)
1050         {
1051           g_assert (socket6 != NULL);
1052
1053           if (result)
1054             /* got our candidate port successfully */
1055             break;
1056
1057           else
1058             /* we failed to bind to the specified port.  try again. */
1059             {
1060               g_object_unref (socket4);
1061               socket4 = NULL;
1062
1063               /* keep this open so we get a different port number */
1064               sockets_to_close = g_slist_prepend (sockets_to_close,
1065                                                   socket6);
1066               candidate_port = 0;
1067               socket6 = NULL;
1068             }
1069         }
1070       else
1071         /* we didn't tell it a port.  this means two things.
1072          *  - if we failed, then something really bad happened.
1073          *  - if we succeeded, then we need to find out the port number.
1074          */
1075         {
1076           g_assert (socket6 == NULL);
1077
1078           if (!result ||
1079               !(address = g_socket_get_local_address (socket4, error)))
1080             {
1081               g_object_unref (socket4);
1082               socket4 = NULL;
1083               break;
1084             }
1085
1086             g_assert (G_IS_INET_SOCKET_ADDRESS (address));
1087             candidate_port =
1088               g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (address));
1089             g_assert (candidate_port != 0);
1090             g_object_unref (address);
1091             break;
1092         }
1093     }
1094
1095   /* should only be non-zero if we have a socket */
1096   g_assert ((candidate_port != 0) == (socket4 || socket6));
1097
1098   while (sockets_to_close)
1099     {
1100       g_object_unref (sockets_to_close->data);
1101       sockets_to_close = g_slist_delete_link (sockets_to_close,
1102                                               sockets_to_close);
1103     }
1104
1105   /* now we actually listen() the sockets and add them to the listener */
1106   if (socket6 != NULL)
1107     {
1108       g_socket_set_listen_backlog (socket6, listener->priv->listen_backlog);
1109       if (!g_socket_listen (socket6, error))
1110         {
1111           g_object_unref (socket6);
1112           if (socket4)
1113             g_object_unref (socket4);
1114
1115           return 0;
1116         }
1117
1118       if (source_object)
1119         g_object_set_qdata_full (G_OBJECT (socket6), source_quark,
1120                                  g_object_ref (source_object),
1121                                  g_object_unref);
1122
1123       g_ptr_array_add (listener->priv->sockets, socket6);
1124     }
1125
1126    if (socket4 != NULL)
1127     {
1128       g_socket_set_listen_backlog (socket4, listener->priv->listen_backlog);
1129       if (!g_socket_listen (socket4, error))
1130         {
1131           g_object_unref (socket4);
1132           if (socket6)
1133             g_object_unref (socket6);
1134
1135           return 0;
1136         }
1137
1138       if (source_object)
1139         g_object_set_qdata_full (G_OBJECT (socket4), source_quark,
1140                                  g_object_ref (source_object),
1141                                  g_object_unref);
1142
1143       g_ptr_array_add (listener->priv->sockets, socket4);
1144     }
1145
1146   if ((socket4 != NULL || socket6 != NULL) &&
1147       G_SOCKET_LISTENER_GET_CLASS (listener)->changed)
1148     G_SOCKET_LISTENER_GET_CLASS (listener)->changed (listener);
1149
1150   return candidate_port;
1151 }