1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2008 Christian Kellner, Samuel Cormier-Iijima
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.1 of the License, or (at your option) any later version.
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.
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/>.
18 * Authors: Christian Kellner <gicmo@gnome.org>
19 * Samuel Cormier-Iijima <sciyoshi@gmail.com>
26 #include "gunixsocketaddress.h"
27 #include "gsocketconnectable.h"
29 #include "gnetworking.h"
33 * SECTION:gunixsocketaddress
34 * @short_description: UNIX GSocketAddress
35 * @include: gio/gunixsocketaddress.h
37 * Support for UNIX-domain (also known as local) sockets.
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.
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
56 * A UNIX-domain (local) socket address, corresponding to a
69 #define UNIX_PATH_MAX sizeof (((struct sockaddr_un *) 0)->sun_path)
71 struct _GUnixSocketAddressPrivate
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
;
80 static void g_unix_socket_address_connectable_iface_init (GSocketConnectableIface
*iface
);
81 static gchar
*g_unix_socket_address_connectable_to_string (GSocketConnectable
*connectable
);
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
))
89 g_unix_socket_address_set_property (GObject
*object
,
94 GUnixSocketAddress
*address
= G_UNIX_SOCKET_ADDRESS (object
);
102 str
= g_value_get_string (value
);
105 g_strlcpy (address
->priv
->path
, str
,
106 sizeof (address
->priv
->path
));
107 address
->priv
->path_len
= strlen (address
->priv
->path
);
111 case PROP_PATH_AS_ARRAY
:
112 array
= g_value_get_boxed (value
);
116 /* Clip to fit in UNIX_PATH_MAX with zero termination or first byte */
117 len
= MIN (array
->len
, UNIX_PATH_MAX
-1);
120 memcpy (address
->priv
->path
, array
->data
, len
);
122 address
->priv
->path
[len
] = 0; /* Ensure null-terminated */
123 address
->priv
->path_len
= len
;
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
;
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
);
140 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
145 g_unix_socket_address_get_property (GObject
*object
,
150 GUnixSocketAddress
*address
= G_UNIX_SOCKET_ADDRESS (object
);
156 g_value_set_string (value
, address
->priv
->path
);
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
);
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
));
171 case PROP_ADDRESS_TYPE
:
172 g_value_set_enum (value
, address
->priv
->address_type
);
176 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
181 g_unix_socket_address_get_family (GSocketAddress
*address
)
183 g_assert (PF_UNIX
== G_SOCKET_FAMILY_UNIX
);
185 return G_SOCKET_FAMILY_UNIX
;
189 g_unix_socket_address_get_native_size (GSocketAddress
*address
)
191 GUnixSocketAddress
*addr
= G_UNIX_SOCKET_ADDRESS (address
);
193 switch (addr
->priv
->address_type
)
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;
200 return sizeof (struct sockaddr_un
);
205 g_unix_socket_address_to_native (GSocketAddress
*address
,
210 GUnixSocketAddress
*addr
= G_UNIX_SOCKET_ADDRESS (address
);
211 struct sockaddr_un
*sock
;
214 socklen
= g_unix_socket_address_get_native_size (address
);
215 if (destlen
< socklen
)
217 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_NO_SPACE
,
218 _("Not enough space for socket address"));
222 sock
= (struct sockaddr_un
*) dest
;
223 memset (sock
, 0, socklen
);
224 sock
->sun_family
= AF_UNIX
;
226 switch (addr
->priv
->address_type
)
228 case G_UNIX_SOCKET_ADDRESS_INVALID
:
229 case G_UNIX_SOCKET_ADDRESS_ANONYMOUS
:
232 case G_UNIX_SOCKET_ADDRESS_PATH
:
233 strcpy (sock
->sun_path
, addr
->priv
->path
);
236 case G_UNIX_SOCKET_ADDRESS_ABSTRACT
:
237 case G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
:
238 if (!g_unix_socket_address_abstract_names_supported ())
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"));
245 sock
->sun_path
[0] = 0;
246 memcpy (sock
->sun_path
+1, addr
->priv
->path
, addr
->priv
->path_len
);
254 g_unix_socket_address_class_init (GUnixSocketAddressClass
*klass
)
256 GObjectClass
*gobject_class
= G_OBJECT_CLASS (klass
);
257 GSocketAddressClass
*gsocketaddress_class
= G_SOCKET_ADDRESS_CLASS (klass
);
259 gobject_class
->set_property
= g_unix_socket_address_set_property
;
260 gobject_class
->get_property
= g_unix_socket_address_get_property
;
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
;
266 g_object_class_install_property (gobject_class
,
268 g_param_spec_string ("path",
270 P_("UNIX socket path"),
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",
278 P_("UNIX socket path, as byte array"),
281 G_PARAM_CONSTRUCT_ONLY
|
282 G_PARAM_STATIC_STRINGS
));
284 * GUnixSocketAddress:abstract:
286 * Whether or not this is an abstract address
288 * Deprecated: Use #GUnixSocketAddress:address-type, which
289 * distinguishes between zero-padded and non-zero-padded
290 * abstract addresses.
292 g_object_class_install_property (gobject_class
, PROP_ABSTRACT
,
293 g_param_spec_boolean ("abstract",
295 P_("Whether or not this is an abstract address"),
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",
303 P_("The type of UNIX socket address"),
304 G_TYPE_UNIX_SOCKET_ADDRESS_TYPE
,
305 G_UNIX_SOCKET_ADDRESS_PATH
,
307 G_PARAM_CONSTRUCT_ONLY
|
308 G_PARAM_STATIC_STRINGS
));
312 g_unix_socket_address_connectable_iface_init (GSocketConnectableIface
*iface
)
314 GSocketConnectableIface
*parent_iface
= g_type_interface_peek_parent (iface
);
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
;
322 g_unix_socket_address_connectable_to_string (GSocketConnectable
*connectable
)
324 GUnixSocketAddress
*ua
;
329 ua
= G_UNIX_SOCKET_ADDRESS (connectable
);
331 /* Anonymous sockets have no path. */
332 if (ua
->priv
->address_type
== G_UNIX_SOCKET_ADDRESS_ANONYMOUS
)
333 return g_strdup ("anonymous");
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
);
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
++)
345 if (g_ascii_isprint (path
[i
]))
346 g_string_append_c (out
, c
);
348 g_string_append_printf (out
, "\\x%02x", (guint
) c
);
351 return g_string_free (out
, FALSE
);
355 g_unix_socket_address_init (GUnixSocketAddress
*address
)
357 address
->priv
= g_unix_socket_address_get_instance_private (address
);
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
;
365 * g_unix_socket_address_new:
366 * @path: the socket path
368 * Creates a new #GUnixSocketAddress for @path.
370 * To create abstract socket addresses, on systems that support that,
371 * use g_unix_socket_address_new_abstract().
373 * Returns: a new #GUnixSocketAddress
378 g_unix_socket_address_new (const gchar
*path
)
380 return g_object_new (G_TYPE_UNIX_SOCKET_ADDRESS
,
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
391 * Creates a new %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
392 * #GUnixSocketAddress for @path.
394 * Returns: a new #GUnixSocketAddress
396 * Deprecated: Use g_unix_socket_address_new_with_type().
399 g_unix_socket_address_new_abstract (const gchar
*path
,
402 return g_unix_socket_address_new_with_type (path
, path_len
,
403 G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
);
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
412 * Creates a new #GUnixSocketAddress of type @type with name @path.
414 * If @type is %G_UNIX_SOCKET_ADDRESS_PATH, this is equivalent to
415 * calling g_unix_socket_address_new().
417 * If @type is %G_UNIX_SOCKET_ADDRESS_ANONYMOUS, @path and @path_len will be
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").
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
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.
444 * Returns: a new #GUnixSocketAddress
449 g_unix_socket_address_new_with_type (const gchar
*path
,
451 GUnixSocketAddressType type
)
453 GSocketAddress
*address
;
456 if (type
== G_UNIX_SOCKET_ADDRESS_ANONYMOUS
)
458 else if (path_len
== -1)
459 path_len
= strlen (path
);
461 array
= g_byte_array_sized_new (path_len
);
463 g_byte_array_append (array
, (guint8
*)path
, path_len
);
465 address
= g_object_new (G_TYPE_UNIX_SOCKET_ADDRESS
,
466 "path-as-array", array
,
467 "address-type", type
,
470 g_byte_array_unref (array
);
476 * g_unix_socket_address_get_path:
477 * @address: a #GInetSocketAddress
479 * Gets @address's path, or for abstract sockets the "name".
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
486 * Returns: the path for @address
491 g_unix_socket_address_get_path (GUnixSocketAddress
*address
)
493 return address
->priv
->path
;
497 * g_unix_socket_address_get_path_len:
498 * @address: a #GInetSocketAddress
500 * Gets the length of @address's path.
502 * For details, see g_unix_socket_address_get_path().
504 * Returns: the length of the path
509 g_unix_socket_address_get_path_len (GUnixSocketAddress
*address
)
511 return address
->priv
->path_len
;
515 * g_unix_socket_address_get_address_type:
516 * @address: a #GInetSocketAddress
518 * Gets @address's type.
520 * Returns: a #GUnixSocketAddressType
524 GUnixSocketAddressType
525 g_unix_socket_address_get_address_type (GUnixSocketAddress
*address
)
527 return address
->priv
->address_type
;
531 * g_unix_socket_address_get_is_abstract:
532 * @address: a #GInetSocketAddress
534 * Tests if @address is abstract.
536 * Returns: %TRUE if the address is abstract, %FALSE otherwise
540 * Deprecated: Use g_unix_socket_address_get_address_type()
543 g_unix_socket_address_get_is_abstract (GUnixSocketAddress
*address
)
545 return (address
->priv
->address_type
== G_UNIX_SOCKET_ADDRESS_ABSTRACT
||
546 address
->priv
->address_type
== G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
);
550 * g_unix_socket_address_abstract_names_supported:
552 * Checks if abstract UNIX domain socket names are supported.
554 * Returns: %TRUE if supported, %FALSE otherwise
559 g_unix_socket_address_abstract_names_supported (void)