/* GDBus - GLib D-Bus Library

 *

 * Copyright (C) 2008-2010 Red Hat, Inc.

 *

 * SPDX-License-Identifier: LGPL-2.1-or-later

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General

 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.

 *

 * Author: David Zeuthen <davidz@redhat.com>

 */

#include "config.h"

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <errno.h>

#include "gioerror.h"

#include "gdbusutils.h"

#include "gdbusaddress.h"

#include "gdbuserror.h"

#include "gioenumtypes.h"

#include "glib-private.h"

#include "gnetworkaddress.h"

#include "gsocketclient.h"

#include "giostream.h"

#include "gasyncresult.h"

#include "gtask.h"

#include "glib-private.h"

#include "gdbusprivate.h"

#include "gstdio.h"

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <sys/stat.h>

#include <sys/types.h>

#include <gio/gunixsocketaddress.h>

#ifdef G_OS_WIN32

#include <windows.h>

#endif

#ifdef G_OS_WIN32

#define FO_CLOEXEC ""

#else

#define FO_CLOEXEC "e"

#endif

#include "glibintl.h"

/**

 * GDBusAddress:

 *

 * Routines for working with D-Bus addresses. A D-Bus address is a string

 * like `unix:tmpdir=/tmp/my-app-name`. The exact format of addresses

 * is explained in detail in the

 * [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html#addresses).

 *

 * TCP D-Bus connections are supported, but accessing them via a proxy is

 * currently not supported.

 *

 * Since GLib 2.72, `unix:` addresses are supported on Windows with `AF_UNIX`

 * support (Windows 10).

 */

static gchar *get_session_address_platform_specific (GError **error);

static gchar *get_session_address_dbus_launch       (GError **error);

/* ---------------------------------------------------------------------------------------------------- */

/**

 * g_dbus_is_address:

 * @string: A string.

 *

 * Checks if @string is a

 * [D-Bus address](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).

 *

 * This doesn't check if @string is actually supported by #GDBusServer

 * or #GDBusConnection - use g_dbus_is_supported_address() to do more

 * checks.

 *

 * Returns: %TRUE if @string is a valid D-Bus address, %FALSE otherwise.

 *

 * Since: 2.26

 */

gboolean

g_dbus_is_address (const gchar *string)

{

  guint n;

  gchar **a;

  gboolean ret;

  ret = FALSE;

  g_return_val_if_fail (string != NULL, FALSE);

  a = g_strsplit (string, ";", 0);

  if (a[0] == NULL)

    goto out;

  for (n = 0; a[n] != NULL; n++)

    {

      if (!_g_dbus_address_parse_entry (a[n],

                                        NULL,

                                        NULL,

                                        NULL))

        goto out;

    }

  ret = TRUE;

 out:

  g_strfreev (a);

  return ret;

}

static gboolean

is_valid_unix (const gchar  *address_entry,

               GHashTable   *key_value_pairs,

               GError      **error)

{

  gboolean ret;

  GPtrArray *keys;

  const gchar *path;

  const gchar *dir;

  const gchar *tmpdir;

  const gchar *abstract;

  ret = FALSE;

  path = NULL;

  dir = NULL;

  tmpdir = NULL;

  abstract = NULL;

  keys = g_hash_table_get_keys_as_ptr_array (key_value_pairs);

  for (guint i = 0; i < keys->len; ++i)

    {

      const gchar *key = g_ptr_array_index (keys, i);

      if (g_strcmp0 (key, "path") == 0)

        path = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "dir") == 0)

        dir = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "tmpdir") == 0)

        tmpdir = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "abstract") == 0)

        abstract = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "guid") != 0)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Unsupported key “%s” in address entry “%s”"),

                       key,

                       address_entry);

          goto out;

        }

    }

  /* Exactly one key must be set */

  if ((path != NULL) + (dir != NULL) + (tmpdir != NULL) + (abstract != NULL) > 1)

    {

      g_set_error (error,

             G_IO_ERROR,

             G_IO_ERROR_INVALID_ARGUMENT,

             _("Meaningless key/value pair combination in address entry “%s”"),

             address_entry);

      goto out;

    }

  else if (path == NULL && dir == NULL && tmpdir == NULL && abstract == NULL)

    {

      g_set_error (error,

                   G_IO_ERROR,

                   G_IO_ERROR_INVALID_ARGUMENT,

                   _("Address “%s” is invalid (need exactly one of path, dir, tmpdir, or abstract keys)"),

                   address_entry);

      goto out;

    }

  ret = TRUE;

 out:

  g_ptr_array_unref (keys);

  return ret;

}

