/src/glib-2.80.0/gio/gproxyaddressenumerator.c

Source
/* GIO - GLib Input, Output and Streaming Library
 *
 * Copyright (C) 2010 Collabora, Ltd.
 *
 * 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: Nicolas Dufresne <nicolas.dufresne@collabora.co.uk>
 */

#include "config.h"
#include "gproxyaddressenumerator.h"

#include <string.h>

#include "gasyncresult.h"
#include "ginetaddress.h"
#include "gioerror.h"
#include "glibintl.h"
#include "glib-private.h"
#include "gnetworkaddress.h"
#include "gnetworkingprivate.h"
#include "gproxy.h"
#include "gproxyaddress.h"
#include "gproxyresolver.h"
#include "gtask.h"
#include "gresolver.h"
#include "gsocketaddress.h"
#include "gsocketaddressenumerator.h"
#include "gsocketconnectable.h"

/**
 * GProxyAddressEnumerator:
 *
 * `GProxyAddressEnumerator` is a wrapper around
 * [class@Gio.SocketAddressEnumerator] which takes the [class@Gio.SocketAddress]
 * instances returned by the [class@Gio.SocketAddressEnumerator]
 * and wraps them in [class@Gio.ProxyAddress] instances, using the given
 * [property@Gio.ProxyAddressEnumerator:proxy-resolver].
 *
 * This enumerator will be returned (for example, by
 * [method@Gio.SocketConnectable.enumerate]) as appropriate when a proxy is
 * configured; there should be no need to manually wrap a
 * [class@Gio.SocketAddressEnumerator] instance with one.
 */

#define GET_PRIVATE(o) (G_PROXY_ADDRESS_ENUMERATOR (o)->priv)

enum
{
  PROP_0,
  PROP_URI,
  PROP_DEFAULT_PORT,
  PROP_CONNECTABLE,
  PROP_PROXY_RESOLVER
};

struct _GProxyAddressEnumeratorPrivate
{
  /* Destination address */
  GSocketConnectable *connectable;
  gchar              *dest_uri;
  guint16             default_port;
  gchar              *dest_hostname;
  guint16             dest_port;
  GList              *dest_ips;

  /* Proxy enumeration */
  GProxyResolver           *proxy_resolver;
  gchar                   **proxies;
  gchar                   **next_proxy;
  GSocketAddressEnumerator *addr_enum;
  GSocketAddress           *proxy_address;
  const gchar              *proxy_uri;
  gchar                    *proxy_type;
  gchar                    *proxy_username;
  gchar                    *proxy_password;
  gboolean                  supports_hostname;
  GList                    *next_dest_ip;
  GError                   *last_error;

  /* ever_enumerated is TRUE after we've returned a result for the first time
   * via g_proxy_address_enumerator_next() or _next_async(). If FALSE, we have
   * never returned yet, and should return an error if returning NULL because
   * it does not make sense for a proxy resolver to return NULL except on error.
   * (Whereas a DNS resolver would return NULL with no error to indicate "no
   * results", a proxy resolver would want to return "direct://" instead, so
   * NULL without error does not make sense for us.)
   *
   * But if ever_enumerated is TRUE, then we must not report any further errors
   * (except for G_IO_ERROR_CANCELLED), because this is an API contract of
   * GSocketAddressEnumerator.
   */
  gboolean                  ever_enumerated;
};

G_DEFINE_TYPE_WITH_PRIVATE (GProxyAddressEnumerator, g_proxy_address_enumerator, G_TYPE_SOCKET_ADDRESS_ENUMERATOR)

static void
save_userinfo (GProxyAddressEnumeratorPrivate *priv,
               const gchar *proxy)
{
  g_clear_pointer (&priv->proxy_username, g_free);
  g_clear_pointer (&priv->proxy_password, g_free);

  g_uri_split_with_user (proxy, G_URI_FLAGS_HAS_PASSWORD, NULL,
                         &priv->proxy_username, &priv->proxy_password,
                         NULL, NULL, NULL, NULL, NULL, NULL, NULL);
}

