/* GIO - GLib Input, Output and Streaming Library

 *

 * Copyright (C) 2008 Christian Kellner, Samuel Cormier-Iijima

 *

 * 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/>.

 *

 * Authors: Christian Kellner <gicmo@gnome.org>

 *          Samuel Cormier-Iijima <sciyoshi@gmail.com>

 */

#include <config.h>

#include <glib.h>

#include <string.h>

#include "gsocketaddress.h"

#include "ginetaddress.h"

#include "ginetsocketaddress.h"

#include "gnativesocketaddress.h"

#include "gnetworkingprivate.h"

#include "gproxyaddress.h"

#include "gproxyaddressenumerator.h"

#include "gsocketaddressenumerator.h"

#include "gsocketconnectable.h"

#include "glibintl.h"

#include "gioenumtypes.h"

#include "gunixsocketaddress.h"

#ifdef G_OS_WIN32

#include "giowin32-afunix.h"

#endif

/**

 * GSocketAddress:

 *

 * `GSocketAddress` is the equivalent of

 * [`struct sockaddr`](man:sockaddr(3type)) and its subtypes in the BSD sockets

 * API. This is an abstract class; use [class@Gio.InetSocketAddress] for

 * internet sockets, or [class@Gio.UnixSocketAddress] for UNIX domain sockets.

 */

enum

{

  PROP_NONE,

  PROP_FAMILY

};

static void                      g_socket_address_connectable_iface_init       (GSocketConnectableIface *iface);

static GSocketAddressEnumerator *g_socket_address_connectable_enumerate        (GSocketConnectable      *connectable);

static GSocketAddressEnumerator *g_socket_address_connectable_proxy_enumerate  (GSocketConnectable      *connectable);

G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GSocketAddress, g_socket_address, G_TYPE_OBJECT,

          G_IMPLEMENT_INTERFACE (G_TYPE_SOCKET_CONNECTABLE,

               g_socket_address_connectable_iface_init))

/**

 * g_socket_address_get_family:

 * @address: a #GSocketAddress

 *

 * Gets the socket family type of @address.

 *

 * Returns: the socket family type of @address

 *

 * Since: 2.22

 */

GSocketFamily

g_socket_address_get_family (GSocketAddress *address)

{

  g_return_val_if_fail (G_IS_SOCKET_ADDRESS (address), 0);

  return G_SOCKET_ADDRESS_GET_CLASS (address)->get_family (address);

}

static void

g_socket_address_get_property (GObject *object, guint prop_id,

             GValue *value, GParamSpec *pspec)

{

  GSocketAddress *address = G_SOCKET_ADDRESS (object);

  switch (prop_id)

    {

     case PROP_FAMILY:

      g_value_set_enum (value, g_socket_address_get_family (address));

      break;

     default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    }

}

static void

g_socket_address_class_init (GSocketAddressClass *klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->get_property = g_socket_address_get_property;

  /**

   * GSocketAddress:family:

   *

   * The family of the socket address.

   *

   * Since: 2.22

   */

  g_object_class_install_property (gobject_class, PROP_FAMILY,

                                   g_param_spec_enum ("family", NULL, NULL,

                  G_TYPE_SOCKET_FAMILY,

                  G_SOCKET_FAMILY_INVALID,

                  G_PARAM_READABLE |

                                                      G_PARAM_STATIC_STRINGS));

}

static void

g_socket_address_connectable_iface_init (GSocketConnectableIface *connectable_iface)

{

  connectable_iface->enumerate  = g_socket_address_connectable_enumerate;

  connectable_iface->proxy_enumerate  = g_socket_address_connectable_proxy_enumerate;

  /* to_string() is implemented by subclasses */

}

static void

g_socket_address_init (GSocketAddress *address)

{

}

/**

 * g_socket_address_get_native_size:

 * @address: a #GSocketAddress

 *

 * Gets the size of @address's native struct sockaddr.

 * You can use this to allocate memory to pass to

 * g_socket_address_to_native().

 *

 * Returns: the size of the native struct sockaddr that

 *     @address represents

 *

 * Since: 2.22

 */

gssize

g_socket_address_get_native_size (GSocketAddress *address)

{

  g_return_val_if_fail (G_IS_SOCKET_ADDRESS (address), -1);

  return G_SOCKET_ADDRESS_GET_CLASS (address)->get_native_size (address);

}

