gio/gunixsocketaddress.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2008 Christian Kellner, Samuel Cormier-Iijima
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Authors: Christian Kellner <gicmo@gnome.org>
  19  *          Samuel Cormier-Iijima <sciyoshi@gmail.com>
  20  */
  21
  22 #include <config.h>
  23 #include <glib.h>
  24 #include <string.h>
  25
  26 #include "gunixsocketaddress.h"
  27 #include "gsocketconnectable.h"
  28 #include "glibintl.h"
  29 #include "gnetworking.h"
  30
  31
  32 /**
  33  * SECTION:gunixsocketaddress
  34  * @short_description: UNIX GSocketAddress
  35  * @include: gio/gunixsocketaddress.h
  36  *
  37  * Support for UNIX-domain (also known as local) sockets.
  38  *
  39  * UNIX domain sockets are generally visible in the filesystem.
  40  * However, some systems support abstract socket names which are not
  41  * visible in the filesystem and not affected by the filesystem
  42  * permissions, visibility, etc. Currently this is only supported
  43  * under Linux. If you attempt to use abstract sockets on other
  44  * systems, function calls may return %G_IO_ERROR_NOT_SUPPORTED
  45  * errors. You can use g_unix_socket_address_abstract_names_supported()
  46  * to see if abstract names are supported.
  47  *
  48  * Note that `<gio/gunixsocketaddress.h>` belongs to the UNIX-specific GIO
  49  * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file
  50  * when using it.
  51  */
  52
  53 /**
  54  * GUnixSocketAddress:
  55  *
  56  * A UNIX-domain (local) socket address, corresponding to a
  57  * struct sockaddr_un.
  58  */
  59
  60 enum
  61 {
  62   PROP_0,
  63   PROP_PATH,
  64   PROP_PATH_AS_ARRAY,
  65   PROP_ABSTRACT,
  66   PROP_ADDRESS_TYPE
  67 };
  68
  69 #define UNIX_PATH_MAX sizeof (((struct sockaddr_un *) 0)->sun_path)
  70
  71 struct _GUnixSocketAddressPrivate
  72 {
  73   char path[UNIX_PATH_MAX]; /* Not including the initial zero in abstract case, so
  74                                we can guarantee zero termination of abstract
  75                                pathnames in the get_path() API */
  76   gsize path_len; /* Not including any terminating zeros */
  77   GUnixSocketAddressType address_type;
  78 };
  79
  80 static void   g_unix_socket_address_connectable_iface_init (GSocketConnectableIface *iface);
  81 static gchar *g_unix_socket_address_connectable_to_string  (GSocketConnectable      *connectable);
  82
  83 G_DEFINE_TYPE_WITH_CODE (GUnixSocketAddress, g_unix_socket_address, G_TYPE_SOCKET_ADDRESS,
  84                          G_ADD_PRIVATE (GUnixSocketAddress)
  85                          G_IMPLEMENT_INTERFACE (G_TYPE_SOCKET_CONNECTABLE,
  86                                                 g_unix_socket_address_connectable_iface_init))
  87
  88 static void
  89 g_unix_socket_address_set_property (GObject      *object,
  90                                     guint         prop_id,
  91                                     const GValue *value,
  92                                     GParamSpec   *pspec)
  93 {
  94   GUnixSocketAddress *address = G_UNIX_SOCKET_ADDRESS (object);
  95   const char *str;
  96   GByteArray *array;
  97   gsize len;
  98
  99   switch (prop_id)
 100     {
 101     case PROP_PATH:
 102       str = g_value_get_string (value);
 103       if (str)
 104         {
 105           g_strlcpy (address->priv->path, str,
 106                      sizeof (address->priv->path));
 107           address->priv->path_len = strlen (address->priv->path);
 108         }
 109       break;
 110
 111     case PROP_PATH_AS_ARRAY:
 112       array = g_value_get_boxed (value);
 113
 114       if (array)
 115         {
 116           /* Clip to fit in UNIX_PATH_MAX with zero termination or first byte */
 117           len = MIN (array->len, UNIX_PATH_MAX-1);
 118
 119           if (len != 0)
 120             memcpy (address->priv->path, array->data, len);
 121
 122           address->priv->path[len] = 0; /* Ensure null-terminated */
 123           address->priv->path_len = len;
 124         }
 125       break;
 126
 127     case PROP_ABSTRACT:
 128       /* Only set it if it's not the default... */
 129       if (g_value_get_boolean (value))
 130        address->priv->address_type = G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED;
 131       break;
 132
 133     case PROP_ADDRESS_TYPE:
 134       /* Only set it if it's not the default... */
 135       if (g_value_get_enum (value) != G_UNIX_SOCKET_ADDRESS_PATH)
 136         address->priv->address_type = g_value_get_enum (value);
 137       break;
 138
 139     default:
 140       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 141     }
 142 }
 143
 144 static void
 145 g_unix_socket_address_get_property (GObject    *object,
 146                                     guint       prop_id,
 147                                     GValue     *value,
 148                                     GParamSpec *pspec)
 149 {
 150   GUnixSocketAddress *address = G_UNIX_SOCKET_ADDRESS (object);
 151   GByteArray *array;
 152
 153   switch (prop_id)
 154     {
 155       case PROP_PATH:
 156         g_value_set_string (value, address->priv->path);
 157         break;
 158
 159       case PROP_PATH_AS_ARRAY:
 160         array = g_byte_array_sized_new (address->priv->path_len);
 161         g_byte_array_append (array, (guint8 *)address->priv->path, address->priv->path_len);
 162         g_value_take_boxed (value, array);
 163         break;
 164
 165       case PROP_ABSTRACT:
 166         g_value_set_boolean (value, (address->priv->address_type == G_UNIX_SOCKET_ADDRESS_ABSTRACT ||
 167                                      address->priv->address_type == G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED));
 168
 169         break;
 170
 171       case PROP_ADDRESS_TYPE:
 172         g_value_set_enum (value, address->priv->address_type);
 173         break;
 174
 175       default:
 176         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 177     }
 178 }
 179
 180 static GSocketFamily
 181 g_unix_socket_address_get_family (GSocketAddress *address)
 182 {
 183   g_assert (PF_UNIX == G_SOCKET_FAMILY_UNIX);
 184
 185   return G_SOCKET_FAMILY_UNIX;
 186 }
 187
 188 static gssize
 189 g_unix_socket_address_get_native_size (GSocketAddress *address)
 190 {
 191   GUnixSocketAddress *addr = G_UNIX_SOCKET_ADDRESS (address);
 192
 193   switch (addr->priv->address_type)
 194     {
 195     case G_UNIX_SOCKET_ADDRESS_ANONYMOUS:
 196       return G_STRUCT_OFFSET(struct sockaddr_un, sun_path);
 197     case G_UNIX_SOCKET_ADDRESS_ABSTRACT:
 198       return G_STRUCT_OFFSET(struct sockaddr_un, sun_path) + addr->priv->path_len + 1;
 199     default:
 200       return sizeof (struct sockaddr_un);
 201     }
 202 }
 203
 204 static gboolean
 205 g_unix_socket_address_to_native (GSocketAddress *address,
 206                                  gpointer        dest,
 207                                  gsize           destlen,
 208                                  GError        **error)
 209 {
 210   GUnixSocketAddress *addr = G_UNIX_SOCKET_ADDRESS (address);
 211   struct sockaddr_un *sock;
 212   gssize socklen;
 213
 214   socklen = g_unix_socket_address_get_native_size (address);
 215   if (destlen < socklen)
 216     {
 217       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NO_SPACE,
 218                            _("Not enough space for socket address"));
 219       return FALSE;
 220     }
 221
 222   sock = (struct sockaddr_un *) dest;
 223   memset (sock, 0, socklen);
 224   sock->sun_family = AF_UNIX;
 225
 226   switch (addr->priv->address_type)
 227     {
 228     case G_UNIX_SOCKET_ADDRESS_INVALID:
 229     case G_UNIX_SOCKET_ADDRESS_ANONYMOUS:
 230       break;
 231
 232     case G_UNIX_SOCKET_ADDRESS_PATH:
 233       strcpy (sock->sun_path, addr->priv->path);
 234       break;
 235
 236     case G_UNIX_SOCKET_ADDRESS_ABSTRACT:
 237     case G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED:
 238       if (!g_unix_socket_address_abstract_names_supported ())
 239         {
 240           g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
 241                                _("Abstract UNIX domain socket addresses not supported on this system"));
 242           return FALSE;
 243         }
 244
 245       sock->sun_path[0] = 0;
 246       memcpy (sock->sun_path+1, addr->priv->path, addr->priv->path_len);
 247       break;
 248     }
 249
 250   return TRUE;
 251 }
 252
 253 static void
 254 g_unix_socket_address_class_init (GUnixSocketAddressClass *klass)
 255 {
 256   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 257   GSocketAddressClass *gsocketaddress_class = G_SOCKET_ADDRESS_CLASS (klass);
 258
 259   gobject_class->set_property = g_unix_socket_address_set_property;
 260   gobject_class->get_property = g_unix_socket_address_get_property;
 261
 262   gsocketaddress_class->get_family = g_unix_socket_address_get_family;
 263   gsocketaddress_class->to_native = g_unix_socket_address_to_native;
 264   gsocketaddress_class->get_native_size = g_unix_socket_address_get_native_size;
 265
 266   g_object_class_install_property (gobject_class,
 267                                    PROP_PATH,
 268                                    g_param_spec_string ("path",
 269                                                         P_("Path"),
 270                                                         P_("UNIX socket path"),
 271                                                         NULL,
 272                                                         G_PARAM_READWRITE |
 273                                                         G_PARAM_CONSTRUCT_ONLY |
 274                                                         G_PARAM_STATIC_STRINGS));
 275   g_object_class_install_property (gobject_class, PROP_PATH_AS_ARRAY,
 276                                    g_param_spec_boxed ("path-as-array",
 277                                                        P_("Path array"),
 278                                                        P_("UNIX socket path, as byte array"),
 279                                                        G_TYPE_BYTE_ARRAY,
 280                                                        G_PARAM_READWRITE |
 281                                                        G_PARAM_CONSTRUCT_ONLY |
 282                                                        G_PARAM_STATIC_STRINGS));
 283   /**
 284    * GUnixSocketAddress:abstract:
 285    *
 286    * Whether or not this is an abstract address
 287    *
 288    * Deprecated: Use #GUnixSocketAddress:address-type, which
 289    * distinguishes between zero-padded and non-zero-padded
 290    * abstract addresses.
 291    */
 292   g_object_class_install_property (gobject_class, PROP_ABSTRACT,
 293                                    g_param_spec_boolean ("abstract",
 294                                                          P_("Abstract"),
 295                                                          P_("Whether or not this is an abstract address"),
 296                                                          FALSE,
 297                                                          G_PARAM_READWRITE |
 298                                                          G_PARAM_CONSTRUCT_ONLY |
 299                                                          G_PARAM_STATIC_STRINGS));
 300   g_object_class_install_property (gobject_class, PROP_ADDRESS_TYPE,
 301                                    g_param_spec_enum ("address-type",
 302                                                       P_("Address type"),
 303                                                       P_("The type of UNIX socket address"),
 304                                                       G_TYPE_UNIX_SOCKET_ADDRESS_TYPE,
 305                                                       G_UNIX_SOCKET_ADDRESS_PATH,
 306                                                       G_PARAM_READWRITE |
 307                                                       G_PARAM_CONSTRUCT_ONLY |
 308                                                       G_PARAM_STATIC_STRINGS));
 309 }
 310
 311 static void
 312 g_unix_socket_address_connectable_iface_init (GSocketConnectableIface *iface)
 313 {
 314   GSocketConnectableIface *parent_iface = g_type_interface_peek_parent (iface);
 315
 316   iface->enumerate = parent_iface->enumerate;
 317   iface->proxy_enumerate = parent_iface->proxy_enumerate;
 318   iface->to_string = g_unix_socket_address_connectable_to_string;
 319 }
 320
 321 static gchar *
 322 g_unix_socket_address_connectable_to_string (GSocketConnectable *connectable)
 323 {
 324   GUnixSocketAddress *ua;
 325   GString *out;
 326   const gchar *path;
 327   gsize path_len, i;
 328
 329   ua = G_UNIX_SOCKET_ADDRESS (connectable);
 330
 331   /* Anonymous sockets have no path. */
 332   if (ua->priv->address_type == G_UNIX_SOCKET_ADDRESS_ANONYMOUS)
 333     return g_strdup ("anonymous");
 334
 335   path = g_unix_socket_address_get_path (ua);
 336   path_len = g_unix_socket_address_get_path_len (ua);
 337   out = g_string_sized_new (path_len);
 338
 339   /* Return the #GUnixSocketAddress:path, but with all non-printable characters
 340    * (including nul bytes) escaped to hex. */
 341   for (i = 0; i < path_len; i++)
 342     {
 343       guint8 c = path[i];
 344
 345       if (g_ascii_isprint (path[i]))
 346         g_string_append_c (out, c);
 347       else
 348         g_string_append_printf (out, "\\x%02x", (guint) c);
 349     }
 350
 351   return g_string_free (out, FALSE);
 352 }
 353
 354 static void
 355 g_unix_socket_address_init (GUnixSocketAddress *address)
 356 {
 357   address->priv = g_unix_socket_address_get_instance_private (address);
 358
 359   memset (address->priv->path, 0, sizeof (address->priv->path));
 360   address->priv->path_len = -1;
 361   address->priv->address_type = G_UNIX_SOCKET_ADDRESS_PATH;
 362 }
 363
 364 /**
 365  * g_unix_socket_address_new:
 366  * @path: the socket path
 367  *
 368  * Creates a new #GUnixSocketAddress for @path.
 369  *
 370  * To create abstract socket addresses, on systems that support that,
 371  * use g_unix_socket_address_new_abstract().
 372  *
 373  * Returns: a new #GUnixSocketAddress
 374  *
 375  * Since: 2.22
 376  */
 377 GSocketAddress *
 378 g_unix_socket_address_new (const gchar *path)
 379 {
 380   return g_object_new (G_TYPE_UNIX_SOCKET_ADDRESS,
 381                        "path", path,
 382                        "abstract", FALSE,
 383                        NULL);
 384 }
 385
 386 /**
 387  * g_unix_socket_address_new_abstract:
 388  * @path: (array length=path_len) (element-type gchar): the abstract name
 389  * @path_len: the length of @path, or -1
 390  *
 391  * Creates a new %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
 392  * #GUnixSocketAddress for @path.
 393  *
 394  * Returns: a new #GUnixSocketAddress
 395  *
 396  * Deprecated: Use g_unix_socket_address_new_with_type().
 397  */
 398 GSocketAddress *
 399 g_unix_socket_address_new_abstract (const gchar *path,
 400                                     gint         path_len)
 401 {
 402   return g_unix_socket_address_new_with_type (path, path_len,
 403                                               G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED);
 404 }
 405
 406 /**
 407  * g_unix_socket_address_new_with_type:
 408  * @path: (array length=path_len) (element-type gchar): the name
 409  * @path_len: the length of @path, or -1
 410  * @type: a #GUnixSocketAddressType
 411  *
 412  * Creates a new #GUnixSocketAddress of type @type with name @path.
 413  *
 414  * If @type is %G_UNIX_SOCKET_ADDRESS_PATH, this is equivalent to
 415  * calling g_unix_socket_address_new().
 416  *
 417  * If @type is %G_UNIX_SOCKET_ADDRESS_ANONYMOUS, @path and @path_len will be
 418  * ignored.
 419  *
 420  * If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT, then @path_len
 421  * bytes of @path will be copied to the socket's path, and only those
 422  * bytes will be considered part of the name. (If @path_len is -1,
 423  * then @path is assumed to be NUL-terminated.) For example, if @path
 424  * was "test", then calling g_socket_address_get_native_size() on the
 425  * returned socket would return 7 (2 bytes of overhead, 1 byte for the
 426  * abstract-socket indicator byte, and 4 bytes for the name "test").
 427  *
 428  * If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, then
 429  * @path_len bytes of @path will be copied to the socket's path, the
 430  * rest of the path will be padded with 0 bytes, and the entire
 431  * zero-padded buffer will be considered the name. (As above, if
 432  * @path_len is -1, then @path is assumed to be NUL-terminated.) In
 433  * this case, g_socket_address_get_native_size() will always return
 434  * the full size of a `struct sockaddr_un`, although
 435  * g_unix_socket_address_get_path_len() will still return just the
 436  * length of @path.
 437  *
 438  * %G_UNIX_SOCKET_ADDRESS_ABSTRACT is preferred over
 439  * %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED for new programs. Of course,
 440  * when connecting to a server created by another process, you must
 441  * use the appropriate type corresponding to how that process created
 442  * its listening socket.
 443  *
 444  * Returns: a new #GUnixSocketAddress
 445  *
 446  * Since: 2.26
 447  */
 448 GSocketAddress *
 449 g_unix_socket_address_new_with_type (const gchar            *path,
 450                                      gint                    path_len,
 451                                      GUnixSocketAddressType  type)
 452 {
 453   GSocketAddress *address;
 454   GByteArray *array;
 455
 456   if (type == G_UNIX_SOCKET_ADDRESS_ANONYMOUS)
 457     path_len = 0;
 458   else if (path_len == -1)
 459     path_len = strlen (path);
 460
 461   array = g_byte_array_sized_new (path_len);
 462
 463   g_byte_array_append (array, (guint8 *)path, path_len);
 464
 465   address = g_object_new (G_TYPE_UNIX_SOCKET_ADDRESS,
 466                           "path-as-array", array,
 467                           "address-type", type,
 468                           NULL);
 469
 470   g_byte_array_unref (array);
 471
 472   return address;
 473 }
 474
 475 /**
 476  * g_unix_socket_address_get_path:
 477  * @address: a #GInetSocketAddress
 478  *
 479  * Gets @address's path, or for abstract sockets the "name".
 480  *
 481  * Guaranteed to be zero-terminated, but an abstract socket
 482  * may contain embedded zeros, and thus you should use
 483  * g_unix_socket_address_get_path_len() to get the true length
 484  * of this string.
 485  *
 486  * Returns: the path for @address
 487  *
 488  * Since: 2.22
 489  */
 490 const char *
 491 g_unix_socket_address_get_path (GUnixSocketAddress *address)
 492 {
 493   return address->priv->path;
 494 }
 495
 496 /**
 497  * g_unix_socket_address_get_path_len:
 498  * @address: a #GInetSocketAddress
 499  *
 500  * Gets the length of @address's path.
 501  *
 502  * For details, see g_unix_socket_address_get_path().
 503  *
 504  * Returns: the length of the path
 505  *
 506  * Since: 2.22
 507  */
 508 gsize
 509 g_unix_socket_address_get_path_len (GUnixSocketAddress *address)
 510 {
 511   return address->priv->path_len;
 512 }
 513
 514 /**
 515  * g_unix_socket_address_get_address_type:
 516  * @address: a #GInetSocketAddress
 517  *
 518  * Gets @address's type.
 519  *
 520  * Returns: a #GUnixSocketAddressType
 521  *
 522  * Since: 2.26
 523  */
 524 GUnixSocketAddressType
 525 g_unix_socket_address_get_address_type (GUnixSocketAddress *address)
 526 {
 527   return address->priv->address_type;
 528 }
 529
 530 /**
 531  * g_unix_socket_address_get_is_abstract:
 532  * @address: a #GInetSocketAddress
 533  *
 534  * Tests if @address is abstract.
 535  *
 536  * Returns: %TRUE if the address is abstract, %FALSE otherwise
 537  *
 538  * Since: 2.22
 539  *
 540  * Deprecated: Use g_unix_socket_address_get_address_type()
 541  */
 542 gboolean
 543 g_unix_socket_address_get_is_abstract (GUnixSocketAddress *address)
 544 {
 545   return (address->priv->address_type == G_UNIX_SOCKET_ADDRESS_ABSTRACT ||
 546           address->priv->address_type == G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED);
 547 }
 548
 549 /**
 550  * g_unix_socket_address_abstract_names_supported:
 551  *
 552  * Checks if abstract UNIX domain socket names are supported.
 553  *
 554  * Returns: %TRUE if supported, %FALSE otherwise
 555  *
 556  * Since: 2.22
 557  */
 558 gboolean
 559 g_unix_socket_address_abstract_names_supported (void)
 560 {
 561 #ifdef __linux__
 562   return TRUE;
 563 #else
 564   return FALSE;
 565 #endif
 566 }