static void
next_enumerator (GProxyAddressEnumeratorPrivate *priv)
{
  if (priv->proxy_address)
    return;

  while (priv->addr_enum == NULL && *priv->next_proxy)
    {
      GSocketConnectable *connectable = NULL;
      GProxy *proxy;

      priv->proxy_uri = *priv->next_proxy++;
      g_free (priv->proxy_type);
      priv->proxy_type = g_uri_parse_scheme (priv->proxy_uri);

      if (priv->proxy_type == NULL)
  continue;

      /* Assumes hostnames are supported for unknown protocols */
      priv->supports_hostname = TRUE;
      proxy = g_proxy_get_default_for_protocol (priv->proxy_type);
      if (proxy)
        {
    priv->supports_hostname = g_proxy_supports_hostname (proxy);
    g_object_unref (proxy);
        }

      if (strcmp ("direct", priv->proxy_type) == 0)
  {
    if (priv->connectable)
      connectable = g_object_ref (priv->connectable);
    else
      connectable = g_network_address_new (priv->dest_hostname,
             priv->dest_port);
  }
      else
  {
    GError *error = NULL;
    int default_port;

    default_port = GLIB_PRIVATE_CALL (g_uri_get_default_scheme_port) (priv->proxy_type);
    if (default_port == -1)
      default_port = 0;

    connectable = g_network_address_parse_uri (priv->proxy_uri, default_port, &error);
    if (error)
      {
        g_warning ("Invalid proxy URI '%s': %s",
       priv->proxy_uri, error->message);
        g_error_free (error);
      }

    save_userinfo (priv, priv->proxy_uri);
  }

      if (connectable)
  {
    priv->addr_enum = g_socket_connectable_enumerate (connectable);
    g_object_unref (connectable);
  }
    }
}