static gboolean

is_valid_nonce_tcp (const gchar  *address_entry,

                    GHashTable   *key_value_pairs,

                    GError      **error)

{

  gboolean ret;

  GPtrArray *keys;

  const gchar *host;

  const gchar *port;

  const gchar *family;

  const gchar *nonce_file;

  gint port_num;

  gchar *endp;

  ret = FALSE;

  host = NULL;

  port = NULL;

  family = NULL;

  nonce_file = NULL;

  keys = g_hash_table_get_keys_as_ptr_array (key_value_pairs);

  for (guint i = 0; i < keys->len; ++i)

    {

      const gchar *key = g_ptr_array_index (keys, i);

      if (g_strcmp0 (key, "host") == 0)

        host = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "port") == 0)

        port = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "family") == 0)

        family = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "noncefile") == 0)

        nonce_file = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "guid") != 0)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Unsupported key “%s” in address entry “%s”"),

                       key,

                       address_entry);

          goto out;

        }

    }

  if (port != NULL)

    {

      port_num = strtol (port, &endp, 10);

      if ((*port == '\0' || *endp != '\0') || port_num < 0 || port_num >= 65536)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Error in address “%s” — the “%s” attribute is malformed"),

                       address_entry, "port");

          goto out;

        }

    }

  if (family != NULL && !(g_strcmp0 (family, "ipv4") == 0 || g_strcmp0 (family, "ipv6") == 0))

    {

      g_set_error (error,

                   G_IO_ERROR,

                   G_IO_ERROR_INVALID_ARGUMENT,

                   _("Error in address “%s” — the “%s” attribute is malformed"),

                   address_entry, "family");

      goto out;

    }

  if (host != NULL)

    {

      /* TODO: validate host */

    }

  if (nonce_file != NULL && *nonce_file == '\0')

    {

      g_set_error (error,

                   G_IO_ERROR,

                   G_IO_ERROR_INVALID_ARGUMENT,

                   _("Error in address “%s” — the “%s” attribute is malformed"),

                   address_entry, "noncefile");

      goto out;

    }

  ret = TRUE;

 out:

  g_ptr_array_unref (keys);

  return ret;

}

static gboolean

is_valid_tcp (const gchar  *address_entry,

              GHashTable   *key_value_pairs,

              GError      **error)

{

  gboolean ret;

  GPtrArray *keys;

  const gchar *host;

  const gchar *port;

  const gchar *family;

  gint port_num;

  gchar *endp;

  ret = FALSE;

  host = NULL;

  port = NULL;

  family = NULL;

  keys = g_hash_table_get_keys_as_ptr_array (key_value_pairs);

  for (guint i = 0; i < keys->len; ++i)

    {

      const gchar *key = g_ptr_array_index (keys, i);

      if (g_strcmp0 (key, "host") == 0)

        host = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "port") == 0)

        port = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "family") == 0)

        family = g_hash_table_lookup (key_value_pairs, key);

      else if (g_strcmp0 (key, "guid") != 0)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Unsupported key “%s” in address entry “%s”"),

                       key,

                       address_entry);

          goto out;

        }

    }

  if (port != NULL)

    {

      port_num = strtol (port, &endp, 10);

      if ((*port == '\0' || *endp != '\0') || port_num < 0 || port_num >= 65536)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Error in address “%s” — the “%s” attribute is malformed"),

                       address_entry, "port");

          goto out;

        }

    }

  if (family != NULL && !(g_strcmp0 (family, "ipv4") == 0 || g_strcmp0 (family, "ipv6") == 0))

    {

      g_set_error (error,

                   G_IO_ERROR,

                   G_IO_ERROR_INVALID_ARGUMENT,

                   _("Error in address “%s” — the “%s” attribute is malformed"),

                   address_entry, "family");

      goto out;

    }

  if (host != NULL)

    {

      /* TODO: validate host */

    }

  ret= TRUE;

 out:

  g_ptr_array_unref (keys);

  return ret;

}

/**

 * g_dbus_is_supported_address:

 * @string: A string.

 * @error: Return location for error or %NULL.

 *

 * Like g_dbus_is_address() but also checks if the library supports the

 * transports in @string and that key/value pairs for each transport

 * are valid. See the specification of the

 * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).

 *

 * Returns: %TRUE if @string is a valid D-Bus address that is

 * supported by this library, %FALSE if @error is set.

 *

 * Since: 2.26

 */

gboolean

g_dbus_is_supported_address (const gchar  *string,

                             GError      **error)

