gio/gsocketaddress.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2008 Christian Kellner, Samuel Cormier-Iijima
   4  *
   5  * SPDX-License-Identifier: LGPL-2.1-or-later
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General
  18  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  *
  20  * Authors: Christian Kellner <gicmo@gnome.org>
  21  *          Samuel Cormier-Iijima <sciyoshi@gmail.com>
  22  */
  23
  24 #include <config.h>
  25 #include <glib.h>
  26 #include <string.h>
  27
  28 #include "gsocketaddress.h"
  29 #include "ginetaddress.h"
  30 #include "ginetsocketaddress.h"
  31 #include "gnativesocketaddress.h"
  32 #include "gnetworkingprivate.h"
  33 #include "gproxyaddress.h"
  34 #include "gproxyaddressenumerator.h"
  35 #include "gsocketaddressenumerator.h"
  36 #include "gsocketconnectable.h"
  37 #include "glibintl.h"
  38 #include "gioenumtypes.h"
  39
  40 #include "gunixsocketaddress.h"
  41
  42 #ifdef G_OS_WIN32
  43 #include "giowin32-afunix.h"
  44 #endif
  45
  46
  47 /**
  48  * GSocketAddress:
  49  *
  50  * `GSocketAddress` is the equivalent of
  51  * [`struct sockaddr`](man:sockaddr(3type)) and its subtypes in the BSD sockets
  52  * API. This is an abstract class; use [class@Gio.InetSocketAddress] for
  53  * internet sockets, or [class@Gio.UnixSocketAddress] for UNIX domain sockets.
  54  */
  55
  56 enum
  57 {
  58   PROP_NONE,
  59   PROP_FAMILY
  60 };
  61
  62 static void                      g_socket_address_connectable_iface_init       (GSocketConnectableIface *iface);
  63 static GSocketAddressEnumerator *g_socket_address_connectable_enumerate        (GSocketConnectable      *connectable);
  64 static GSocketAddressEnumerator *g_socket_address_connectable_proxy_enumerate  (GSocketConnectable      *connectable);
  65
  66 G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GSocketAddress, g_socket_address, G_TYPE_OBJECT,
  67                                   G_IMPLEMENT_INTERFACE (G_TYPE_SOCKET_CONNECTABLE,
  68                                                          g_socket_address_connectable_iface_init))
  69
  70 /**
  71  * g_socket_address_get_family:
  72  * @address: a #GSocketAddress
  73  *
  74  * Gets the socket family type of @address.
  75  *
  76  * Returns: the socket family type of @address
  77  *
  78  * Since: 2.22
  79  */
  80 GSocketFamily
  81 g_socket_address_get_family (GSocketAddress *address)
  82 {
  83   g_return_val_if_fail (G_IS_SOCKET_ADDRESS (address), 0);
  84
  85   return G_SOCKET_ADDRESS_GET_CLASS (address)->get_family (address);
  86 }
  87
  88 static void
  89 g_socket_address_get_property (GObject *object, guint prop_id,
  90                                GValue *value, GParamSpec *pspec)
  91 {
  92   GSocketAddress *address = G_SOCKET_ADDRESS (object);
  93
  94   switch (prop_id)
  95     {
  96      case PROP_FAMILY:
  97       g_value_set_enum (value, g_socket_address_get_family (address));
  98       break;
  99
 100      default:
 101       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 102     }
 103 }
 104
 105 static void
 106 g_socket_address_class_init (GSocketAddressClass *klass)
 107 {
 108   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 109
 110   gobject_class->get_property = g_socket_address_get_property;
 111
 112   /**
 113    * GSocketAddress:family:
 114    *
 115    * The family of the socket address.
 116    *
 117    * Since: 2.22
 118    */
 119   g_object_class_install_property (gobject_class, PROP_FAMILY,
 120                                    g_param_spec_enum ("family", NULL, NULL,
 121                                                       G_TYPE_SOCKET_FAMILY,
 122                                                       G_SOCKET_FAMILY_INVALID,
 123                                                       G_PARAM_READABLE |
 124                                                       G_PARAM_STATIC_STRINGS));
 125 }
 126
 127 static void
 128 g_socket_address_connectable_iface_init (GSocketConnectableIface *connectable_iface)
 129 {
 130   connectable_iface->enumerate  = g_socket_address_connectable_enumerate;
 131   connectable_iface->proxy_enumerate  = g_socket_address_connectable_proxy_enumerate;
 132   /* to_string() is implemented by subclasses */
 133 }
 134
 135 static void
 136 g_socket_address_init (GSocketAddress *address)
 137 {
 138
 139 }
 140
 141 /**
 142  * g_socket_address_get_native_size:
 143  * @address: a #GSocketAddress
 144  *
 145  * Gets the size of @address's native struct sockaddr.
 146  * You can use this to allocate memory to pass to
 147  * g_socket_address_to_native().
 148  *
 149  * Returns: the size of the native struct sockaddr that
 150  *     @address represents
 151  *
 152  * Since: 2.22
 153  */
 154 gssize
 155 g_socket_address_get_native_size (GSocketAddress *address)
 156 {
 157   g_return_val_if_fail (G_IS_SOCKET_ADDRESS (address), -1);
 158
 159   return G_SOCKET_ADDRESS_GET_CLASS (address)->get_native_size (address);
 160 }
 161
 162 /**
 163  * g_socket_address_to_native:
 164  * @address: a #GSocketAddress
 165  * @dest: a pointer to a memory location that will contain the native
 166  * struct sockaddr
 167  * @destlen: the size of @dest. Must be at least as large as
 168  *     g_socket_address_get_native_size()
 169  * @error: #GError for error reporting, or %NULL to ignore
 170  *
 171  * Converts a #GSocketAddress to a native struct sockaddr, which can
 172  * be passed to low-level functions like connect() or bind().
 173  *
 174  * If not enough space is available, a %G_IO_ERROR_NO_SPACE error
 175  * is returned. If the address type is not known on the system
 176  * then a %G_IO_ERROR_NOT_SUPPORTED error is returned.
 177  *
 178  * Returns: %TRUE if @dest was filled in, %FALSE on error
 179  *
 180  * Since: 2.22
 181  */
 182 gboolean
 183 g_socket_address_to_native (GSocketAddress  *address,
 184                             gpointer         dest,
 185                             gsize            destlen,
 186                             GError         **error)
 187 {
 188   g_return_val_if_fail (G_IS_SOCKET_ADDRESS (address), FALSE);
 189
 190   return G_SOCKET_ADDRESS_GET_CLASS (address)->to_native (address, dest, destlen, error);
 191 }
 192
 193 /**
 194  * g_socket_address_new_from_native:
 195  * @native: (not nullable): a pointer to a struct sockaddr
 196  * @len: the size of the memory location pointed to by @native
 197  *
 198  * Creates a #GSocketAddress subclass corresponding to the native
 199  * struct sockaddr @native.
 200  *
 201  * Returns: a new #GSocketAddress if @native could successfully
 202  *     be converted, otherwise %NULL
 203  *
 204  * Since: 2.22
 205  */
 206 GSocketAddress *
 207 g_socket_address_new_from_native (gpointer native,
 208                                   gsize    len)
 209 {
 210   gshort family;
 211
 212   if (len < sizeof (gshort))
 213     return NULL;
 214
 215   family = ((struct sockaddr *) native)->sa_family;
 216
 217   if (family == AF_UNSPEC)
 218     return NULL;
 219
 220   if (family == AF_INET)
 221     {
 222       struct sockaddr_in *addr = (struct sockaddr_in *) native;
 223       GInetAddress *iaddr;
 224       GSocketAddress *sockaddr;
 225
 226       if (len < sizeof (*addr))
 227         return NULL;
 228
 229       iaddr = g_inet_address_new_from_bytes ((guint8 *) &(addr->sin_addr), AF_INET);
 230       sockaddr = g_inet_socket_address_new (iaddr, g_ntohs (addr->sin_port));
 231       g_object_unref (iaddr);
 232       return sockaddr;
 233     }
 234
 235   if (family == AF_INET6)
 236     {
 237       struct sockaddr_in6 *addr = (struct sockaddr_in6 *) native;
 238       GInetAddress *iaddr;
 239       GSocketAddress *sockaddr;
 240
 241       if (len < sizeof (*addr))
 242         return NULL;
 243
 244       if (IN6_IS_ADDR_V4MAPPED (&(addr->sin6_addr)))
 245         {
 246           struct sockaddr_in sin_addr;
 247
 248           sin_addr.sin_family = AF_INET;
 249           sin_addr.sin_port = addr->sin6_port;
 250           memcpy (&(sin_addr.sin_addr.s_addr), addr->sin6_addr.s6_addr + 12, 4);
 251           iaddr = g_inet_address_new_from_bytes ((guint8 *) &(sin_addr.sin_addr), AF_INET);
 252         }
 253       else
 254         {
 255           iaddr = g_inet_address_new_from_bytes ((guint8 *) &(addr->sin6_addr), AF_INET6);
 256         }
 257
 258       sockaddr = g_object_new (G_TYPE_INET_SOCKET_ADDRESS,
 259                                "address", iaddr,
 260                                "port", g_ntohs (addr->sin6_port),
 261                                "flowinfo", addr->sin6_flowinfo,
 262                                "scope_id", addr->sin6_scope_id,
 263                                NULL);
 264       g_object_unref (iaddr);
 265       return sockaddr;
 266     }
 267
 268   if (family == AF_UNIX)
 269     {
 270       struct sockaddr_un *addr = (struct sockaddr_un *) native;
 271       gint path_len = len - G_STRUCT_OFFSET (struct sockaddr_un, sun_path);
 272
 273       if (path_len == 0)
 274         {
 275           return g_unix_socket_address_new_with_type ("", 0,
 276                                                       G_UNIX_SOCKET_ADDRESS_ANONYMOUS);
 277         }
 278       else if (addr->sun_path[0] == 0)
 279         {
 280           if (!g_unix_socket_address_abstract_names_supported ())
 281             {
 282               return g_unix_socket_address_new_with_type ("", 0,
 283                                                           G_UNIX_SOCKET_ADDRESS_ANONYMOUS);
 284             }
 285           else if (len < sizeof (*addr))
 286             {
 287               return g_unix_socket_address_new_with_type (addr->sun_path + 1,
 288                                                           path_len - 1,
 289                                                           G_UNIX_SOCKET_ADDRESS_ABSTRACT);
 290             }
 291           else
 292             {
 293               return g_unix_socket_address_new_with_type (addr->sun_path + 1,
 294                                                           path_len - 1,
 295                                                           G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED);
 296             }
 297         }
 298       else
 299         return g_unix_socket_address_new (addr->sun_path);
 300     }
 301
 302   return g_native_socket_address_new (native, len);
 303 }
 304
 305
 306 #define G_TYPE_SOCKET_ADDRESS_ADDRESS_ENUMERATOR (_g_socket_address_address_enumerator_get_type ())
 307 #define G_SOCKET_ADDRESS_ADDRESS_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SOCKET_ADDRESS_ADDRESS_ENUMERATOR, GSocketAddressAddressEnumerator))
 308
 309 typedef struct {
 310   GSocketAddressEnumerator parent_instance;
 311
 312   GSocketAddress *sockaddr;
 313 } GSocketAddressAddressEnumerator;
 314
 315 typedef struct {
 316   GSocketAddressEnumeratorClass parent_class;
 317
 318 } GSocketAddressAddressEnumeratorClass;
 319
 320 static GType _g_socket_address_address_enumerator_get_type (void);
 321 G_DEFINE_TYPE (GSocketAddressAddressEnumerator, _g_socket_address_address_enumerator, G_TYPE_SOCKET_ADDRESS_ENUMERATOR)
 322
 323 static void
 324 g_socket_address_address_enumerator_finalize (GObject *object)
 325 {
 326   GSocketAddressAddressEnumerator *sockaddr_enum =
 327     G_SOCKET_ADDRESS_ADDRESS_ENUMERATOR (object);
 328
 329   if (sockaddr_enum->sockaddr)
 330     g_object_unref (sockaddr_enum->sockaddr);
 331
 332   G_OBJECT_CLASS (_g_socket_address_address_enumerator_parent_class)->finalize (object);
 333 }
 334
 335 static GSocketAddress *
 336 g_socket_address_address_enumerator_next (GSocketAddressEnumerator  *enumerator,
 337                                           GCancellable              *cancellable,
 338                                           GError                   **error)
 339 {
 340   GSocketAddressAddressEnumerator *sockaddr_enum =
 341     G_SOCKET_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
 342
 343   if (sockaddr_enum->sockaddr)
 344     {
 345       GSocketAddress *ret = sockaddr_enum->sockaddr;
 346
 347       sockaddr_enum->sockaddr = NULL;
 348       return ret;
 349     }
 350   else
 351     return NULL;
 352 }
 353
 354 static void
 355 _g_socket_address_address_enumerator_init (GSocketAddressAddressEnumerator *enumerator)
 356 {
 357 }
 358
 359 static void
 360 _g_socket_address_address_enumerator_class_init (GSocketAddressAddressEnumeratorClass *sockaddrenum_class)
 361 {
 362   GObjectClass *object_class = G_OBJECT_CLASS (sockaddrenum_class);
 363   GSocketAddressEnumeratorClass *enumerator_class =
 364     G_SOCKET_ADDRESS_ENUMERATOR_CLASS (sockaddrenum_class);
 365
 366   enumerator_class->next = g_socket_address_address_enumerator_next;
 367   object_class->finalize = g_socket_address_address_enumerator_finalize;
 368 }
 369
 370 static GSocketAddressEnumerator *
 371 g_socket_address_connectable_enumerate (GSocketConnectable *connectable)
 372 {
 373   GSocketAddressAddressEnumerator *sockaddr_enum;
 374
 375   sockaddr_enum = g_object_new (G_TYPE_SOCKET_ADDRESS_ADDRESS_ENUMERATOR, NULL);
 376   sockaddr_enum->sockaddr = g_object_ref (G_SOCKET_ADDRESS (connectable));
 377
 378   return (GSocketAddressEnumerator *)sockaddr_enum;
 379 }
 380
 381 static GSocketAddressEnumerator *
 382 g_socket_address_connectable_proxy_enumerate (GSocketConnectable *connectable)
 383 {
 384   GSocketAddressEnumerator *addr_enum = NULL;
 385
 386   g_assert (connectable != NULL);
 387
 388   if (G_IS_INET_SOCKET_ADDRESS (connectable) &&
 389       !G_IS_PROXY_ADDRESS (connectable))
 390     {
 391       GInetAddress *addr;
 392       guint port;
 393       gchar *uri;
 394       gchar *ip;
 395
 396       g_object_get (connectable, "address", &addr, "port", &port, NULL);
 397
 398       ip = g_inet_address_to_string (addr);
 399       uri = g_uri_join (G_URI_FLAGS_NONE, "none", NULL, ip, port, "", NULL, NULL);
 400
 401       addr_enum = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR,
 402                                 "connectable", connectable,
 403                                 "uri", uri,
 404                                 NULL);
 405
 406       g_object_unref (addr);
 407       g_free (ip);
 408       g_free (uri);
 409     }
 410   else
 411     {
 412       addr_enum = g_socket_address_connectable_enumerate (connectable);
 413     }
 414
 415   return addr_enum;
 416 }