static GSocketAddress *
g_proxy_address_enumerator_next (GSocketAddressEnumerator  *enumerator,
         GCancellable              *cancellable,
         GError                   **error)
{
  GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (enumerator);
  GSocketAddress *result = NULL;
  GError *first_error = NULL;

  if (!priv->ever_enumerated)
    {
      g_assert (priv->proxies == NULL);
      priv->proxies = g_proxy_resolver_lookup (priv->proxy_resolver,
                 priv->dest_uri,
                 cancellable,
                 error);
      priv->next_proxy = priv->proxies;

      if (priv->proxies == NULL)
  {
    priv->ever_enumerated = TRUE;
    return NULL;
  }
    }

  while (result == NULL && (*priv->next_proxy || priv->addr_enum))
    {
      gchar *dest_hostname;
      gchar *dest_protocol;
      GInetSocketAddress *inetsaddr;
      GInetAddress *inetaddr;
      guint16 port;

      next_enumerator (priv);

      if (!priv->addr_enum)
  continue;

      if (priv->proxy_address == NULL)
  {
    priv->proxy_address = g_socket_address_enumerator_next (
            priv->addr_enum,
            cancellable,
            first_error ? NULL : &first_error);
  }

      if (priv->proxy_address == NULL)
  {
    g_object_unref (priv->addr_enum);
    priv->addr_enum = NULL;

    if (priv->dest_ips)
      {
        g_resolver_free_addresses (priv->dest_ips);
        priv->dest_ips = NULL;
      }

    continue;
  }

      if (strcmp ("direct", priv->proxy_type) == 0)
  {
    result = priv->proxy_address;
    priv->proxy_address = NULL;
    continue;
  }

      if (!priv->supports_hostname)
  {
    GInetAddress *dest_ip;

    if (!priv->dest_ips)
      {
        GResolver *resolver;

        resolver = g_resolver_get_default();
        priv->dest_ips = g_resolver_lookup_by_name (resolver,
                priv->dest_hostname,
                cancellable,
                first_error ? NULL : &first_error);
        g_object_unref (resolver);

        if (!priv->dest_ips)
    {
      g_object_unref (priv->proxy_address);
      priv->proxy_address = NULL;
      continue;
    }
      }

    if (!priv->next_dest_ip)
      priv->next_dest_ip = priv->dest_ips;
  
    dest_ip = G_INET_ADDRESS (priv->next_dest_ip->data);
    dest_hostname = g_inet_address_to_string (dest_ip);

    priv->next_dest_ip = g_list_next (priv->next_dest_ip);
  }
      else
  {
    dest_hostname = g_strdup (priv->dest_hostname);
  }
      dest_protocol = g_uri_parse_scheme (priv->dest_uri);
          
      if (!G_IS_INET_SOCKET_ADDRESS (priv->proxy_address))
        {
    g_free (dest_hostname);
    g_free (dest_protocol);
        }
      g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (priv->proxy_address), NULL);

      inetsaddr = G_INET_SOCKET_ADDRESS (priv->proxy_address);
      inetaddr = g_inet_socket_address_get_address (inetsaddr);
      port = g_inet_socket_address_get_port (inetsaddr);

      result = g_object_new (G_TYPE_PROXY_ADDRESS,
           "address", inetaddr,
           "port", port,
           "protocol", priv->proxy_type,
           "destination-protocol", dest_protocol,
           "destination-hostname", dest_hostname,
           "destination-port", priv->dest_port,
           "username", priv->proxy_username,
           "password", priv->proxy_password,
           "uri", priv->proxy_uri,
           NULL);
      g_free (dest_hostname);
      g_free (dest_protocol);

      if (priv->supports_hostname || priv->next_dest_ip == NULL)
  {
    g_object_unref (priv->proxy_address);
    priv->proxy_address = NULL;
  }
    }

  if (result == NULL && first_error && (!priv->ever_enumerated || g_error_matches (first_error, G_IO_ERROR, G_IO_ERROR_CANCELLED)))
    g_propagate_error (error, first_error);
  else if (first_error)
    g_error_free (first_error);

  if (result == NULL && error != NULL && *error == NULL && !priv->ever_enumerated)
    g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Unspecified proxy lookup failure"));

  priv->ever_enumerated = TRUE;

  return result;
}

static void
complete_async (GTask *task)
{
  GProxyAddressEnumeratorPrivate *priv = g_task_get_task_data (task);

  if (priv->last_error && (!priv->ever_enumerated || g_error_matches (priv->last_error, G_IO_ERROR, G_IO_ERROR_CANCELLED)))
    {
      g_task_return_error (task, priv->last_error);
      priv->last_error = NULL;
    }
  else if (!priv->ever_enumerated)
    {
      g_task_return_new_error_literal (task, G_IO_ERROR, G_IO_ERROR_FAILED,
                                       _("Unspecified proxy lookup failure"));
    }
  else
    {
      g_task_return_pointer (task, NULL, NULL);
    }

  priv->ever_enumerated = TRUE;

  g_clear_error (&priv->last_error);
  g_object_unref (task);
}