{

  guint n;

  gchar **a;

  gboolean ret;

  ret = FALSE;

  g_return_val_if_fail (string != NULL, FALSE);

  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  a = g_strsplit (string, ";", 0);

  for (n = 0; a[n] != NULL; n++)

    {

      gchar *transport_name;

      GHashTable *key_value_pairs;

      gboolean supported;

      if (!_g_dbus_address_parse_entry (a[n],

                                        &transport_name,

                                        &key_value_pairs,

                                        error))

        goto out;

      supported = FALSE;

      if (g_strcmp0 (transport_name, "unix") == 0)

        supported = is_valid_unix (a[n], key_value_pairs, error);

      else if (g_strcmp0 (transport_name, "tcp") == 0)

        supported = is_valid_tcp (a[n], key_value_pairs, error);

      else if (g_strcmp0 (transport_name, "nonce-tcp") == 0)

        supported = is_valid_nonce_tcp (a[n], key_value_pairs, error);

      else if (g_strcmp0 (a[n], "autolaunch:") == 0)

        supported = TRUE;

      else

        g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,

                     _("Unknown or unsupported transport “%s” for address “%s”"),

                     transport_name, a[n]);

      g_free (transport_name);

      g_hash_table_unref (key_value_pairs);

      if (!supported)

        goto out;

    }

  ret = TRUE;

 out:

  g_strfreev (a);

  g_assert (ret || (!ret && (error == NULL || *error != NULL)));

  return ret;

}

gboolean

_g_dbus_address_parse_entry (const gchar  *address_entry,

                             gchar       **out_transport_name,

                             GHashTable  **out_key_value_pairs,

                             GError      **error)

{

  gboolean ret;

  GHashTable *key_value_pairs;

  gchar *transport_name;

  gchar **kv_pairs;

  const gchar *s;

  guint n;

  ret = FALSE;

  kv_pairs = NULL;

  transport_name = NULL;

  key_value_pairs = NULL;

  s = strchr (address_entry, ':');

  if (s == NULL)

    {

      g_set_error (error,

                   G_IO_ERROR,

                   G_IO_ERROR_INVALID_ARGUMENT,

                   _("Address element “%s” does not contain a colon (:)"),

                   address_entry);

      goto out;

    }

  else if (s == address_entry)

    {

      g_set_error (error,

                   G_IO_ERROR,

                   G_IO_ERROR_INVALID_ARGUMENT,

                   _("Transport name in address element “%s” must not be empty"),

                   address_entry);

      goto out;

    }

  transport_name = g_strndup (address_entry, s - address_entry);

  key_value_pairs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);

  kv_pairs = g_strsplit (s + 1, ",", 0);

  for (n = 0; kv_pairs[n] != NULL; n++)

    {

      const gchar *kv_pair = kv_pairs[n];

      gchar *key;

      gchar *value;

      s = strchr (kv_pair, '=');

      if (s == NULL)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Key/Value pair %d, “%s”, in address element “%s” does not contain an equal sign"),

                       n,

                       kv_pair,

                       address_entry);

          goto out;

        }

      else if (s == kv_pair)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Key/Value pair %d, “%s”, in address element “%s” must not have an empty key"),

                       n,

                       kv_pair,

                       address_entry);

          goto out;

        }

      key = g_uri_unescape_segment (kv_pair, s, NULL);

      value = g_uri_unescape_segment (s + 1, kv_pair + strlen (kv_pair), NULL);

      if (key == NULL || value == NULL)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Error unescaping key or value in Key/Value pair %d, “%s”, in address element “%s”"),

                       n,

                       kv_pair,

                       address_entry);

          g_free (key);

          g_free (value);

          goto out;

        }

      g_hash_table_insert (key_value_pairs, key, value);

    }

  ret = TRUE;

out:

  if (ret)

    {

      if (out_transport_name != NULL)

        *out_transport_name = g_steal_pointer (&transport_name);

      if (out_key_value_pairs != NULL)

        *out_key_value_pairs = g_steal_pointer (&key_value_pairs);

    }

  g_clear_pointer (&key_value_pairs, g_hash_table_unref);

  g_free (transport_name);

  g_strfreev (kv_pairs);

  return ret;

}

/* ---------------------------------------------------------------------------------------------------- */

static GIOStream *

g_dbus_address_try_connect_one (const gchar   *address_entry,

                                gchar        **out_guid,

                                GCancellable  *cancellable,

                                GError       **error);

/* TODO: Declare an extension point called GDBusTransport (or similar)

 * and move code below to extensions implementing said extension

 * point. That way we can implement a D-Bus transport over X11 without

 * making libgio link to libX11...

 */