/**

 * g_socket_address_to_native:

 * @address: a #GSocketAddress

 * @dest: a pointer to a memory location that will contain the native

 * struct sockaddr

 * @destlen: the size of @dest. Must be at least as large as

 *     g_socket_address_get_native_size()

 * @error: #GError for error reporting, or %NULL to ignore

 *

 * Converts a #GSocketAddress to a native struct sockaddr, which can

 * be passed to low-level functions like connect() or bind().

 *

 * If not enough space is available, a %G_IO_ERROR_NO_SPACE error

 * is returned. If the address type is not known on the system

 * then a %G_IO_ERROR_NOT_SUPPORTED error is returned.

 *

 * Returns: %TRUE if @dest was filled in, %FALSE on error

 *

 * Since: 2.22

 */

gboolean

g_socket_address_to_native (GSocketAddress  *address,

          gpointer         dest,

          gsize            destlen,

          GError         **error)

{

  g_return_val_if_fail (G_IS_SOCKET_ADDRESS (address), FALSE);

  return G_SOCKET_ADDRESS_GET_CLASS (address)->to_native (address, dest, destlen, error);

}

/**

 * g_socket_address_new_from_native:

 * @native: (not nullable): a pointer to a struct sockaddr

 * @len: the size of the memory location pointed to by @native

 *

 * Creates a #GSocketAddress subclass corresponding to the native

 * struct sockaddr @native.

 *

 * Returns: a new #GSocketAddress if @native could successfully

 *     be converted, otherwise %NULL

 *

 * Since: 2.22

 */

GSocketAddress *

g_socket_address_new_from_native (gpointer native,

          gsize    len)

{

  gshort family;

  if (len < sizeof (gshort))

    return NULL;

  family = ((struct sockaddr *) native)->sa_family;

  if (family == AF_UNSPEC)

    return NULL;

  if (family == AF_INET)

    {

      struct sockaddr_in *addr = (struct sockaddr_in *) native;

      GInetAddress *iaddr;

      GSocketAddress *sockaddr;

      if (len < sizeof (*addr))

  return NULL;

      iaddr = g_inet_address_new_from_bytes ((guint8 *) &(addr->sin_addr), AF_INET);

      sockaddr = g_inet_socket_address_new (iaddr, g_ntohs (addr->sin_port));

      g_object_unref (iaddr);

      return sockaddr;

    }

  if (family == AF_INET6)

    {

      struct sockaddr_in6 *addr = (struct sockaddr_in6 *) native;

      GInetAddress *iaddr;

      GSocketAddress *sockaddr;

      if (len < sizeof (*addr))

  return NULL;

      if (IN6_IS_ADDR_V4MAPPED (&(addr->sin6_addr)))

  {

    struct sockaddr_in sin_addr;

    sin_addr.sin_family = AF_INET;

    sin_addr.sin_port = addr->sin6_port;

    memcpy (&(sin_addr.sin_addr.s_addr), addr->sin6_addr.s6_addr + 12, 4);

    iaddr = g_inet_address_new_from_bytes ((guint8 *) &(sin_addr.sin_addr), AF_INET);

  }

      else

  {

    iaddr = g_inet_address_new_from_bytes ((guint8 *) &(addr->sin6_addr), AF_INET6);

  }

      sockaddr = g_object_new (G_TYPE_INET_SOCKET_ADDRESS,

             "address", iaddr,

             "port", g_ntohs (addr->sin6_port),

             "flowinfo", addr->sin6_flowinfo,

             "scope_id", addr->sin6_scope_id,

             NULL);

      g_object_unref (iaddr);

      return sockaddr;

    }

  if (family == AF_UNIX)

    {

      struct sockaddr_un *addr = (struct sockaddr_un *) native;

      gint path_len = len - G_STRUCT_OFFSET (struct sockaddr_un, sun_path);

      if (path_len == 0)

  {

    return g_unix_socket_address_new_with_type ("", 0,

                  G_UNIX_SOCKET_ADDRESS_ANONYMOUS);

  }

      else if (addr->sun_path[0] == 0)

  {

    if (!g_unix_socket_address_abstract_names_supported ())

      {

        return g_unix_socket_address_new_with_type ("", 0,

                G_UNIX_SOCKET_ADDRESS_ANONYMOUS);

      }

    else if (len < sizeof (*addr))

      {

        return g_unix_socket_address_new_with_type (addr->sun_path + 1,

                path_len - 1,

                G_UNIX_SOCKET_ADDRESS_ABSTRACT);

      }

    else

      {

        return g_unix_socket_address_new_with_type (addr->sun_path + 1,

                path_len - 1,

                G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED);

      }

  }

      else

  return g_unix_socket_address_new (addr->sun_path);

    }

  return g_native_socket_address_new (native, len);

}

