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 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, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
20 * Authors: Christian Kellner <gicmo@gnome.org>
21 * Samuel Cormier-Iijima <sciyoshi@gmail.com>
28 #include "gunixsocketaddress.h"
30 #include "gnetworkingprivate.h"
34 * SECTION:gunixsocketaddress
35 * @short_description: UNIX GSocketAddress
36 * @include: gio/gunixsocketaddress.h
38 * Support for UNIX-domain (also known as local) sockets.
40 * UNIX domain sockets are generally visible in the filesystem.
41 * However, some systems support abstract socket names which are not
42 * visible in the filesystem and not affected by the filesystem
43 * permissions, visibility, etc. Currently this is only supported
44 * under Linux. If you attempt to use abstract sockets on other
45 * systems, function calls may return %G_IO_ERROR_NOT_SUPPORTED
46 * errors. You can use g_unix_socket_address_abstract_names_supported()
47 * to see if abstract names are supported.
49 * Note that <filename><gio/gunixsocketaddress.h></filename> belongs to
50 * the UNIX-specific GIO interfaces, thus you have to use the
51 * <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
57 * A UNIX-domain (local) socket address, corresponding to a
58 * <type>struct sockaddr_un</type>.
60 G_DEFINE_TYPE (GUnixSocketAddress
, g_unix_socket_address
, G_TYPE_SOCKET_ADDRESS
);
71 #define UNIX_PATH_MAX sizeof (((struct sockaddr_un *) 0)->sun_path)
73 struct _GUnixSocketAddressPrivate
75 char path
[UNIX_PATH_MAX
]; /* Not including the initial zero in abstract case, so
76 we can guarantee zero termination of abstract
77 pathnames in the get_path() API */
78 gsize path_len
; /* Not including any terminating zeros */
79 GUnixSocketAddressType address_type
;
83 g_unix_socket_address_set_property (GObject
*object
,
88 GUnixSocketAddress
*address
= G_UNIX_SOCKET_ADDRESS (object
);
96 str
= g_value_get_string (value
);
99 g_strlcpy (address
->priv
->path
, str
,
100 sizeof (address
->priv
->path
));
101 address
->priv
->path_len
= strlen (address
->priv
->path
);
105 case PROP_PATH_AS_ARRAY
:
106 array
= g_value_get_boxed (value
);
110 /* Clip to fit in UNIX_PATH_MAX with zero termination or first byte */
111 len
= MIN (array
->len
, UNIX_PATH_MAX
-1);
113 memcpy (address
->priv
->path
, array
->data
, len
);
114 address
->priv
->path
[len
] = 0; /* Ensure null-terminated */
115 address
->priv
->path_len
= len
;
120 /* If the caller already set PROP_ADDRESS_TYPE, don't let the
121 * default value of PROP_ABSTRACT overwrite it.
123 if (address
->priv
->address_type
!= G_UNIX_SOCKET_ADDRESS_INVALID
)
126 if (g_value_get_boolean (value
))
127 address
->priv
->address_type
= G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
;
129 address
->priv
->address_type
= G_UNIX_SOCKET_ADDRESS_PATH
;
132 case PROP_ADDRESS_TYPE
:
133 /* If the caller already set PROP_ABSTRACT, don't let the
134 * default value of PROP_ADDRESS_TYPE overwrite it.
136 if (address
->priv
->address_type
!= G_UNIX_SOCKET_ADDRESS_INVALID
)
139 address
->priv
->address_type
= g_value_get_enum (value
);
143 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
148 g_unix_socket_address_get_property (GObject
*object
,
153 GUnixSocketAddress
*address
= G_UNIX_SOCKET_ADDRESS (object
);
159 g_value_set_string (value
, address
->priv
->path
);
162 case PROP_PATH_AS_ARRAY
:
163 array
= g_byte_array_sized_new (address
->priv
->path_len
);
164 g_byte_array_append (array
, (guint8
*)address
->priv
->path
, address
->priv
->path_len
);
165 g_value_take_boxed (value
, array
);
169 g_value_set_boolean (value
, (address
->priv
->address_type
== G_UNIX_SOCKET_ADDRESS_ABSTRACT
||
170 address
->priv
->address_type
== G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
));
174 case PROP_ADDRESS_TYPE
:
175 g_value_set_enum (value
, address
->priv
->address_type
);
179 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
184 g_unix_socket_address_get_family (GSocketAddress
*address
)
186 g_assert (PF_UNIX
== G_SOCKET_FAMILY_UNIX
);
188 return G_SOCKET_FAMILY_UNIX
;
192 g_unix_socket_address_get_native_size (GSocketAddress
*address
)
194 GUnixSocketAddress
*addr
= G_UNIX_SOCKET_ADDRESS (address
);
196 switch (addr
->priv
->address_type
)
198 case G_UNIX_SOCKET_ADDRESS_ANONYMOUS
:
199 return G_STRUCT_OFFSET(struct sockaddr_un
, sun_path
);
200 case G_UNIX_SOCKET_ADDRESS_ABSTRACT
:
201 return G_STRUCT_OFFSET(struct sockaddr_un
, sun_path
) + addr
->priv
->path_len
+ 1;
203 return sizeof (struct sockaddr_un
);
208 g_unix_socket_address_to_native (GSocketAddress
*address
,
213 GUnixSocketAddress
*addr
= G_UNIX_SOCKET_ADDRESS (address
);
214 struct sockaddr_un
*sock
;
217 socklen
= g_unix_socket_address_get_native_size (address
);
218 if (destlen
< socklen
)
220 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_NO_SPACE
,
221 _("Not enough space for socket address"));
225 sock
= (struct sockaddr_un
*) dest
;
226 memset (sock
, 0, socklen
);
227 sock
->sun_family
= AF_UNIX
;
229 switch (addr
->priv
->address_type
)
231 case G_UNIX_SOCKET_ADDRESS_INVALID
:
232 case G_UNIX_SOCKET_ADDRESS_ANONYMOUS
:
235 case G_UNIX_SOCKET_ADDRESS_PATH
:
236 strcpy (sock
->sun_path
, addr
->priv
->path
);
239 case G_UNIX_SOCKET_ADDRESS_ABSTRACT
:
240 case G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
:
241 if (!g_unix_socket_address_abstract_names_supported ())
243 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
244 _("Abstract unix domain socket addresses not supported on this system"));
248 sock
->sun_path
[0] = 0;
249 memcpy (sock
->sun_path
+1, addr
->priv
->path
, addr
->priv
->path_len
);
257 g_unix_socket_address_class_init (GUnixSocketAddressClass
*klass
)
259 GObjectClass
*gobject_class
= G_OBJECT_CLASS (klass
);
260 GSocketAddressClass
*gsocketaddress_class
= G_SOCKET_ADDRESS_CLASS (klass
);
262 g_type_class_add_private (klass
, sizeof (GUnixSocketAddressPrivate
));
264 gobject_class
->set_property
= g_unix_socket_address_set_property
;
265 gobject_class
->get_property
= g_unix_socket_address_get_property
;
267 gsocketaddress_class
->get_family
= g_unix_socket_address_get_family
;
268 gsocketaddress_class
->to_native
= g_unix_socket_address_to_native
;
269 gsocketaddress_class
->get_native_size
= g_unix_socket_address_get_native_size
;
271 g_object_class_install_property (gobject_class
,
273 g_param_spec_string ("path",
275 P_("UNIX socket path"),
278 G_PARAM_CONSTRUCT_ONLY
|
279 G_PARAM_STATIC_STRINGS
));
280 g_object_class_install_property (gobject_class
, PROP_PATH_AS_ARRAY
,
281 g_param_spec_boxed ("path-as-array",
283 P_("UNIX socket path, as byte array"),
286 G_PARAM_CONSTRUCT_ONLY
|
287 G_PARAM_STATIC_STRINGS
));
289 * GUnixSocketAddress:abstract:
291 * Whether or not this is an abstract address
293 * Deprecated: Use #GUnixSocketAddress:address-type, which
294 * distinguishes between zero-padded and non-zero-padded
295 * abstract addresses.
297 g_object_class_install_property (gobject_class
, PROP_ABSTRACT
,
298 g_param_spec_boolean ("abstract",
300 P_("Whether or not this is an abstract address"),
303 G_PARAM_CONSTRUCT_ONLY
|
304 G_PARAM_STATIC_STRINGS
));
305 g_object_class_install_property (gobject_class
, PROP_ADDRESS_TYPE
,
306 g_param_spec_enum ("address-type",
308 P_("The type of UNIX socket address"),
309 G_TYPE_UNIX_SOCKET_ADDRESS_TYPE
,
310 G_UNIX_SOCKET_ADDRESS_PATH
,
312 G_PARAM_CONSTRUCT_ONLY
|
313 G_PARAM_STATIC_STRINGS
));
317 g_unix_socket_address_init (GUnixSocketAddress
*address
)
319 address
->priv
= G_TYPE_INSTANCE_GET_PRIVATE (address
,
320 G_TYPE_UNIX_SOCKET_ADDRESS
,
321 GUnixSocketAddressPrivate
);
323 memset (address
->priv
->path
, 0, sizeof (address
->priv
->path
));
324 address
->priv
->path_len
= -1;
325 address
->priv
->address_type
= G_UNIX_SOCKET_ADDRESS_INVALID
;
329 * g_unix_socket_address_new:
330 * @path: the socket path
332 * Creates a new #GUnixSocketAddress for @path.
334 * To create abstract socket addresses, on systems that support that,
335 * use g_unix_socket_address_new_abstract().
337 * Returns: a new #GUnixSocketAddress
342 g_unix_socket_address_new (const gchar
*path
)
344 return g_object_new (G_TYPE_UNIX_SOCKET_ADDRESS
,
351 * g_unix_socket_address_new_abstract:
352 * @path: (array length=path_len) (element-type gchar): the abstract name
353 * @path_len: the length of @path, or -1
355 * Creates a new %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
356 * #GUnixSocketAddress for @path.
358 * Returns: a new #GUnixSocketAddress
360 * Deprecated: Use g_unix_socket_address_new_with_type().
363 g_unix_socket_address_new_abstract (const gchar
*path
,
366 return g_unix_socket_address_new_with_type (path
, path_len
,
367 G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
);
371 * g_unix_socket_address_new_with_type:
372 * @path: (array length=path_len) (element-type gchar): the name
373 * @path_len: the length of @path, or -1
374 * @type: a #GUnixSocketAddressType
376 * Creates a new #GUnixSocketAddress of type @type with name @path.
378 * If @type is %G_UNIX_SOCKET_ADDRESS_PATH, this is equivalent to
379 * calling g_unix_socket_address_new().
381 * If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT, then @path_len
382 * bytes of @path will be copied to the socket's path, and only those
383 * bytes will be considered part of the name. (If @path_len is -1,
384 * then @path is assumed to be NUL-terminated.) For example, if @path
385 * was "test", then calling g_socket_address_get_native_size() on the
386 * returned socket would return 7 (2 bytes of overhead, 1 byte for the
387 * abstract-socket indicator byte, and 4 bytes for the name "test").
389 * If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, then
390 * @path_len bytes of @path will be copied to the socket's path, the
391 * rest of the path will be padded with 0 bytes, and the entire
392 * zero-padded buffer will be considered the name. (As above, if
393 * @path_len is -1, then @path is assumed to be NUL-terminated.) In
394 * this case, g_socket_address_get_native_size() will always return
395 * the full size of a <literal>struct sockaddr_un</literal>, although
396 * g_unix_socket_address_get_path_len() will still return just the
399 * %G_UNIX_SOCKET_ADDRESS_ABSTRACT is preferred over
400 * %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED for new programs. Of course,
401 * when connecting to a server created by another process, you must
402 * use the appropriate type corresponding to how that process created
403 * its listening socket.
405 * Returns: a new #GUnixSocketAddress
410 g_unix_socket_address_new_with_type (const gchar
*path
,
412 GUnixSocketAddressType type
)
414 GSocketAddress
*address
;
417 if (type
== G_UNIX_SOCKET_ADDRESS_ANONYMOUS
)
419 else if (path_len
== -1)
420 path_len
= strlen (path
);
422 array
= g_byte_array_sized_new (path_len
);
424 g_byte_array_append (array
, (guint8
*)path
, path_len
);
426 address
= g_object_new (G_TYPE_UNIX_SOCKET_ADDRESS
,
427 "path-as-array", array
,
428 "address-type", type
,
431 g_byte_array_unref (array
);
437 * g_unix_socket_address_get_path:
438 * @address: a #GInetSocketAddress
440 * Gets @address's path, or for abstract sockets the "name".
442 * Guaranteed to be zero-terminated, but an abstract socket
443 * may contain embedded zeros, and thus you should use
444 * g_unix_socket_address_get_path_len() to get the true length
447 * Returns: the path for @address
452 g_unix_socket_address_get_path (GUnixSocketAddress
*address
)
454 return address
->priv
->path
;
458 * g_unix_socket_address_get_path_len:
459 * @address: a #GInetSocketAddress
461 * Gets the length of @address's path.
463 * For details, see g_unix_socket_address_get_path().
465 * Returns: the length of the path
470 g_unix_socket_address_get_path_len (GUnixSocketAddress
*address
)
472 return address
->priv
->path_len
;
476 * g_unix_socket_address_get_address_type:
477 * @address: a #GInetSocketAddress
479 * Gets @address's type.
481 * Returns: a #GUnixSocketAddressType
485 GUnixSocketAddressType
486 g_unix_socket_address_get_address_type (GUnixSocketAddress
*address
)
488 return address
->priv
->address_type
;
492 * g_unix_socket_address_get_is_abstract:
493 * @address: a #GInetSocketAddress
495 * Tests if @address is abstract.
497 * Returns: %TRUE if the address is abstract, %FALSE otherwise
501 * Deprecated: Use g_unix_socket_address_get_address_type()
504 g_unix_socket_address_get_is_abstract (GUnixSocketAddress
*address
)
506 return (address
->priv
->address_type
== G_UNIX_SOCKET_ADDRESS_ABSTRACT
||
507 address
->priv
->address_type
== G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
);
511 * g_unix_socket_address_abstract_names_supported:
513 * Checks if abstract unix domain socket names are supported.
515 * Returns: %TRUE if supported, %FALSE otherwise
520 g_unix_socket_address_abstract_names_supported (void)