static GIOStream *

g_dbus_address_connect (const gchar   *address_entry,

                        const gchar   *transport_name,

                        GHashTable    *key_value_pairs,

                        GCancellable  *cancellable,

                        GError       **error)

{

  GIOStream *ret;

  GSocketConnectable *connectable;

  const gchar *nonce_file;

  connectable = NULL;

  ret = NULL;

  nonce_file = NULL;

  if (g_strcmp0 (transport_name, "unix") == 0)

    {

      const gchar *path;

      const gchar *abstract;

      path = g_hash_table_lookup (key_value_pairs, "path");

      abstract = g_hash_table_lookup (key_value_pairs, "abstract");

      if ((path == NULL && abstract == NULL) || (path != NULL && abstract != NULL))

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Error in address “%s” — the unix transport requires exactly one of the "

                         "keys “path” or “abstract” to be set"),

                       address_entry);

        }

      else if (path != NULL)

        {

          connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new (path));

        }

      else if (abstract != NULL)

        {

          connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new_with_type (abstract,

                                                                                   -1,

                                                                                   G_UNIX_SOCKET_ADDRESS_ABSTRACT));

        }

      else

        {

          g_assert_not_reached ();

        }

    }

  else if (g_strcmp0 (transport_name, "tcp") == 0 || g_strcmp0 (transport_name, "nonce-tcp") == 0)

    {

      const gchar *s;

      const gchar *host;

      glong port;

      gchar *endp;

      gboolean is_nonce;

      is_nonce = (g_strcmp0 (transport_name, "nonce-tcp") == 0);

      host = g_hash_table_lookup (key_value_pairs, "host");

      if (host == NULL)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Error in address “%s” — the host attribute is missing or malformed"),

                       address_entry);

          goto out;

        }

      s = g_hash_table_lookup (key_value_pairs, "port");

      if (s == NULL)

        s = "0";

      port = strtol (s, &endp, 10);

      if ((*s == '\0' || *endp != '\0') || port < 0 || port >= 65536)

        {

          g_set_error (error,

                       G_IO_ERROR,

                       G_IO_ERROR_INVALID_ARGUMENT,

                       _("Error in address “%s” — the port attribute is missing or malformed"),

                       address_entry);

          goto out;

        }

      if (is_nonce)

        {

          nonce_file = g_hash_table_lookup (key_value_pairs, "noncefile");

          if (nonce_file == NULL)

            {

              g_set_error (error,

                           G_IO_ERROR,

                           G_IO_ERROR_INVALID_ARGUMENT,

                           _("Error in address “%s” — the noncefile attribute is missing or malformed"),

                           address_entry);

              goto out;

            }

        }

      /* TODO: deal with family key/value-pair */

      connectable = g_network_address_new (host, port);

    }

  else if (g_strcmp0 (address_entry, "autolaunch:") == 0)

    {

      gchar *autolaunch_address;

      autolaunch_address = get_session_address_dbus_launch (error);

      if (autolaunch_address != NULL)

        {

          ret = g_dbus_address_try_connect_one (autolaunch_address, NULL, cancellable, error);

          g_free (autolaunch_address);

          goto out;

        }

      else

        {

          g_prefix_error (error, _("Error auto-launching: "));

        }

    }

  else

    {

      g_set_error (error,

                   G_IO_ERROR,

                   G_IO_ERROR_INVALID_ARGUMENT,

                   _("Unknown or unsupported transport “%s” for address “%s”"),

                   transport_name,

                   address_entry);

    }

  if (connectable != NULL)

    {

      GSocketClient *client;

      GSocketConnection *connection;

      g_assert (ret == NULL);

      client = g_socket_client_new ();

      /* Disable proxy support to prevent a deadlock on startup, since loading a

       * proxy resolver causes the GIO modules to be loaded, and there will

       * almost certainly be one of them which then tries to use GDBus.

       * See: https://bugzilla.gnome.org/show_bug.cgi?id=792499 */

      g_socket_client_set_enable_proxy (client, FALSE);

      connection = g_socket_client_connect (client,

                                            connectable,

                                            cancellable,

                                            error);

      g_object_unref (connectable);

      g_object_unref (client);

      if (connection == NULL)

        goto out;

      ret = G_IO_STREAM (connection);

      if (nonce_file != NULL)

        {

          gchar nonce_contents[16 + 1];

          size_t num_bytes_read;

          FILE *f;

          int errsv;

          /* be careful to read only 16 bytes - we also check that the file is only 16 bytes long */

          f = fopen (nonce_file, "rb" FO_CLOEXEC);

          errsv = errno;

          if (f == NULL)

            {

              g_set_error (error,

                           G_IO_ERROR,

                           G_IO_ERROR_INVALID_ARGUMENT,

                           _("Error opening nonce file “%s”: %s"),

                           nonce_file,

                           g_strerror (errsv));

              g_object_unref (ret);

              ret = NULL;

              goto out;

            }

          num_bytes_read = fread (nonce_contents,

                                  sizeof (gchar),

                                  16 + 1,

                                  f);

          errsv = errno;

          if (num_bytes_read != 16)

            {

              if (num_bytes_read == 0)

                {

                  g_set_error (error,

                               G_IO_ERROR,

                               G_IO_ERROR_INVALID_ARGUMENT,

                               _("Error reading from nonce file “%s”: %s"),

                               nonce_file,

                               g_strerror (errsv));

                }

              else

                {

                  g_set_error (error,

                               G_IO_ERROR,

                               G_IO_ERROR_INVALID_ARGUMENT,

                               _("Error reading from nonce file “%s”, expected 16 bytes, got %d"),

                               nonce_file,

                               (gint) num_bytes_read);

                }

              g_object_unref (ret);

              ret = NULL;

              fclose (f);

              goto out;

            }

          fclose (f);

          if (!g_output_stream_write_all (g_io_stream_get_output_stream (ret),

                                          nonce_contents,

                                          16,

                                          NULL,

                                          cancellable,

                                          error))

            {

              g_prefix_error (error, _("Error writing contents of nonce file “%s” to stream:"), nonce_file);

              g_object_unref (ret);

              ret = NULL;

              goto out;

            }

        }

    }

 out:

  return ret;

}