#define G_TYPE_SOCKET_ADDRESS_ADDRESS_ENUMERATOR (_g_socket_address_address_enumerator_get_type ())

#define G_SOCKET_ADDRESS_ADDRESS_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SOCKET_ADDRESS_ADDRESS_ENUMERATOR, GSocketAddressAddressEnumerator))

typedef struct {

  GSocketAddressEnumerator parent_instance;

  GSocketAddress *sockaddr;

} GSocketAddressAddressEnumerator;

typedef struct {

  GSocketAddressEnumeratorClass parent_class;

} GSocketAddressAddressEnumeratorClass;

static GType _g_socket_address_address_enumerator_get_type (void);

G_DEFINE_TYPE (GSocketAddressAddressEnumerator, _g_socket_address_address_enumerator, G_TYPE_SOCKET_ADDRESS_ENUMERATOR)

static void

g_socket_address_address_enumerator_finalize (GObject *object)

{

  GSocketAddressAddressEnumerator *sockaddr_enum =

    G_SOCKET_ADDRESS_ADDRESS_ENUMERATOR (object);

  if (sockaddr_enum->sockaddr)

    g_object_unref (sockaddr_enum->sockaddr);

  G_OBJECT_CLASS (_g_socket_address_address_enumerator_parent_class)->finalize (object);

}

static GSocketAddress *

g_socket_address_address_enumerator_next (GSocketAddressEnumerator  *enumerator,

            GCancellable              *cancellable,

            GError                   **error)

{

  GSocketAddressAddressEnumerator *sockaddr_enum =

    G_SOCKET_ADDRESS_ADDRESS_ENUMERATOR (enumerator);

  if (sockaddr_enum->sockaddr)

    {

      GSocketAddress *ret = sockaddr_enum->sockaddr;

      sockaddr_enum->sockaddr = NULL;

      return ret;

    }

  else

    return NULL;

}

static void

_g_socket_address_address_enumerator_init (GSocketAddressAddressEnumerator *enumerator)

{

}

static void

_g_socket_address_address_enumerator_class_init (GSocketAddressAddressEnumeratorClass *sockaddrenum_class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (sockaddrenum_class);

  GSocketAddressEnumeratorClass *enumerator_class =

    G_SOCKET_ADDRESS_ENUMERATOR_CLASS (sockaddrenum_class);

  enumerator_class->next = g_socket_address_address_enumerator_next;

  object_class->finalize = g_socket_address_address_enumerator_finalize;

}

static GSocketAddressEnumerator *

g_socket_address_connectable_enumerate (GSocketConnectable *connectable)

{

  GSocketAddressAddressEnumerator *sockaddr_enum;

  sockaddr_enum = g_object_new (G_TYPE_SOCKET_ADDRESS_ADDRESS_ENUMERATOR, NULL);

  sockaddr_enum->sockaddr = g_object_ref (G_SOCKET_ADDRESS (connectable));

  return (GSocketAddressEnumerator *)sockaddr_enum;

}

static GSocketAddressEnumerator *

g_socket_address_connectable_proxy_enumerate (GSocketConnectable *connectable)

{

  GSocketAddressEnumerator *addr_enum = NULL;

  g_assert (connectable != NULL);

  if (G_IS_INET_SOCKET_ADDRESS (connectable) &&

      !G_IS_PROXY_ADDRESS (connectable))

    {

      GInetAddress *addr;

      guint port;

      gchar *uri;

      gchar *ip;

      g_object_get (connectable, "address", &addr, "port", &port, NULL);

      ip = g_inet_address_to_string (addr);

      uri = g_uri_join (G_URI_FLAGS_NONE, "none", NULL, ip, port, "", NULL, NULL);

      addr_enum = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR,

                                "connectable", connectable,

                                "uri", uri,

                                NULL);

      g_object_unref (addr);

      g_free (ip);

      g_free (uri);

    }

  else

    {

      addr_enum = g_socket_address_connectable_enumerate (connectable);

    }

  return addr_enum;

}