static void
return_result (GTask *task)
{
  GProxyAddressEnumeratorPrivate *priv = g_task_get_task_data (task);
  GSocketAddress *result;
  gboolean is_inet_socket_address;

  if (strcmp ("direct", priv->proxy_type) == 0)
    {
      result = priv->proxy_address;
      priv->proxy_address = NULL;
    }
  else
    {
      gchar *dest_hostname, *dest_protocol;
      GInetSocketAddress *inetsaddr;
      GInetAddress *inetaddr;
      guint16 port;

      if (!priv->supports_hostname)
  {
    GInetAddress *dest_ip;

    if (!priv->next_dest_ip)
      priv->next_dest_ip = priv->dest_ips;

    dest_ip = G_INET_ADDRESS (priv->next_dest_ip->data);
    dest_hostname = g_inet_address_to_string (dest_ip);

    priv->next_dest_ip = g_list_next (priv->next_dest_ip);
  }
      else
  {
    dest_hostname = g_strdup (priv->dest_hostname);
  }
      dest_protocol = g_uri_parse_scheme (priv->dest_uri);

      is_inet_socket_address = G_IS_INET_SOCKET_ADDRESS (priv->proxy_address);
      if (!is_inet_socket_address)
        {
    g_free (dest_hostname);
    g_free (dest_protocol);
        }
      g_return_if_fail (is_inet_socket_address);

      inetsaddr = G_INET_SOCKET_ADDRESS (priv->proxy_address);
      inetaddr = g_inet_socket_address_get_address (inetsaddr);
      port = g_inet_socket_address_get_port (inetsaddr);

      result = g_object_new (G_TYPE_PROXY_ADDRESS,
           "address", inetaddr,
           "port", port,
           "protocol", priv->proxy_type,
           "destination-protocol", dest_protocol,
           "destination-hostname", dest_hostname,
           "destination-port", priv->dest_port,
           "username", priv->proxy_username,
           "password", priv->proxy_password,
           "uri", priv->proxy_uri,
           NULL);
      g_free (dest_hostname);
      g_free (dest_protocol);

      if (priv->supports_hostname || priv->next_dest_ip == NULL)
  {
    g_object_unref (priv->proxy_address);
    priv->proxy_address = NULL;
  }
    }

  priv->ever_enumerated = TRUE;
  g_task_return_pointer (task, result, g_object_unref);
  g_object_unref (task);
}

static void address_enumerate_cb (GObject      *object,
          GAsyncResult *result,
          gpointer  user_data);

static void
next_proxy (GTask *task)
{
  GProxyAddressEnumeratorPrivate *priv = g_task_get_task_data (task);

  if (*priv->next_proxy)
    {
      g_object_unref (priv->addr_enum);
      priv->addr_enum = NULL;

      if (priv->dest_ips)
  {
    g_resolver_free_addresses (priv->dest_ips);
    priv->dest_ips = NULL;
  }

      next_enumerator (priv);

      if (priv->addr_enum)
  {
    g_socket_address_enumerator_next_async (priv->addr_enum,
              g_task_get_cancellable (task),
              address_enumerate_cb,
              task);
    return;
  }
    }

  complete_async (task);
}

static void
dest_hostname_lookup_cb (GObject           *object,
       GAsyncResult      *result,
       gpointer           user_data)
{
  GTask *task = user_data;
  GProxyAddressEnumeratorPrivate *priv = g_task_get_task_data (task);

  g_clear_error (&priv->last_error);
  priv->dest_ips = g_resolver_lookup_by_name_finish (G_RESOLVER (object),
                 result,
                 &priv->last_error);
  if (priv->dest_ips)
    return_result (task);
  else
    {
      g_clear_object (&priv->proxy_address);
      next_proxy (task);
    }
}

static void
address_enumerate_cb (GObject    *object,
          GAsyncResult *result,
          gpointer      user_data)
{
  GTask *task = user_data;
  GProxyAddressEnumeratorPrivate *priv = g_task_get_task_data (task);

  g_clear_error (&priv->last_error);
  priv->proxy_address =
    g_socket_address_enumerator_next_finish (priv->addr_enum,
               result,
               &priv->last_error);
  if (priv->proxy_address)
    {
      if (!priv->supports_hostname && !priv->dest_ips)
  {
    GResolver *resolver;
    resolver = g_resolver_get_default();
    g_resolver_lookup_by_name_async (resolver,
             priv->dest_hostname,
             g_task_get_cancellable (task),
             dest_hostname_lookup_cb,
             task);
    g_object_unref (resolver);
    return;
  }

      return_result (task);
    }
  else
    next_proxy (task);
}

