| /* 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 "ginetsocketaddress.h" | |
| #include "ginetaddress.h" | |
| #include "gnetworkingprivate.h" | |
| #include "gsocketconnectable.h" | |
| #include "gioerror.h" | |
| #include "glibintl.h" | |
| /** | |
| * GInetSocketAddress: | |
| * | |
| * An IPv4 or IPv6 socket address. That is, the combination of a | |
| * [class@Gio.InetAddress] and a port number. | |
| * | |
| * In UNIX terms, `GInetSocketAddress` corresponds to a | |
| * [`struct sockaddr_in` or `struct sockaddr_in6`](man:sockaddr(3type)). | |
| */ | |
| struct _GInetSocketAddressPrivate | |
| { | |
| GInetAddress *address; | |
| guint16 port; | |
| guint32 flowinfo; | |
| guint32 scope_id; | |
| }; | |
| static void g_inet_socket_address_connectable_iface_init (GSocketConnectableIface *iface); | |
| static gchar *g_inet_socket_address_connectable_to_string (GSocketConnectable *connectable); | |
| G_DEFINE_TYPE_WITH_CODE (GInetSocketAddress, g_inet_socket_address, G_TYPE_SOCKET_ADDRESS, | |
| G_ADD_PRIVATE (GInetSocketAddress) | |
| G_IMPLEMENT_INTERFACE (G_TYPE_SOCKET_CONNECTABLE, | |
| g_inet_socket_address_connectable_iface_init)) | |
| enum { | |
| PROP_0, | |
| PROP_ADDRESS, | |
| PROP_PORT, | |
| PROP_FLOWINFO, | |
| PROP_SCOPE_ID | |
| }; | |
| static void | |
| g_inet_socket_address_dispose (GObject *object) | |
| { | |
| GInetSocketAddress *address = G_INET_SOCKET_ADDRESS (object); | |
| g_clear_object (&(address->priv->address)); | |
| G_OBJECT_CLASS (g_inet_socket_address_parent_class)->dispose (object); | |
| } | |
| static void | |
| g_inet_socket_address_get_property (GObject *object, | |
| guint prop_id, | |
| GValue *value, | |
| GParamSpec *pspec) | |
| { | |
| GInetSocketAddress *address = G_INET_SOCKET_ADDRESS (object); | |
| switch (prop_id) | |
| { | |
| case PROP_ADDRESS: | |
| g_value_set_object (value, address->priv->address); | |
| break; | |
| case PROP_PORT: | |
| g_value_set_uint (value, address->priv->port); | |
| break; | |
| case PROP_FLOWINFO: | |
| g_return_if_fail (g_inet_address_get_family (address->priv->address) == G_SOCKET_FAMILY_IPV6); | |
| g_value_set_uint (value, address->priv->flowinfo); | |
| break; | |
| case PROP_SCOPE_ID: | |
| g_return_if_fail (g_inet_address_get_family (address->priv->address) == G_SOCKET_FAMILY_IPV6); | |
| g_value_set_uint (value, address->priv->scope_id); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| } | |
| } | |
| static void | |
| g_inet_socket_address_set_property (GObject *object, | |
| guint prop_id, | |
| const GValue *value, | |
| GParamSpec *pspec) | |
| { | |
| GInetSocketAddress *address = G_INET_SOCKET_ADDRESS (object); | |
| switch (prop_id) | |
| { | |
| case PROP_ADDRESS: | |
| address->priv->address = g_object_ref (g_value_get_object (value)); | |
| break; | |
| case PROP_PORT: | |
| address->priv->port = (guint16) g_value_get_uint (value); | |
| break; | |
| case PROP_FLOWINFO: | |
| /* We can't test that address->priv->address is IPv6 here, | |
| * since this property might get set before PROP_ADDRESS. | |
| */ | |
| address->priv->flowinfo = g_value_get_uint (value); | |
| break; | |
| case PROP_SCOPE_ID: | |
| address->priv->scope_id = g_value_get_uint (value); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| } | |
| } | |
| static GSocketFamily | |
| g_inet_socket_address_get_family (GSocketAddress *address) | |
| { | |
| GInetSocketAddress *addr; | |
| g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (address), 0); | |
| addr = G_INET_SOCKET_ADDRESS (address); | |
| return g_inet_address_get_family (addr->priv->address); | |
| } | |
| static gssize | |
| g_inet_socket_address_get_native_size (GSocketAddress *address) | |
| { | |
| GInetSocketAddress *addr; | |
| GSocketFamily family; | |
| g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (address), 0); | |
| addr = G_INET_SOCKET_ADDRESS (address); | |
| family = g_inet_address_get_family (addr->priv->address); | |
| if (family == AF_INET) | |
| return sizeof (struct sockaddr_in); | |
| else if (family == AF_INET6) | |
| return sizeof (struct sockaddr_in6); | |
| else | |
| return -1; | |
| } | |
| static gboolean | |
| g_inet_socket_address_to_native (GSocketAddress *address, | |
| gpointer dest, | |
| gsize destlen, | |
| GError **error) | |
| { | |
| GInetSocketAddress *addr; | |
| GSocketFamily family; | |
| g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (address), FALSE); | |
| addr = G_INET_SOCKET_ADDRESS (address); | |
| family = g_inet_address_get_family (addr->priv->address); | |
| if (family == AF_INET) | |
| { | |
| struct sockaddr_in *sock = (struct sockaddr_in *) dest; | |
| if (destlen < sizeof (*sock)) | |
| { | |
| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NO_SPACE, | |
| _("Not enough space for socket address")); | |
| return FALSE; | |
| } | |
| sock->sin_family = AF_INET; | |
| sock->sin_port = g_htons (addr->priv->port); | |
| memcpy (&(sock->sin_addr.s_addr), g_inet_address_to_bytes (addr->priv->address), sizeof (sock->sin_addr)); | |
| memset (sock->sin_zero, 0, sizeof (sock->sin_zero)); | |
| return TRUE; | |
| } | |
| else if (family == AF_INET6) | |
| { | |
| struct sockaddr_in6 *sock = (struct sockaddr_in6 *) dest; | |
| if (destlen < sizeof (*sock)) | |
| { | |
| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NO_SPACE, | |
| _("Not enough space for socket address")); | |
| return FALSE; | |
| } | |
| memset (sock, 0, sizeof (*sock)); | |
| sock->sin6_family = AF_INET6; | |
| sock->sin6_port = g_htons (addr->priv->port); | |
| sock->sin6_flowinfo = addr->priv->flowinfo; | |
| sock->sin6_scope_id = addr->priv->scope_id; | |
| memcpy (&(sock->sin6_addr.s6_addr), g_inet_address_to_bytes (addr->priv->address), sizeof (sock->sin6_addr)); | |
| return TRUE; | |
| } | |
| else | |
| { | |
| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, | |
| _("Unsupported socket address")); | |
| return FALSE; | |
| } | |
| } | |
| static void | |
| g_inet_socket_address_class_init (GInetSocketAddressClass *klass) | |
| { | |
| GObjectClass *gobject_class = G_OBJECT_CLASS (klass); | |
| GSocketAddressClass *gsocketaddress_class = G_SOCKET_ADDRESS_CLASS (klass); | |
| gobject_class->dispose = g_inet_socket_address_dispose; | |
| gobject_class->set_property = g_inet_socket_address_set_property; | |
| gobject_class->get_property = g_inet_socket_address_get_property; | |
| gsocketaddress_class->get_family = g_inet_socket_address_get_family; | |
| gsocketaddress_class->to_native = g_inet_socket_address_to_native; | |
| gsocketaddress_class->get_native_size = g_inet_socket_address_get_native_size; | |
| /** | |
| * GInetSocketAddress:address: | |
| * | |
| * The address. | |
| * | |
| * Since: 2.22 | |
| */ | |
| g_object_class_install_property (gobject_class, PROP_ADDRESS, | |
| g_param_spec_object ("address", NULL, NULL, | |
| G_TYPE_INET_ADDRESS, | |
| G_PARAM_CONSTRUCT_ONLY | | |
| G_PARAM_READWRITE | | |
| G_PARAM_STATIC_STRINGS)); | |
| /** | |
| * GInetSocketAddress:port: | |
| * | |
| * The port. | |
| * | |
| * Since: 2.22 | |
| */ | |
| g_object_class_install_property (gobject_class, PROP_PORT, | |
| g_param_spec_uint ("port", NULL, NULL, | |
| 0, | |
| 65535, | |
| 0, | |
| G_PARAM_CONSTRUCT_ONLY | | |
| G_PARAM_READWRITE | | |
| G_PARAM_STATIC_STRINGS)); | |
| /** | |
| * GInetSocketAddress:flowinfo: | |
| * | |
| * The `sin6_flowinfo` field, for IPv6 addresses. | |
| * | |
| * Since: 2.32 | |
| */ | |
| g_object_class_install_property (gobject_class, PROP_FLOWINFO, | |
| g_param_spec_uint ("flowinfo", NULL, NULL, | |
| 0, | |
| G_MAXUINT32, | |
| 0, | |
| G_PARAM_CONSTRUCT_ONLY | | |
| G_PARAM_READWRITE | | |
| G_PARAM_STATIC_STRINGS)); | |
| /** | |
| * GInetSocketAddress:scope-id: | |
| * | |
| * The `sin6_scope_id` field, for IPv6 addresses. | |
| * | |
| * Since: 2.32 | |
| */ | |
| g_object_class_install_property (gobject_class, PROP_SCOPE_ID, | |
| g_param_spec_uint ("scope-id", NULL, NULL, | |
| 0, | |
| G_MAXUINT32, | |
| 0, | |
| G_PARAM_CONSTRUCT_ONLY | | |
| G_PARAM_READWRITE | | |
| G_PARAM_STATIC_STRINGS)); | |
| } | |
| static void | |
| g_inet_socket_address_connectable_iface_init (GSocketConnectableIface *iface) | |
| { | |
| GSocketConnectableIface *parent_iface = g_type_interface_peek_parent (iface); | |
| iface->enumerate = parent_iface->enumerate; | |
| iface->proxy_enumerate = parent_iface->proxy_enumerate; | |
| iface->to_string = g_inet_socket_address_connectable_to_string; | |
| } | |
| static gchar * | |
| g_inet_socket_address_connectable_to_string (GSocketConnectable *connectable) | |
| { | |
| GInetSocketAddress *sa; | |
| GInetAddress *a; | |
| gchar *a_string; | |
| GString *out; | |
| guint16 port; | |
| sa = G_INET_SOCKET_ADDRESS (connectable); | |
| a = g_inet_socket_address_get_address (sa); | |
| out = g_string_new (""); | |
| /* Address. */ | |
| a_string = g_inet_address_to_string (a); | |
| g_string_append (out, a_string); | |
| g_free (a_string); | |
| /* Scope ID (IPv6 only). */ | |
| if (g_inet_address_get_family (a) == G_SOCKET_FAMILY_IPV6 && | |
| g_inet_socket_address_get_scope_id (sa) != 0) | |
| { | |
| g_string_append_printf (out, "%%%u", | |
| g_inet_socket_address_get_scope_id (sa)); | |
| } | |
| /* Port. */ | |
| port = g_inet_socket_address_get_port (sa); | |
| if (port != 0) | |
| { | |
| /* Disambiguate ports from IPv6 addresses using square brackets. */ | |
| if (g_inet_address_get_family (a) == G_SOCKET_FAMILY_IPV6) | |
| { | |
| g_string_prepend (out, "["); | |
| g_string_append (out, "]"); | |
| } | |
| g_string_append_printf (out, ":%u", port); | |
| } | |
| return g_string_free (out, FALSE); | |
| } | |
| static void | |
| g_inet_socket_address_init (GInetSocketAddress *address) | |
| { | |
| address->priv = g_inet_socket_address_get_instance_private (address); | |
| } | |
| /** | |
| * g_inet_socket_address_new: | |
| * @address: a #GInetAddress | |
| * @port: a port number | |
| * | |
| * Creates a new #GInetSocketAddress for @address and @port. | |
| * | |
| * Returns: a new #GInetSocketAddress | |
| * | |
| * Since: 2.22 | |
| */ | |
| GSocketAddress * | |
| g_inet_socket_address_new (GInetAddress *address, | |
| guint16 port) | |
| { | |
| return g_object_new (G_TYPE_INET_SOCKET_ADDRESS, | |
| "address", address, | |
| "port", port, | |
| NULL); | |
| } | |
| /** | |
| * g_inet_socket_address_new_from_string: | |
| * @address: the string form of an IP address | |
| * @port: a port number | |
| * | |
| * Creates a new #GInetSocketAddress for @address and @port. | |
| * | |
| * If @address is an IPv6 address, it can also contain a scope ID | |
| * (separated from the address by a `%`). | |
| * | |
| * Returns: (nullable) (transfer full): a new #GInetSocketAddress, | |
| * or %NULL if @address cannot be parsed. | |
| * | |
| * Since: 2.40 | |
| */ | |
| GSocketAddress * | |
| g_inet_socket_address_new_from_string (const char *address, | |
| guint port) | |
| { | |
| static struct addrinfo *hints, hints_struct; | |
| GSocketAddress *saddr; | |
| GInetAddress *iaddr; | |
| struct addrinfo *res; | |
| gint status; | |
| if (strchr (address, ':')) | |
| { | |
| /* IPv6 address (or it's invalid). We use getaddrinfo() because | |
| * it will handle parsing a scope_id as well. | |
| */ | |
| if (G_UNLIKELY (g_once_init_enter_pointer (&hints))) | |
| { | |
| hints_struct.ai_family = AF_UNSPEC; | |
| hints_struct.ai_socktype = SOCK_STREAM; | |
| hints_struct.ai_protocol = 0; | |
| hints_struct.ai_flags = AI_NUMERICHOST; | |
| g_once_init_leave_pointer (&hints, &hints_struct); | |
| } | |
| status = getaddrinfo (address, NULL, hints, &res); | |
| if (status != 0) | |
| return NULL; | |
| if (res->ai_family == AF_INET6 && | |
| res->ai_addrlen == sizeof (struct sockaddr_in6)) | |
| { | |
| ((struct sockaddr_in6 *)res->ai_addr)->sin6_port = g_htons (port); | |
| saddr = g_socket_address_new_from_native (res->ai_addr, res->ai_addrlen); | |
| } | |
| else | |
| saddr = NULL; | |
| freeaddrinfo (res); | |
| } | |
| else | |
| { | |
| /* IPv4 (or invalid). We don't want to use getaddrinfo() here, | |
| * because it accepts the stupid "IPv4 numbers-and-dots | |
| * notation" addresses that are never used for anything except | |
| * phishing. Since we don't have to worry about scope IDs for | |
| * IPv4, we can just use g_inet_address_new_from_string(). | |
| */ | |
| iaddr = g_inet_address_new_from_string (address); | |
| if (!iaddr) | |
| return NULL; | |
| g_warn_if_fail (g_inet_address_get_family (iaddr) == G_SOCKET_FAMILY_IPV4); | |
| saddr = g_inet_socket_address_new (iaddr, port); | |
| g_object_unref (iaddr); | |
| } | |
| return saddr; | |
| } | |
| /** | |
| * g_inet_socket_address_get_address: | |
| * @address: a #GInetSocketAddress | |
| * | |
| * Gets @address's #GInetAddress. | |
| * | |
| * Returns: (transfer none): the #GInetAddress for @address, which must be | |
| * g_object_ref()'d if it will be stored | |
| * | |
| * Since: 2.22 | |
| */ | |
| GInetAddress * | |
| g_inet_socket_address_get_address (GInetSocketAddress *address) | |
| { | |
| g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (address), NULL); | |
| return address->priv->address; | |
| } | |
| /** | |
| * g_inet_socket_address_get_port: | |
| * @address: a #GInetSocketAddress | |
| * | |
| * Gets @address's port. | |
| * | |
| * Returns: the port for @address | |
| * | |
| * Since: 2.22 | |
| */ | |
| guint16 | |
| g_inet_socket_address_get_port (GInetSocketAddress *address) | |
| { | |
| g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (address), 0); | |
| return address->priv->port; | |
| } | |
| /** | |
| * g_inet_socket_address_get_flowinfo: | |
| * @address: a %G_SOCKET_FAMILY_IPV6 #GInetSocketAddress | |
| * | |
| * Gets the `sin6_flowinfo` field from @address, | |
| * which must be an IPv6 address. | |
| * | |
| * Returns: the flowinfo field | |
| * | |
| * Since: 2.32 | |
| */ | |
| guint32 | |
| g_inet_socket_address_get_flowinfo (GInetSocketAddress *address) | |
| { | |
| g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (address), 0); | |
| g_return_val_if_fail (g_inet_address_get_family (address->priv->address) == G_SOCKET_FAMILY_IPV6, 0); | |
| return address->priv->flowinfo; | |
| } | |
| /** | |
| * g_inet_socket_address_get_scope_id: | |
| * @address: a %G_SOCKET_FAMILY_IPV6 #GInetAddress | |
| * | |
| * Gets the `sin6_scope_id` field from @address, | |
| * which must be an IPv6 address. | |
| * | |
| * Returns: the scope id field | |
| * | |
| * Since: 2.32 | |
| */ | |
| guint32 | |
| g_inet_socket_address_get_scope_id (GInetSocketAddress *address) | |
| { | |
| g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (address), 0); | |
| g_return_val_if_fail (g_inet_address_get_family (address->priv->address) == G_SOCKET_FAMILY_IPV6, 0); | |
| return address->priv->scope_id; | |
| } |