| /* 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; |
| } |