static void
proxy_lookup_cb (GObject      *object,
     GAsyncResult *result,
     gpointer      user_data)
{
  GTask *task = user_data;
  GProxyAddressEnumeratorPrivate *priv = g_task_get_task_data (task);

  g_clear_error (&priv->last_error);
  priv->proxies = g_proxy_resolver_lookup_finish (G_PROXY_RESOLVER (object),
              result,
              &priv->last_error);
  priv->next_proxy = priv->proxies;

  if (priv->last_error)
    {
      complete_async (task);
      return;
    }
  else
    {
      next_enumerator (priv);
      if (priv->addr_enum)
  {
    g_socket_address_enumerator_next_async (priv->addr_enum,
              g_task_get_cancellable (task),
              address_enumerate_cb,
              task);
    return;
  }
    }

  complete_async (task);
}

static void
g_proxy_address_enumerator_next_async (GSocketAddressEnumerator *enumerator,
               GCancellable             *cancellable,
               GAsyncReadyCallback       callback,
               gpointer                  user_data)
{
  GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (enumerator);
  GTask *task;

  task = g_task_new (enumerator, cancellable, callback, user_data);
  g_task_set_source_tag (task, g_proxy_address_enumerator_next_async);
  g_task_set_task_data (task, priv, NULL);

  if (priv->proxies == NULL)
    {
      g_proxy_resolver_lookup_async (priv->proxy_resolver,
             priv->dest_uri,
             cancellable,
             proxy_lookup_cb,
             task);
      return;
    }

  if (priv->addr_enum)
    {
      if (priv->proxy_address)
  {
    return_result (task);
    return;
  }
      else
  {
    g_socket_address_enumerator_next_async (priv->addr_enum,
              cancellable,
              address_enumerate_cb,
              task);
    return;
  }
    }

  complete_async (task);
}

static GSocketAddress *
g_proxy_address_enumerator_next_finish (GSocketAddressEnumerator  *enumerator,
          GAsyncResult              *result,
          GError                   **error)
{
  g_return_val_if_fail (g_task_is_valid (result, enumerator), NULL);

  return g_task_propagate_pointer (G_TASK (result), error);
}

static void
g_proxy_address_enumerator_constructed (GObject *object)
{
  GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (object);
  GSocketConnectable *conn;
  guint port;

  if (priv->dest_uri)
    {
      conn = g_network_address_parse_uri (priv->dest_uri, priv->default_port, NULL);
      if (conn)
        {
          g_object_get (conn,
                        "hostname", &priv->dest_hostname,
                        "port", &port,
                        NULL);
          priv->dest_port = port;

          g_object_unref (conn);
        }
      else
        g_warning ("Invalid URI '%s'", priv->dest_uri);
    }

  G_OBJECT_CLASS (g_proxy_address_enumerator_parent_class)->constructed (object);
}