static GIOStream *

g_dbus_address_try_connect_one (const gchar   *address_entry,

                                gchar        **out_guid,

                                GCancellable  *cancellable,

                                GError       **error)

{

  GIOStream *ret;

  GHashTable *key_value_pairs;

  gchar *transport_name;

  const gchar *guid;

  ret = NULL;

  transport_name = NULL;

  key_value_pairs = NULL;

  if (!_g_dbus_address_parse_entry (address_entry,

                                    &transport_name,

                                    &key_value_pairs,

                                    error))

    goto out;

  ret = g_dbus_address_connect (address_entry,

                                transport_name,

                                key_value_pairs,

                                cancellable,

                                error);

  if (ret == NULL)

    goto out;

  guid = g_hash_table_lookup (key_value_pairs, "guid");

  if (guid != NULL && out_guid != NULL)

    *out_guid = g_strdup (guid);

out:

  g_free (transport_name);

  if (key_value_pairs != NULL)

    g_hash_table_unref (key_value_pairs);

  return ret;

}

/* ---------------------------------------------------------------------------------------------------- */

typedef struct {

  gchar *address;

  gchar *guid;

} GetStreamData;

static void

get_stream_data_free (GetStreamData *data)

{

  g_free (data->address);

  g_free (data->guid);

  g_free (data);

}

static void

get_stream_thread_func (GTask         *task,

                        gpointer       source_object,

                        gpointer       task_data,

                        GCancellable  *cancellable)

{

  GetStreamData *data = task_data;

  GIOStream *stream;

  GError *error = NULL;

  stream = g_dbus_address_get_stream_sync (data->address,

                                           &data->guid,

                                           cancellable,

                                           &error);

  if (stream)

    g_task_return_pointer (task, stream, g_object_unref);

  else

    g_task_return_error (task, error);

}

/**

 * g_dbus_address_get_stream:

 * @address: A valid D-Bus address.

 * @cancellable: (nullable): A #GCancellable or %NULL.

 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.

 * @user_data: Data to pass to @callback.

 *

 * Asynchronously connects to an endpoint specified by @address and

 * sets up the connection so it is in a state to run the client-side

 * of the D-Bus authentication conversation. @address must be in the

 * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).

 *

 * When the operation is finished, @callback will be invoked. You can

 * then call g_dbus_address_get_stream_finish() to get the result of

 * the operation.

 *

 * This is an asynchronous failable function. See

 * g_dbus_address_get_stream_sync() for the synchronous version.

 *

 * Since: 2.26

 */

void

g_dbus_address_get_stream (const gchar         *address,

                           GCancellable        *cancellable,

                           GAsyncReadyCallback  callback,

                           gpointer             user_data)

{

  GTask *task;

  GetStreamData *data;

  g_return_if_fail (address != NULL);

  data = g_new0 (GetStreamData, 1);