static void
g_proxy_address_enumerator_get_property (GObject        *object,
                                         guint           property_id,
                                         GValue         *value,
                                         GParamSpec     *pspec)
{
  GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (object);
  switch (property_id)
    {
    case PROP_URI:
      g_value_set_string (value, priv->dest_uri);
      break;

    case PROP_DEFAULT_PORT:
      g_value_set_uint (value, priv->default_port);
      break;

    case PROP_CONNECTABLE:
      g_value_set_object (value, priv->connectable);
      break;

    case PROP_PROXY_RESOLVER:
      g_value_set_object (value, priv->proxy_resolver);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}

static void
g_proxy_address_enumerator_set_property (GObject        *object,
                                         guint           property_id,
                                         const GValue   *value,
                                         GParamSpec     *pspec)
{
  GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (object);
  switch (property_id)
    {
    case PROP_URI:
      priv->dest_uri = g_value_dup_string (value);
      break;

    case PROP_DEFAULT_PORT:
      priv->default_port = g_value_get_uint (value);
      break;

    case PROP_CONNECTABLE:
      priv->connectable = g_value_dup_object (value);
      break;

    case PROP_PROXY_RESOLVER:
      if (priv->proxy_resolver)
        g_object_unref (priv->proxy_resolver);
      priv->proxy_resolver = g_value_get_object (value);
      if (!priv->proxy_resolver)
        priv->proxy_resolver = g_proxy_resolver_get_default ();
      g_object_ref (priv->proxy_resolver);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}

static void
g_proxy_address_enumerator_finalize (GObject *object)
{
  GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (object);

  if (priv->connectable)
    g_object_unref (priv->connectable);

  if (priv->proxy_resolver)
    g_object_unref (priv->proxy_resolver);

  g_free (priv->dest_uri);
  g_free (priv->dest_hostname);

  if (priv->dest_ips)
    g_resolver_free_addresses (priv->dest_ips);

  g_strfreev (priv->proxies);

  if (priv->addr_enum)
    g_object_unref (priv->addr_enum);

  g_free (priv->proxy_type);
  g_free (priv->proxy_username);
  g_free (priv->proxy_password);

  g_clear_error (&priv->last_error);

  G_OBJECT_CLASS (g_proxy_address_enumerator_parent_class)->finalize (object);
}

static void
g_proxy_address_enumerator_init (GProxyAddressEnumerator *self)
{
  self->priv = g_proxy_address_enumerator_get_instance_private (self);
}

static void
g_proxy_address_enumerator_class_init (GProxyAddressEnumeratorClass *proxy_enumerator_class)
{
  GObjectClass *object_class = G_OBJECT_CLASS (proxy_enumerator_class);
  GSocketAddressEnumeratorClass *enumerator_class = G_SOCKET_ADDRESS_ENUMERATOR_CLASS (proxy_enumerator_class);

  object_class->constructed = g_proxy_address_enumerator_constructed;
  object_class->set_property = g_proxy_address_enumerator_set_property;
  object_class->get_property = g_proxy_address_enumerator_get_property;
  object_class->finalize = g_proxy_address_enumerator_finalize;

  enumerator_class->next = g_proxy_address_enumerator_next;
  enumerator_class->next_async = g_proxy_address_enumerator_next_async;
  enumerator_class->next_finish = g_proxy_address_enumerator_next_finish;

  /**
   * GProxyAddressEnumerator:uri:
   *
   * The destination URI. Use `none://` for a generic socket.
   */
  g_object_class_install_property (object_class,
           PROP_URI,
           g_param_spec_string ("uri", NULL, NULL,
              NULL,
              G_PARAM_READWRITE |
              G_PARAM_CONSTRUCT_ONLY |
              G_PARAM_STATIC_STRINGS));

  /**
   * GProxyAddressEnumerator:default-port:
   *
   * The default port to use if #GProxyAddressEnumerator:uri does not
   * specify one.
   *
   * Since: 2.38
   */
  g_object_class_install_property (object_class,
           PROP_DEFAULT_PORT,
           g_param_spec_uint ("default-port", NULL, NULL,
                                                      0, 65535, 0,
                                                      G_PARAM_READWRITE |
                                                      G_PARAM_CONSTRUCT_ONLY |
                                                      G_PARAM_STATIC_STRINGS));

  /**
   * GProxyAddressEnumerator:connectable:
   *
   * The connectable being enumerated.
   */
  g_object_class_install_property (object_class,
           PROP_CONNECTABLE,
           g_param_spec_object ("connectable", NULL, NULL,
              G_TYPE_SOCKET_CONNECTABLE,
              G_PARAM_READWRITE |
              G_PARAM_CONSTRUCT_ONLY |
              G_PARAM_STATIC_STRINGS));

  /**
   * GProxyAddressEnumerator:proxy-resolver:
   *
   * The proxy resolver to use.
   *
   * Since: 2.36
   */
  g_object_class_install_property (object_class,
                                   PROP_PROXY_RESOLVER,
                                   g_param_spec_object ("proxy-resolver", NULL, NULL,
                                                        G_TYPE_PROXY_RESOLVER,
                                                        G_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT |
                                                        G_PARAM_STATIC_STRINGS));
}

Coverage Report

Created: 2025-11-16 07:45