1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-sysdeps-unix.c Wrappers around UNIX system/libc features (internal to D-Bus implementation)
4 * Copyright (C) 2002, 2003, 2006 Red Hat, Inc.
5 * Copyright (C) 2003 CodeFactory AB
7 * Licensed under the Academic Free License version 2.1
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "dbus-internals.h"
28 #include "dbus-sysdeps.h"
29 #include "dbus-sysdeps-unix.h"
30 #include "dbus-threads.h"
31 #include "dbus-protocol.h"
32 #include "dbus-transport.h"
33 #include "dbus-string.h"
34 #include "dbus-userdb.h"
35 #include "dbus-list.h"
36 #include "dbus-credentials.h"
37 #include "dbus-nonce.h"
39 #include <sys/types.h>
46 #include <sys/socket.h>
55 #include <netinet/in.h>
71 #ifdef HAVE_GETPEERUCRED
79 #include "sd-daemon.h"
86 #define AI_ADDRCONFIG 0
89 #ifndef HAVE_SOCKLEN_T
94 _dbus_open_socket (int *fd_p,
101 dbus_bool_t cloexec_done;
103 *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
104 cloexec_done = *fd_p >= 0;
106 /* Check if kernel seems to be too old to know SOCK_CLOEXEC */
107 if (*fd_p < 0 && errno == EINVAL)
110 *fd_p = socket (domain, type, protocol);
119 _dbus_fd_set_close_on_exec(*fd_p);
122 _dbus_verbose ("socket fd %d opened\n", *fd_p);
127 dbus_set_error(error,
128 _dbus_error_from_errno (errno),
129 "Failed to open socket: %s",
130 _dbus_strerror (errno));
136 * Opens a UNIX domain socket (as in the socket() call).
137 * Does not bind the socket.
139 * This will set FD_CLOEXEC for the socket returned
141 * @param fd return location for socket descriptor
142 * @param error return location for an error
143 * @returns #FALSE if error is set
146 _dbus_open_unix_socket (int *fd,
149 return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);
153 * Closes a socket. Should not be used on non-socket
154 * file descriptors or handles.
156 * @param fd the socket
157 * @param error return location for an error
158 * @returns #FALSE if error is set
161 _dbus_close_socket (int fd,
164 return _dbus_close (fd, error);
168 * Like _dbus_read(), but only works on sockets so is
169 * available on Windows.
171 * @param fd the socket
172 * @param buffer string to append data to
173 * @param count max amount of data to read
174 * @returns number of bytes appended to the string
177 _dbus_read_socket (int fd,
181 return _dbus_read (fd, buffer, count);
185 * Like _dbus_write(), but only supports sockets
186 * and is thus available on Windows.
188 * @param fd the file descriptor to write
189 * @param buffer the buffer to write data from
190 * @param start the first byte in the buffer to write
191 * @param len the number of bytes to try to write
192 * @returns the number of bytes written or -1 on error
195 _dbus_write_socket (int fd,
196 const DBusString *buffer,
200 #if HAVE_DECL_MSG_NOSIGNAL
204 data = _dbus_string_get_const_data_len (buffer, start, len);
208 bytes_written = send (fd, data, len, MSG_NOSIGNAL);
210 if (bytes_written < 0 && errno == EINTR)
213 return bytes_written;
216 return _dbus_write (fd, buffer, start, len);
221 * Like _dbus_read_socket() but also tries to read unix fds from the
222 * socket. When there are more fds to read than space in the array
223 * passed this function will fail with ENOSPC.
225 * @param fd the socket
226 * @param buffer string to append data to
227 * @param count max amount of data to read
228 * @param fds array to place read file descriptors in
229 * @param n_fds on input space in fds array, on output how many fds actually got read
230 * @returns number of bytes appended to string
233 _dbus_read_socket_with_unix_fds (int fd,
238 #ifndef HAVE_UNIX_FD_PASSING
241 if ((r = _dbus_read_socket(fd, buffer, count)) < 0)
253 _dbus_assert (count >= 0);
254 _dbus_assert (*n_fds >= 0);
256 start = _dbus_string_get_length (buffer);
258 if (!_dbus_string_lengthen (buffer, count))
265 iov.iov_base = _dbus_string_get_data_len (buffer, start, count);
272 /* Hmm, we have no clue how long the control data will actually be
273 that is queued for us. The least we can do is assume that the
274 caller knows. Hence let's make space for the number of fds that
275 we shall read at max plus the cmsg header. */
276 m.msg_controllen = CMSG_SPACE(*n_fds * sizeof(int));
278 /* It's probably safe to assume that systems with SCM_RIGHTS also
280 m.msg_control = alloca(m.msg_controllen);
281 memset(m.msg_control, 0, m.msg_controllen);
285 bytes_read = recvmsg(fd, &m, 0
286 #ifdef MSG_CMSG_CLOEXEC
297 /* put length back (note that this doesn't actually realloc anything) */
298 _dbus_string_set_length (buffer, start);
305 dbus_bool_t found = FALSE;
307 if (m.msg_flags & MSG_CTRUNC)
309 /* Hmm, apparently the control data was truncated. The bad
310 thing is that we might have completely lost a couple of fds
311 without chance to recover them. Hence let's treat this as a
315 _dbus_string_set_length (buffer, start);
319 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
320 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
324 _dbus_assert(cm->cmsg_len <= CMSG_LEN(*n_fds * sizeof(int)));
325 *n_fds = (cm->cmsg_len - CMSG_LEN(0)) / sizeof(int);
327 memcpy(fds, CMSG_DATA(cm), *n_fds * sizeof(int));
330 /* Linux doesn't tell us whether MSG_CMSG_CLOEXEC actually
331 worked, hence we need to go through this list and set
332 CLOEXEC everywhere in any case */
333 for (i = 0; i < *n_fds; i++)
334 _dbus_fd_set_close_on_exec(fds[i]);
342 /* put length back (doesn't actually realloc) */
343 _dbus_string_set_length (buffer, start + bytes_read);
347 _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
356 _dbus_write_socket_with_unix_fds(int fd,
357 const DBusString *buffer,
363 #ifndef HAVE_UNIX_FD_PASSING
370 return _dbus_write_socket(fd, buffer, start, len);
372 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len, NULL, 0, 0, fds, n_fds);
377 _dbus_write_socket_with_unix_fds_two(int fd,
378 const DBusString *buffer1,
381 const DBusString *buffer2,
387 #ifndef HAVE_UNIX_FD_PASSING
394 return _dbus_write_socket_two(fd,
395 buffer1, start1, len1,
396 buffer2, start2, len2);
404 _dbus_assert (len1 >= 0);
405 _dbus_assert (len2 >= 0);
406 _dbus_assert (n_fds >= 0);
409 iov[0].iov_base = (char*) _dbus_string_get_const_data_len (buffer1, start1, len1);
410 iov[0].iov_len = len1;
414 iov[1].iov_base = (char*) _dbus_string_get_const_data_len (buffer2, start2, len2);
415 iov[1].iov_len = len2;
420 m.msg_iovlen = buffer2 ? 2 : 1;
424 m.msg_controllen = CMSG_SPACE(n_fds * sizeof(int));
425 m.msg_control = alloca(m.msg_controllen);
426 memset(m.msg_control, 0, m.msg_controllen);
428 cm = CMSG_FIRSTHDR(&m);
429 cm->cmsg_level = SOL_SOCKET;
430 cm->cmsg_type = SCM_RIGHTS;
431 cm->cmsg_len = CMSG_LEN(n_fds * sizeof(int));
432 memcpy(CMSG_DATA(cm), fds, n_fds * sizeof(int));
437 bytes_written = sendmsg (fd, &m, 0
438 #if HAVE_DECL_MSG_NOSIGNAL
443 if (bytes_written < 0 && errno == EINTR)
447 if (bytes_written > 0)
448 _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
451 return bytes_written;
456 * Like _dbus_write_two() but only works on sockets and is thus
457 * available on Windows.
459 * @param fd the file descriptor
460 * @param buffer1 first buffer
461 * @param start1 first byte to write in first buffer
462 * @param len1 number of bytes to write from first buffer
463 * @param buffer2 second buffer, or #NULL
464 * @param start2 first byte to write in second buffer
465 * @param len2 number of bytes to write in second buffer
466 * @returns total bytes written from both buffers, or -1 on error
469 _dbus_write_socket_two (int fd,
470 const DBusString *buffer1,
473 const DBusString *buffer2,
477 #if HAVE_DECL_MSG_NOSIGNAL
478 struct iovec vectors[2];
484 _dbus_assert (buffer1 != NULL);
485 _dbus_assert (start1 >= 0);
486 _dbus_assert (start2 >= 0);
487 _dbus_assert (len1 >= 0);
488 _dbus_assert (len2 >= 0);
490 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
493 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
501 vectors[0].iov_base = (char*) data1;
502 vectors[0].iov_len = len1;
503 vectors[1].iov_base = (char*) data2;
504 vectors[1].iov_len = len2;
508 m.msg_iovlen = data2 ? 2 : 1;
512 bytes_written = sendmsg (fd, &m, MSG_NOSIGNAL);
514 if (bytes_written < 0 && errno == EINTR)
517 return bytes_written;
520 return _dbus_write_two (fd, buffer1, start1, len1,
521 buffer2, start2, len2);
526 _dbus_socket_is_invalid (int fd)
528 return fd < 0 ? TRUE : FALSE;
532 * Thin wrapper around the read() system call that appends
533 * the data it reads to the DBusString buffer. It appends
534 * up to the given count, and returns the same value
535 * and same errno as read(). The only exception is that
536 * _dbus_read() handles EINTR for you. Also, _dbus_read() can
537 * return ENOMEM, even though regular UNIX read doesn't.
539 * Unlike _dbus_read_socket(), _dbus_read() is not available
542 * @param fd the file descriptor to read from
543 * @param buffer the buffer to append data to
544 * @param count the amount of data to read
545 * @returns the number of bytes read or -1
556 _dbus_assert (count >= 0);
558 start = _dbus_string_get_length (buffer);
560 if (!_dbus_string_lengthen (buffer, count))
566 data = _dbus_string_get_data_len (buffer, start, count);
570 bytes_read = read (fd, data, count);
578 /* put length back (note that this doesn't actually realloc anything) */
579 _dbus_string_set_length (buffer, start);
585 /* put length back (doesn't actually realloc) */
586 _dbus_string_set_length (buffer, start + bytes_read);
590 _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
598 * Thin wrapper around the write() system call that writes a part of a
599 * DBusString and handles EINTR for you.
601 * @param fd the file descriptor to write
602 * @param buffer the buffer to write data from
603 * @param start the first byte in the buffer to write
604 * @param len the number of bytes to try to write
605 * @returns the number of bytes written or -1 on error
609 const DBusString *buffer,
616 data = _dbus_string_get_const_data_len (buffer, start, len);
620 bytes_written = write (fd, data, len);
622 if (bytes_written < 0 && errno == EINTR)
626 if (bytes_written > 0)
627 _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
630 return bytes_written;
634 * Like _dbus_write() but will use writev() if possible
635 * to write both buffers in sequence. The return value
636 * is the number of bytes written in the first buffer,
637 * plus the number written in the second. If the first
638 * buffer is written successfully and an error occurs
639 * writing the second, the number of bytes in the first
640 * is returned (i.e. the error is ignored), on systems that
641 * don't have writev. Handles EINTR for you.
642 * The second buffer may be #NULL.
644 * @param fd the file descriptor
645 * @param buffer1 first buffer
646 * @param start1 first byte to write in first buffer
647 * @param len1 number of bytes to write from first buffer
648 * @param buffer2 second buffer, or #NULL
649 * @param start2 first byte to write in second buffer
650 * @param len2 number of bytes to write in second buffer
651 * @returns total bytes written from both buffers, or -1 on error
654 _dbus_write_two (int fd,
655 const DBusString *buffer1,
658 const DBusString *buffer2,
662 _dbus_assert (buffer1 != NULL);
663 _dbus_assert (start1 >= 0);
664 _dbus_assert (start2 >= 0);
665 _dbus_assert (len1 >= 0);
666 _dbus_assert (len2 >= 0);
670 struct iovec vectors[2];
675 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
678 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
686 vectors[0].iov_base = (char*) data1;
687 vectors[0].iov_len = len1;
688 vectors[1].iov_base = (char*) data2;
689 vectors[1].iov_len = len2;
693 bytes_written = writev (fd,
697 if (bytes_written < 0 && errno == EINTR)
700 return bytes_written;
702 #else /* HAVE_WRITEV */
706 ret1 = _dbus_write (fd, buffer1, start1, len1);
707 if (ret1 == len1 && buffer2 != NULL)
709 ret2 = _dbus_write (fd, buffer2, start2, len2);
711 ret2 = 0; /* we can't report an error as the first write was OK */
718 #endif /* !HAVE_WRITEV */
721 #define _DBUS_MAX_SUN_PATH_LENGTH 99
724 * @def _DBUS_MAX_SUN_PATH_LENGTH
726 * Maximum length of the path to a UNIX domain socket,
727 * sockaddr_un::sun_path member. POSIX requires that all systems
728 * support at least 100 bytes here, including the nul termination.
729 * We use 99 for the max value to allow for the nul.
731 * We could probably also do sizeof (addr.sun_path)
732 * but this way we are the same on all platforms
733 * which is probably a good idea.
737 * Creates a socket and connects it to the UNIX domain socket at the
738 * given path. The connection fd is returned, and is set up as
741 * Uses abstract sockets instead of filesystem-linked sockets if
742 * requested (it's possible only on Linux; see "man 7 unix" on Linux).
743 * On non-Linux abstract socket usage always fails.
745 * This will set FD_CLOEXEC for the socket returned.
747 * @param path the path to UNIX domain socket
748 * @param abstract #TRUE to use abstract namespace
749 * @param error return location for error code
750 * @returns connection file descriptor or -1 on error
753 _dbus_connect_unix_socket (const char *path,
754 dbus_bool_t abstract,
759 struct sockaddr_un addr;
761 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
763 _dbus_verbose ("connecting to unix socket %s abstract=%d\n",
767 if (!_dbus_open_unix_socket (&fd, error))
769 _DBUS_ASSERT_ERROR_IS_SET(error);
772 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
775 addr.sun_family = AF_UNIX;
776 path_len = strlen (path);
780 #ifdef HAVE_ABSTRACT_SOCKETS
781 addr.sun_path[0] = '\0'; /* this is what says "use abstract" */
782 path_len++; /* Account for the extra nul byte added to the start of sun_path */
784 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
786 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
787 "Abstract socket name too long\n");
788 _dbus_close (fd, NULL);
792 strncpy (&addr.sun_path[1], path, path_len);
793 /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */
794 #else /* HAVE_ABSTRACT_SOCKETS */
795 dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
796 "Operating system does not support abstract socket namespace\n");
797 _dbus_close (fd, NULL);
799 #endif /* ! HAVE_ABSTRACT_SOCKETS */
803 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
805 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
806 "Socket name too long\n");
807 _dbus_close (fd, NULL);
811 strncpy (addr.sun_path, path, path_len);
814 if (connect (fd, (struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (struct sockaddr_un, sun_path) + path_len) < 0)
816 dbus_set_error (error,
817 _dbus_error_from_errno (errno),
818 "Failed to connect to socket %s: %s",
819 path, _dbus_strerror (errno));
821 _dbus_close (fd, NULL);
825 if (!_dbus_set_fd_nonblocking (fd, error))
827 _DBUS_ASSERT_ERROR_IS_SET (error);
829 _dbus_close (fd, NULL);
837 * Enables or disables the reception of credentials on the given socket during
838 * the next message transmission. This is only effective if the #LOCAL_CREDS
839 * system feature exists, in which case the other side of the connection does
840 * not have to do anything special to send the credentials.
842 * @param fd socket on which to change the #LOCAL_CREDS flag.
843 * @param on whether to enable or disable the #LOCAL_CREDS flag.
846 _dbus_set_local_creds (int fd, dbus_bool_t on)
848 dbus_bool_t retval = TRUE;
850 #if defined(HAVE_CMSGCRED)
851 /* NOOP just to make sure only one codepath is used
852 * and to prefer CMSGCRED
854 #elif defined(LOCAL_CREDS)
855 int val = on ? 1 : 0;
856 if (setsockopt (fd, 0, LOCAL_CREDS, &val, sizeof (val)) < 0)
858 _dbus_verbose ("Unable to set LOCAL_CREDS socket option on fd %d\n", fd);
862 _dbus_verbose ("LOCAL_CREDS %s for further messages on fd %d\n",
863 on ? "enabled" : "disabled", fd);
870 * Creates a socket and binds it to the given path,
871 * then listens on the socket. The socket is
872 * set to be nonblocking.
874 * Uses abstract sockets instead of filesystem-linked
875 * sockets if requested (it's possible only on Linux;
876 * see "man 7 unix" on Linux).
877 * On non-Linux abstract socket usage always fails.
879 * This will set FD_CLOEXEC for the socket returned
881 * @param path the socket name
882 * @param abstract #TRUE to use abstract namespace
883 * @param error return location for errors
884 * @returns the listening file descriptor or -1 on error
887 _dbus_listen_unix_socket (const char *path,
888 dbus_bool_t abstract,
892 struct sockaddr_un addr;
894 unsigned int reuseaddr;
896 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
898 _dbus_verbose ("listening on unix socket %s abstract=%d\n",
901 if (!_dbus_open_unix_socket (&listen_fd, error))
903 _DBUS_ASSERT_ERROR_IS_SET(error);
906 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
909 addr.sun_family = AF_UNIX;
910 path_len = strlen (path);
914 #ifdef HAVE_ABSTRACT_SOCKETS
915 /* remember that abstract names aren't nul-terminated so we rely
916 * on sun_path being filled in with zeroes above.
918 addr.sun_path[0] = '\0'; /* this is what says "use abstract" */
919 path_len++; /* Account for the extra nul byte added to the start of sun_path */
921 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
923 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
924 "Abstract socket name too long\n");
925 _dbus_close (listen_fd, NULL);
929 strncpy (&addr.sun_path[1], path, path_len);
930 /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */
931 #else /* HAVE_ABSTRACT_SOCKETS */
932 dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
933 "Operating system does not support abstract socket namespace\n");
934 _dbus_close (listen_fd, NULL);
936 #endif /* ! HAVE_ABSTRACT_SOCKETS */
940 /* Discussed security implications of this with Nalin,
941 * and we couldn't think of where it would kick our ass, but
942 * it still seems a bit sucky. It also has non-security suckage;
943 * really we'd prefer to exit if the socket is already in use.
944 * But there doesn't seem to be a good way to do this.
946 * Just to be extra careful, I threw in the stat() - clearly
947 * the stat() can't *fix* any security issue, but it at least
948 * avoids inadvertent/accidental data loss.
953 if (stat (path, &sb) == 0 &&
954 S_ISSOCK (sb.st_mode))
958 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
960 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
961 "Abstract socket name too long\n");
962 _dbus_close (listen_fd, NULL);
966 strncpy (addr.sun_path, path, path_len);
970 if (setsockopt (listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr))==-1)
972 _dbus_warn ("Failed to set socket option\"%s\": %s",
973 path, _dbus_strerror (errno));
976 if (bind (listen_fd, (struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (struct sockaddr_un, sun_path) + path_len) < 0)
978 dbus_set_error (error, _dbus_error_from_errno (errno),
979 "Failed to bind socket \"%s\": %s",
980 path, _dbus_strerror (errno));
981 _dbus_close (listen_fd, NULL);
985 if (listen (listen_fd, 30 /* backlog */) < 0)
987 dbus_set_error (error, _dbus_error_from_errno (errno),
988 "Failed to listen on socket \"%s\": %s",
989 path, _dbus_strerror (errno));
990 _dbus_close (listen_fd, NULL);
994 if (!_dbus_set_local_creds (listen_fd, TRUE))
996 dbus_set_error (error, _dbus_error_from_errno (errno),
997 "Failed to enable LOCAL_CREDS on socket \"%s\": %s",
998 path, _dbus_strerror (errno));
1003 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1005 _DBUS_ASSERT_ERROR_IS_SET (error);
1006 _dbus_close (listen_fd, NULL);
1010 /* Try opening up the permissions, but if we can't, just go ahead
1011 * and continue, maybe it will be good enough.
1013 if (!abstract && chmod (path, 0777) < 0)
1014 _dbus_warn ("Could not set mode 0777 on socket %s\n",
1021 * Acquires one or more sockets passed in from systemd. The sockets
1022 * are set to be nonblocking.
1024 * This will set FD_CLOEXEC for the sockets returned.
1026 * @oaram fds the file descriptors
1027 * @param error return location for errors
1028 * @returns the number of file descriptors
1031 _dbus_listen_systemd_sockets (int **fds,
1038 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1040 n = sd_listen_fds (TRUE);
1043 dbus_set_error (error, _dbus_error_from_errno (-n),
1044 "Failed to acquire systemd socket: %s",
1045 _dbus_strerror (-n));
1051 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
1052 "No socket received.");
1056 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1058 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1061 dbus_set_error (error, _dbus_error_from_errno (-r),
1062 "Failed to verify systemd socket type: %s",
1063 _dbus_strerror (-r));
1069 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
1070 "Passed socket has wrong type.");
1075 /* OK, the file descriptors are all good, so let's take posession of
1078 new_fds = dbus_new (int, n);
1081 dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
1082 "Failed to allocate file handle array.");
1086 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1088 if (!_dbus_set_local_creds (fd, TRUE))
1090 dbus_set_error (error, _dbus_error_from_errno (errno),
1091 "Failed to enable LOCAL_CREDS on systemd socket: %s",
1092 _dbus_strerror (errno));
1096 if (!_dbus_set_fd_nonblocking (fd, error))
1098 _DBUS_ASSERT_ERROR_IS_SET (error);
1102 new_fds[fd - SD_LISTEN_FDS_START] = fd;
1110 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1112 _dbus_close (fd, NULL);
1115 dbus_free (new_fds);
1120 * Creates a socket and connects to a socket at the given host
1121 * and port. The connection fd is returned, and is set up as
1124 * This will set FD_CLOEXEC for the socket returned
1126 * @param host the host name to connect to
1127 * @param port the port to connect to
1128 * @param family the address family to listen on, NULL for all
1129 * @param error return location for error code
1130 * @returns connection file descriptor or -1 on error
1133 _dbus_connect_tcp_socket (const char *host,
1138 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (const char*)NULL, error);
1142 _dbus_connect_tcp_socket_with_nonce (const char *host,
1145 const char *noncefile,
1148 int saved_errno = 0;
1150 struct addrinfo hints;
1151 struct addrinfo *ai, *tmp;
1153 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1158 hints.ai_family = AF_UNSPEC;
1159 else if (!strcmp(family, "ipv4"))
1160 hints.ai_family = AF_INET;
1161 else if (!strcmp(family, "ipv6"))
1162 hints.ai_family = AF_INET6;
1165 dbus_set_error (error,
1166 DBUS_ERROR_BAD_ADDRESS,
1167 "Unknown address family %s", family);
1170 hints.ai_protocol = IPPROTO_TCP;
1171 hints.ai_socktype = SOCK_STREAM;
1172 hints.ai_flags = AI_ADDRCONFIG;
1174 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1176 dbus_set_error (error,
1177 _dbus_error_from_errno (errno),
1178 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1179 host, port, gai_strerror(res), res);
1180 _dbus_close (fd, NULL);
1187 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1190 _DBUS_ASSERT_ERROR_IS_SET(error);
1193 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1195 if (connect (fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1197 saved_errno = errno;
1198 _dbus_close(fd, NULL);
1210 dbus_set_error (error,
1211 _dbus_error_from_errno (saved_errno),
1212 "Failed to connect to socket \"%s:%s\" %s",
1213 host, port, _dbus_strerror(saved_errno));
1217 if (noncefile != NULL)
1219 DBusString noncefileStr;
1221 _dbus_string_init_const (&noncefileStr, noncefile);
1222 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1223 _dbus_string_free (&noncefileStr);
1227 _dbus_close (fd, NULL);
1232 if (!_dbus_set_fd_nonblocking (fd, error))
1234 _dbus_close (fd, NULL);
1242 * Creates a socket and binds it to the given path, then listens on
1243 * the socket. The socket is set to be nonblocking. In case of port=0
1244 * a random free port is used and returned in the port parameter.
1245 * If inaddr_any is specified, the hostname is ignored.
1247 * This will set FD_CLOEXEC for the socket returned
1249 * @param host the host name to listen on
1250 * @param port the port to listen on, if zero a free port will be used
1251 * @param family the address family to listen on, NULL for all
1252 * @param retport string to return the actual port listened on
1253 * @param fds_p location to store returned file descriptors
1254 * @param error return location for errors
1255 * @returns the number of listening file descriptors or -1 on error
1258 _dbus_listen_tcp_socket (const char *host,
1261 DBusString *retport,
1266 int nlisten_fd = 0, *listen_fd = NULL, res, i;
1267 struct addrinfo hints;
1268 struct addrinfo *ai, *tmp;
1269 unsigned int reuseaddr;
1272 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1277 hints.ai_family = AF_UNSPEC;
1278 else if (!strcmp(family, "ipv4"))
1279 hints.ai_family = AF_INET;
1280 else if (!strcmp(family, "ipv6"))
1281 hints.ai_family = AF_INET6;
1284 dbus_set_error (error,
1285 DBUS_ERROR_BAD_ADDRESS,
1286 "Unknown address family %s", family);
1290 hints.ai_protocol = IPPROTO_TCP;
1291 hints.ai_socktype = SOCK_STREAM;
1292 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1294 redo_lookup_with_port:
1295 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1297 dbus_set_error (error,
1298 _dbus_error_from_errno (errno),
1299 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1300 host ? host : "*", port, gai_strerror(res), res);
1307 int fd = -1, *newlisten_fd;
1308 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1310 _DBUS_ASSERT_ERROR_IS_SET(error);
1313 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1316 if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr))==-1)
1318 _dbus_warn ("Failed to set socket option \"%s:%s\": %s",
1319 host ? host : "*", port, _dbus_strerror (errno));
1322 if (bind (fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1324 saved_errno = errno;
1325 _dbus_close(fd, NULL);
1326 if (saved_errno == EADDRINUSE)
1328 /* Depending on kernel policy, it may or may not
1329 be neccessary to bind to both IPv4 & 6 addresses
1330 so ignore EADDRINUSE here */
1334 dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1335 "Failed to bind socket \"%s:%s\": %s",
1336 host ? host : "*", port, _dbus_strerror (saved_errno));
1340 if (listen (fd, 30 /* backlog */) < 0)
1342 saved_errno = errno;
1343 _dbus_close (fd, NULL);
1344 dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1345 "Failed to listen on socket \"%s:%s\": %s",
1346 host ? host : "*", port, _dbus_strerror (saved_errno));
1350 newlisten_fd = dbus_realloc(listen_fd, sizeof(int)*(nlisten_fd+1));
1353 saved_errno = errno;
1354 _dbus_close (fd, NULL);
1355 dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1356 "Failed to allocate file handle array: %s",
1357 _dbus_strerror (saved_errno));
1360 listen_fd = newlisten_fd;
1361 listen_fd[nlisten_fd] = fd;
1364 if (!_dbus_string_get_length(retport))
1366 /* If the user didn't specify a port, or used 0, then
1367 the kernel chooses a port. After the first address
1368 is bound to, we need to force all remaining addresses
1369 to use the same port */
1370 if (!port || !strcmp(port, "0"))
1373 struct sockaddr_storage addr;
1377 addrlen = sizeof(addr);
1378 result = getsockname(fd, (struct sockaddr*) &addr, &addrlen);
1381 (res = getnameinfo ((struct sockaddr*)&addr, addrlen, NULL, 0,
1382 portbuf, sizeof(portbuf),
1383 NI_NUMERICHOST)) != 0)
1385 dbus_set_error (error, _dbus_error_from_errno (errno),
1386 "Failed to resolve port \"%s:%s\": %s (%s)",
1387 host ? host : "*", port, gai_strerror(res), res);
1390 if (!_dbus_string_append(retport, portbuf))
1392 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1396 /* Release current address list & redo lookup */
1397 port = _dbus_string_get_const_data(retport);
1399 goto redo_lookup_with_port;
1403 if (!_dbus_string_append(retport, port))
1405 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1419 dbus_set_error (error, _dbus_error_from_errno (errno),
1420 "Failed to bind socket \"%s:%s\": %s",
1421 host ? host : "*", port, _dbus_strerror (errno));
1425 for (i = 0 ; i < nlisten_fd ; i++)
1427 if (!_dbus_set_fd_nonblocking (listen_fd[i], error))
1440 for (i = 0 ; i < nlisten_fd ; i++)
1441 _dbus_close(listen_fd[i], NULL);
1442 dbus_free(listen_fd);
1447 write_credentials_byte (int server_fd,
1451 char buf[1] = { '\0' };
1452 #if defined(HAVE_CMSGCRED)
1455 char cred[CMSG_SPACE (sizeof (struct cmsgcred))];
1466 msg.msg_control = (caddr_t) &cmsg;
1467 msg.msg_controllen = CMSG_SPACE (sizeof (struct cmsgcred));
1469 cmsg.hdr.cmsg_len = CMSG_LEN (sizeof (struct cmsgcred));
1470 cmsg.hdr.cmsg_level = SOL_SOCKET;
1471 cmsg.hdr.cmsg_type = SCM_CREDS;
1474 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1478 #if defined(HAVE_CMSGCRED)
1479 bytes_written = sendmsg (server_fd, &msg, 0
1480 #if HAVE_DECL_MSG_NOSIGNAL
1485 bytes_written = send (server_fd, buf, 1, 0
1486 #if HAVE_DECL_MSG_NOSIGNAL
1492 if (bytes_written < 0 && errno == EINTR)
1495 if (bytes_written < 0)
1497 dbus_set_error (error, _dbus_error_from_errno (errno),
1498 "Failed to write credentials byte: %s",
1499 _dbus_strerror (errno));
1502 else if (bytes_written == 0)
1504 dbus_set_error (error, DBUS_ERROR_IO_ERROR,
1505 "wrote zero bytes writing credentials byte");
1510 _dbus_assert (bytes_written == 1);
1511 _dbus_verbose ("wrote credentials byte\n");
1517 * Reads a single byte which must be nul (an error occurs otherwise),
1518 * and reads unix credentials if available. Clears the credentials
1519 * object, then adds pid/uid if available, so any previous credentials
1520 * stored in the object are lost.
1522 * Return value indicates whether a byte was read, not whether
1523 * we got valid credentials. On some systems, such as Linux,
1524 * reading/writing the byte isn't actually required, but we do it
1525 * anyway just to avoid multiple codepaths.
1527 * Fails if no byte is available, so you must select() first.
1529 * The point of the byte is that on some systems we have to
1530 * use sendmsg()/recvmsg() to transmit credentials.
1532 * @param client_fd the client file descriptor
1533 * @param credentials object to add client credentials to
1534 * @param error location to store error code
1535 * @returns #TRUE on success
1538 _dbus_read_credentials_socket (int client_fd,
1539 DBusCredentials *credentials,
1545 dbus_uid_t uid_read;
1546 dbus_pid_t pid_read;
1549 #ifdef HAVE_CMSGCRED
1552 char cred[CMSG_SPACE (sizeof (struct cmsgcred))];
1555 #elif defined(LOCAL_CREDS)
1558 struct sockcred cred;
1562 uid_read = DBUS_UID_UNSET;
1563 pid_read = DBUS_PID_UNSET;
1565 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1567 /* The POSIX spec certainly doesn't promise this, but
1568 * we need these assertions to fail as soon as we're wrong about
1569 * it so we can do the porting fixups
1571 _dbus_assert (sizeof (pid_t) <= sizeof (dbus_pid_t));
1572 _dbus_assert (sizeof (uid_t) <= sizeof (dbus_uid_t));
1573 _dbus_assert (sizeof (gid_t) <= sizeof (dbus_gid_t));
1575 _dbus_credentials_clear (credentials);
1577 /* Systems supporting LOCAL_CREDS are configured to have this feature
1578 * enabled (if it does not conflict with HAVE_CMSGCRED) prior accepting
1579 * the connection. Therefore, the received message must carry the
1580 * credentials information without doing anything special.
1583 iov.iov_base = &buf;
1590 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
1592 msg.msg_control = (caddr_t) &cmsg;
1593 msg.msg_controllen = CMSG_SPACE (sizeof (struct cmsgcred));
1597 bytes_read = recvmsg (client_fd, &msg, 0);
1604 /* EAGAIN or EWOULDBLOCK would be unexpected here since we would
1605 * normally only call read_credentials if the socket was ready
1609 dbus_set_error (error, _dbus_error_from_errno (errno),
1610 "Failed to read credentials byte: %s",
1611 _dbus_strerror (errno));
1614 else if (bytes_read == 0)
1616 /* this should not happen unless we are using recvmsg wrong,
1617 * so is essentially here for paranoia
1619 dbus_set_error (error, DBUS_ERROR_FAILED,
1620 "Failed to read credentials byte (zero-length read)");
1623 else if (buf != '\0')
1625 dbus_set_error (error, DBUS_ERROR_FAILED,
1626 "Credentials byte was not nul");
1630 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
1631 if (cmsg.hdr.cmsg_len < CMSG_LEN (sizeof (struct cmsgcred))
1632 || cmsg.hdr.cmsg_type != SCM_CREDS)
1634 dbus_set_error (error, DBUS_ERROR_FAILED,
1635 "Message from recvmsg() was not SCM_CREDS");
1640 _dbus_verbose ("read credentials byte\n");
1645 struct sockpeercred cr;
1649 int cr_len = sizeof (cr);
1651 if (getsockopt (client_fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) == 0 &&
1652 cr_len == sizeof (cr))
1659 _dbus_verbose ("Failed to getsockopt() credentials, returned len %d/%d: %s\n",
1660 cr_len, (int) sizeof (cr), _dbus_strerror (errno));
1662 #elif defined(HAVE_CMSGCRED)
1663 struct cmsgcred *cred;
1665 cred = (struct cmsgcred *) CMSG_DATA (&cmsg.hdr);
1666 pid_read = cred->cmcred_pid;
1667 uid_read = cred->cmcred_euid;
1668 #elif defined(LOCAL_CREDS)
1669 pid_read = DBUS_PID_UNSET;
1670 uid_read = cmsg.cred.sc_uid;
1671 /* Since we have already got the credentials from this socket, we can
1672 * disable its LOCAL_CREDS flag if it was ever set. */
1673 _dbus_set_local_creds (client_fd, FALSE);
1674 #elif defined(HAVE_GETPEEREID)
1677 if (getpeereid (client_fd, &euid, &egid) == 0)
1683 _dbus_verbose ("Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
1685 #elif defined(HAVE_GETPEERUCRED)
1686 ucred_t * ucred = NULL;
1687 if (getpeerucred (client_fd, &ucred) == 0)
1689 pid_read = ucred_getpid (ucred);
1690 uid_read = ucred_geteuid (ucred);
1692 /* generate audit session data based on socket ucred */
1693 adt_session_data_t *adth = NULL;
1694 adt_export_data_t *data = NULL;
1696 if (adt_start_session (&adth, NULL, 0) || (adth == NULL))
1698 _dbus_verbose ("Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
1702 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
1704 _dbus_verbose ("Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
1708 size = adt_export_session_data (adth, &data);
1711 _dbus_verbose ("Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
1715 _dbus_credentials_add_adt_audit_data (credentials, data, size);
1719 (void) adt_end_session (adth);
1721 #endif /* HAVE_ADT */
1725 _dbus_verbose ("Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
1729 #else /* !SO_PEERCRED && !HAVE_CMSGCRED && !HAVE_GETPEEREID && !HAVE_GETPEERUCRED */
1730 _dbus_verbose ("Socket credentials not supported on this OS\n");
1734 _dbus_verbose ("Credentials:"
1735 " pid "DBUS_PID_FORMAT
1736 " uid "DBUS_UID_FORMAT
1741 if (pid_read != DBUS_PID_UNSET)
1743 if (!_dbus_credentials_add_unix_pid (credentials, pid_read))
1745 _DBUS_SET_OOM (error);
1750 if (uid_read != DBUS_UID_UNSET)
1752 if (!_dbus_credentials_add_unix_uid (credentials, uid_read))
1754 _DBUS_SET_OOM (error);
1763 * Sends a single nul byte with our UNIX credentials as ancillary
1764 * data. Returns #TRUE if the data was successfully written. On
1765 * systems that don't support sending credentials, just writes a byte,
1766 * doesn't send any credentials. On some systems, such as Linux,
1767 * reading/writing the byte isn't actually required, but we do it
1768 * anyway just to avoid multiple codepaths.
1770 * Fails if no byte can be written, so you must select() first.
1772 * The point of the byte is that on some systems we have to
1773 * use sendmsg()/recvmsg() to transmit credentials.
1775 * @param server_fd file descriptor for connection to server
1776 * @param error return location for error code
1777 * @returns #TRUE if the byte was sent
1780 _dbus_send_credentials_socket (int server_fd,
1783 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1785 if (write_credentials_byte (server_fd, error))
1792 * Accepts a connection on a listening socket.
1793 * Handles EINTR for you.
1795 * This will enable FD_CLOEXEC for the returned socket.
1797 * @param listen_fd the listen file descriptor
1798 * @returns the connection fd of the client, or -1 on error
1801 _dbus_accept (int listen_fd)
1804 struct sockaddr addr;
1807 dbus_bool_t cloexec_done;
1810 addrlen = sizeof (addr);
1815 /* We assume that if accept4 is available SOCK_CLOEXEC is too */
1816 client_fd = accept4 (listen_fd, &addr, &addrlen, SOCK_CLOEXEC);
1817 cloexec_done = client_fd >= 0;
1819 if (client_fd < 0 && errno == ENOSYS)
1822 client_fd = accept (listen_fd, &addr, &addrlen);
1831 _dbus_verbose ("client fd %d accepted\n", client_fd);
1837 _dbus_fd_set_close_on_exec(client_fd);
1844 * Checks to make sure the given directory is
1845 * private to the user
1847 * @param dir the name of the directory
1848 * @param error error return
1849 * @returns #FALSE on failure
1852 _dbus_check_dir_is_private_to_user (DBusString *dir, DBusError *error)
1854 const char *directory;
1857 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1859 directory = _dbus_string_get_const_data (dir);
1861 if (stat (directory, &sb) < 0)
1863 dbus_set_error (error, _dbus_error_from_errno (errno),
1864 "%s", _dbus_strerror (errno));
1869 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
1870 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
1872 dbus_set_error (error, DBUS_ERROR_FAILED,
1873 "%s directory is not private to the user", directory);
1881 fill_user_info_from_passwd (struct passwd *p,
1885 _dbus_assert (p->pw_name != NULL);
1886 _dbus_assert (p->pw_dir != NULL);
1888 info->uid = p->pw_uid;
1889 info->primary_gid = p->pw_gid;
1890 info->username = _dbus_strdup (p->pw_name);
1891 info->homedir = _dbus_strdup (p->pw_dir);
1893 if (info->username == NULL ||
1894 info->homedir == NULL)
1896 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1904 fill_user_info (DBusUserInfo *info,
1906 const DBusString *username,
1909 const char *username_c;
1911 /* exactly one of username/uid provided */
1912 _dbus_assert (username != NULL || uid != DBUS_UID_UNSET);
1913 _dbus_assert (username == NULL || uid == DBUS_UID_UNSET);
1915 info->uid = DBUS_UID_UNSET;
1916 info->primary_gid = DBUS_GID_UNSET;
1917 info->group_ids = NULL;
1918 info->n_group_ids = 0;
1919 info->username = NULL;
1920 info->homedir = NULL;
1922 if (username != NULL)
1923 username_c = _dbus_string_get_const_data (username);
1927 /* For now assuming that the getpwnam() and getpwuid() flavors
1928 * are always symmetrical, if not we have to add more configure
1932 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
1938 struct passwd p_str;
1940 /* retrieve maximum needed size for buf */
1941 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
1943 /* sysconf actually returns a long, but everything else expects size_t,
1944 * so just recast here.
1945 * https://bugs.freedesktop.org/show_bug.cgi?id=17061
1947 if ((long) buflen <= 0)
1953 buf = dbus_malloc (buflen);
1956 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1961 #ifdef HAVE_POSIX_GETPWNAM_R
1962 if (uid != DBUS_UID_UNSET)
1963 result = getpwuid_r (uid, &p_str, buf, buflen,
1966 result = getpwnam_r (username_c, &p_str, buf, buflen,
1969 if (uid != DBUS_UID_UNSET)
1970 p = getpwuid_r (uid, &p_str, buf, buflen);
1972 p = getpwnam_r (username_c, &p_str, buf, buflen);
1974 #endif /* !HAVE_POSIX_GETPWNAM_R */
1975 //Try a bigger buffer if ERANGE was returned
1976 if (result == ERANGE && buflen < 512 * 1024)
1986 if (result == 0 && p == &p_str)
1988 if (!fill_user_info_from_passwd (p, info, error))
1997 dbus_set_error (error, _dbus_error_from_errno (errno),
1998 "User \"%s\" unknown or no memory to allocate password entry\n",
1999 username_c ? username_c : "???");
2000 _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
2005 #else /* ! HAVE_GETPWNAM_R */
2007 /* I guess we're screwed on thread safety here */
2010 if (uid != DBUS_UID_UNSET)
2013 p = getpwnam (username_c);
2017 if (!fill_user_info_from_passwd (p, info, error))
2024 dbus_set_error (error, _dbus_error_from_errno (errno),
2025 "User \"%s\" unknown or no memory to allocate password entry\n",
2026 username_c ? username_c : "???");
2027 _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
2031 #endif /* ! HAVE_GETPWNAM_R */
2033 /* Fill this in so we can use it to get groups */
2034 username_c = info->username;
2036 #ifdef HAVE_GETGROUPLIST
2041 int initial_buf_count;
2043 initial_buf_count = 17;
2044 buf_count = initial_buf_count;
2045 buf = dbus_new (gid_t, buf_count);
2048 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2052 if (getgrouplist (username_c,
2054 buf, &buf_count) < 0)
2057 /* Presumed cause of negative return code: buf has insufficient
2058 entries to hold the entire group list. The Linux behavior in this
2059 case is to pass back the actual number of groups in buf_count, but
2060 on Mac OS X 10.5, buf_count is unhelpfully left alone.
2061 So as a hack, try to help out a bit by guessing a larger
2062 number of groups, within reason.. might still fail, of course,
2063 but we can at least print a more informative message. I looked up
2064 the "right way" to do this by downloading Apple's own source code
2065 for the "id" command, and it turns out that they use an
2066 undocumented library function getgrouplist_2 (!) which is not
2067 declared in any header in /usr/include (!!). That did not seem
2068 like the way to go here.
2070 if (buf_count == initial_buf_count)
2072 buf_count *= 16; /* Retry with an arbitrarily scaled-up array */
2074 new = dbus_realloc (buf, buf_count * sizeof (buf[0]));
2077 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2085 if (getgrouplist (username_c, info->primary_gid, buf, &buf_count) < 0)
2089 _dbus_warn ("It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2090 username_c, buf_count, buf_count);
2094 dbus_set_error (error,
2095 _dbus_error_from_errno (errno),
2096 "Failed to get groups for username \"%s\" primary GID "
2097 DBUS_GID_FORMAT ": %s\n",
2098 username_c, info->primary_gid,
2099 _dbus_strerror (errno));
2106 info->group_ids = dbus_new (dbus_gid_t, buf_count);
2107 if (info->group_ids == NULL)
2109 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2114 for (i = 0; i < buf_count; ++i)
2115 info->group_ids[i] = buf[i];
2117 info->n_group_ids = buf_count;
2121 #else /* HAVE_GETGROUPLIST */
2123 /* We just get the one group ID */
2124 info->group_ids = dbus_new (dbus_gid_t, 1);
2125 if (info->group_ids == NULL)
2127 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2131 info->n_group_ids = 1;
2133 (info->group_ids)[0] = info->primary_gid;
2135 #endif /* HAVE_GETGROUPLIST */
2137 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2142 _DBUS_ASSERT_ERROR_IS_SET (error);
2147 * Gets user info for the given username.
2149 * @param info user info object to initialize
2150 * @param username the username
2151 * @param error error return
2152 * @returns #TRUE on success
2155 _dbus_user_info_fill (DBusUserInfo *info,
2156 const DBusString *username,
2159 return fill_user_info (info, DBUS_UID_UNSET,
2164 * Gets user info for the given user ID.
2166 * @param info user info object to initialize
2167 * @param uid the user ID
2168 * @param error error return
2169 * @returns #TRUE on success
2172 _dbus_user_info_fill_uid (DBusUserInfo *info,
2176 return fill_user_info (info, uid,
2181 * Adds the credentials of the current process to the
2182 * passed-in credentials object.
2184 * @param credentials credentials to add to
2185 * @returns #FALSE if no memory; does not properly roll back on failure, so only some credentials may have been added
2188 _dbus_credentials_add_from_current_process (DBusCredentials *credentials)
2190 /* The POSIX spec certainly doesn't promise this, but
2191 * we need these assertions to fail as soon as we're wrong about
2192 * it so we can do the porting fixups
2194 _dbus_assert (sizeof (pid_t) <= sizeof (dbus_pid_t));
2195 _dbus_assert (sizeof (uid_t) <= sizeof (dbus_uid_t));
2196 _dbus_assert (sizeof (gid_t) <= sizeof (dbus_gid_t));
2198 if (!_dbus_credentials_add_unix_pid(credentials, _dbus_getpid()))
2200 if (!_dbus_credentials_add_unix_uid(credentials, _dbus_geteuid()))
2207 * Append to the string the identity we would like to have when we
2208 * authenticate, on UNIX this is the current process UID and on
2209 * Windows something else, probably a Windows SID string. No escaping
2210 * is required, that is done in dbus-auth.c. The username here
2211 * need not be anything human-readable, it can be the machine-readable
2212 * form i.e. a user id.
2214 * @param str the string to append to
2215 * @returns #FALSE on no memory
2218 _dbus_append_user_from_current_process (DBusString *str)
2220 return _dbus_string_append_uint (str,
2225 * Gets our process ID
2226 * @returns process ID
2235 * @returns process UID
2243 /** Gets our effective UID
2244 * @returns process effective UID
2247 _dbus_geteuid (void)
2253 * The only reason this is separate from _dbus_getpid() is to allow it
2254 * on Windows for logging but not for other purposes.
2256 * @returns process ID to put in log messages
2259 _dbus_pid_for_log (void)
2265 * Gets a UID from a UID string.
2267 * @param uid_str the UID in string form
2268 * @param uid UID to fill in
2269 * @returns #TRUE if successfully filled in UID
2272 _dbus_parse_uid (const DBusString *uid_str,
2278 if (_dbus_string_get_length (uid_str) == 0)
2280 _dbus_verbose ("UID string was zero length\n");
2286 if (!_dbus_string_parse_int (uid_str, 0, &val,
2289 _dbus_verbose ("could not parse string as a UID\n");
2293 if (end != _dbus_string_get_length (uid_str))
2295 _dbus_verbose ("string contained trailing stuff after UID\n");
2305 _DBUS_DEFINE_GLOBAL_LOCK (atomic);
2309 * Atomically increments an integer
2311 * @param atomic pointer to the integer to increment
2312 * @returns the value before incrementing
2315 _dbus_atomic_inc (DBusAtomic *atomic)
2318 return __sync_add_and_fetch(&atomic->value, 1)-1;
2321 _DBUS_LOCK (atomic);
2322 res = atomic->value;
2324 _DBUS_UNLOCK (atomic);
2330 * Atomically decrement an integer
2332 * @param atomic pointer to the integer to decrement
2333 * @returns the value before decrementing
2336 _dbus_atomic_dec (DBusAtomic *atomic)
2339 return __sync_sub_and_fetch(&atomic->value, 1)+1;
2343 _DBUS_LOCK (atomic);
2344 res = atomic->value;
2346 _DBUS_UNLOCK (atomic);
2352 * Atomically get the value of an integer. It may change at any time
2353 * thereafter, so this is mostly only useful for assertions.
2355 * @param atomic pointer to the integer to get
2356 * @returns the value at this moment
2359 _dbus_atomic_get (DBusAtomic *atomic)
2362 __sync_synchronize ();
2363 return atomic->value;
2367 _DBUS_LOCK (atomic);
2368 res = atomic->value;
2369 _DBUS_UNLOCK (atomic);
2374 #ifdef DBUS_BUILD_TESTS
2376 * @returns process GID
2386 * Wrapper for poll().
2388 * @param fds the file descriptors to poll
2389 * @param n_fds number of descriptors in the array
2390 * @param timeout_milliseconds timeout or -1 for infinite
2391 * @returns numbers of fds with revents, or <0 on error
2394 _dbus_poll (DBusPollFD *fds,
2396 int timeout_milliseconds)
2398 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
2399 /* This big thing is a constant expression and should get optimized
2400 * out of existence. So it's more robust than a configure check at
2403 if (_DBUS_POLLIN == POLLIN &&
2404 _DBUS_POLLPRI == POLLPRI &&
2405 _DBUS_POLLOUT == POLLOUT &&
2406 _DBUS_POLLERR == POLLERR &&
2407 _DBUS_POLLHUP == POLLHUP &&
2408 _DBUS_POLLNVAL == POLLNVAL &&
2409 sizeof (DBusPollFD) == sizeof (struct pollfd) &&
2410 _DBUS_STRUCT_OFFSET (DBusPollFD, fd) ==
2411 _DBUS_STRUCT_OFFSET (struct pollfd, fd) &&
2412 _DBUS_STRUCT_OFFSET (DBusPollFD, events) ==
2413 _DBUS_STRUCT_OFFSET (struct pollfd, events) &&
2414 _DBUS_STRUCT_OFFSET (DBusPollFD, revents) ==
2415 _DBUS_STRUCT_OFFSET (struct pollfd, revents))
2417 return poll ((struct pollfd*) fds,
2419 timeout_milliseconds);
2423 /* We have to convert the DBusPollFD to an array of
2424 * struct pollfd, poll, and convert back.
2426 _dbus_warn ("didn't implement poll() properly for this system yet\n");
2429 #else /* ! HAVE_POLL */
2431 fd_set read_set, write_set, err_set;
2437 FD_ZERO (&read_set);
2438 FD_ZERO (&write_set);
2441 for (i = 0; i < n_fds; i++)
2443 DBusPollFD *fdp = &fds[i];
2445 if (fdp->events & _DBUS_POLLIN)
2446 FD_SET (fdp->fd, &read_set);
2448 if (fdp->events & _DBUS_POLLOUT)
2449 FD_SET (fdp->fd, &write_set);
2451 FD_SET (fdp->fd, &err_set);
2453 max_fd = MAX (max_fd, fdp->fd);
2456 tv.tv_sec = timeout_milliseconds / 1000;
2457 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
2459 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
2460 timeout_milliseconds < 0 ? NULL : &tv);
2464 for (i = 0; i < n_fds; i++)
2466 DBusPollFD *fdp = &fds[i];
2470 if (FD_ISSET (fdp->fd, &read_set))
2471 fdp->revents |= _DBUS_POLLIN;
2473 if (FD_ISSET (fdp->fd, &write_set))
2474 fdp->revents |= _DBUS_POLLOUT;
2476 if (FD_ISSET (fdp->fd, &err_set))
2477 fdp->revents |= _DBUS_POLLERR;
2486 * Get current time, as in gettimeofday(). Use the monotonic clock if
2487 * available, to avoid problems when the system time changes.
2489 * @param tv_sec return location for number of seconds
2490 * @param tv_usec return location for number of microseconds (thousandths)
2493 _dbus_get_current_time (long *tv_sec,
2496 #ifdef HAVE_MONOTONIC_CLOCK
2498 clock_gettime (CLOCK_MONOTONIC, &ts);
2501 *tv_sec = ts.tv_sec;
2503 *tv_usec = ts.tv_nsec / 1000;
2507 gettimeofday (&t, NULL);
2512 *tv_usec = t.tv_usec;
2517 * Creates a directory; succeeds if the directory
2518 * is created or already existed.
2520 * @param filename directory filename
2521 * @param error initialized error object
2522 * @returns #TRUE on success
2525 _dbus_create_directory (const DBusString *filename,
2528 const char *filename_c;
2530 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2532 filename_c = _dbus_string_get_const_data (filename);
2534 if (mkdir (filename_c, 0700) < 0)
2536 if (errno == EEXIST)
2539 dbus_set_error (error, DBUS_ERROR_FAILED,
2540 "Failed to create directory %s: %s\n",
2541 filename_c, _dbus_strerror (errno));
2549 * Appends the given filename to the given directory.
2551 * @todo it might be cute to collapse multiple '/' such as "foo//"
2554 * @param dir the directory name
2555 * @param next_component the filename
2556 * @returns #TRUE on success
2559 _dbus_concat_dir_and_file (DBusString *dir,
2560 const DBusString *next_component)
2562 dbus_bool_t dir_ends_in_slash;
2563 dbus_bool_t file_starts_with_slash;
2565 if (_dbus_string_get_length (dir) == 0 ||
2566 _dbus_string_get_length (next_component) == 0)
2569 dir_ends_in_slash = '/' == _dbus_string_get_byte (dir,
2570 _dbus_string_get_length (dir) - 1);
2572 file_starts_with_slash = '/' == _dbus_string_get_byte (next_component, 0);
2574 if (dir_ends_in_slash && file_starts_with_slash)
2576 _dbus_string_shorten (dir, 1);
2578 else if (!(dir_ends_in_slash || file_starts_with_slash))
2580 if (!_dbus_string_append_byte (dir, '/'))
2584 return _dbus_string_copy (next_component, 0, dir,
2585 _dbus_string_get_length (dir));
2588 /** nanoseconds in a second */
2589 #define NANOSECONDS_PER_SECOND 1000000000
2590 /** microseconds in a second */
2591 #define MICROSECONDS_PER_SECOND 1000000
2592 /** milliseconds in a second */
2593 #define MILLISECONDS_PER_SECOND 1000
2594 /** nanoseconds in a millisecond */
2595 #define NANOSECONDS_PER_MILLISECOND 1000000
2596 /** microseconds in a millisecond */
2597 #define MICROSECONDS_PER_MILLISECOND 1000
2600 * Sleeps the given number of milliseconds.
2601 * @param milliseconds number of milliseconds
2604 _dbus_sleep_milliseconds (int milliseconds)
2606 #ifdef HAVE_NANOSLEEP
2607 struct timespec req;
2608 struct timespec rem;
2610 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
2611 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
2615 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
2617 #elif defined (HAVE_USLEEP)
2618 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
2619 #else /* ! HAVE_USLEEP */
2620 sleep (MAX (milliseconds / 1000, 1));
2625 _dbus_generate_pseudorandom_bytes (DBusString *str,
2631 old_len = _dbus_string_get_length (str);
2633 if (!_dbus_string_lengthen (str, n_bytes))
2636 p = _dbus_string_get_data_len (str, old_len, n_bytes);
2638 _dbus_generate_pseudorandom_bytes_buffer (p, n_bytes);
2644 * Generates the given number of random bytes,
2645 * using the best mechanism we can come up with.
2647 * @param str the string
2648 * @param n_bytes the number of random bytes to append to string
2649 * @returns #TRUE on success, #FALSE if no memory
2652 _dbus_generate_random_bytes (DBusString *str,
2658 /* FALSE return means "no memory", if it could
2659 * mean something else then we'd need to return
2660 * a DBusError. So we always fall back to pseudorandom
2664 old_len = _dbus_string_get_length (str);
2667 /* note, urandom on linux will fall back to pseudorandom */
2668 fd = open ("/dev/urandom", O_RDONLY);
2670 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2672 _dbus_verbose ("/dev/urandom fd %d opened\n", fd);
2674 if (_dbus_read (fd, str, n_bytes) != n_bytes)
2676 _dbus_close (fd, NULL);
2677 _dbus_string_set_length (str, old_len);
2678 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2681 _dbus_verbose ("Read %d bytes from /dev/urandom\n",
2684 _dbus_close (fd, NULL);
2690 * Exit the process, returning the given value.
2692 * @param code the exit code
2695 _dbus_exit (int code)
2701 * A wrapper around strerror() because some platforms
2702 * may be lame and not have strerror(). Also, never
2705 * @param error_number errno.
2706 * @returns error description.
2709 _dbus_strerror (int error_number)
2713 msg = strerror (error_number);
2721 * signal (SIGPIPE, SIG_IGN);
2724 _dbus_disable_sigpipe (void)
2726 signal (SIGPIPE, SIG_IGN);
2730 * Sets the file descriptor to be close
2731 * on exec. Should be called for all file
2732 * descriptors in D-Bus code.
2734 * @param fd the file descriptor
2737 _dbus_fd_set_close_on_exec (intptr_t fd)
2741 val = fcntl (fd, F_GETFD, 0);
2748 fcntl (fd, F_SETFD, val);
2752 * Closes a file descriptor.
2754 * @param fd the file descriptor
2755 * @param error error object
2756 * @returns #FALSE if error set
2759 _dbus_close (int fd,
2762 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2770 dbus_set_error (error, _dbus_error_from_errno (errno),
2771 "Could not close fd %d", fd);
2779 * Duplicates a file descriptor. Makes sure the fd returned is >= 3
2780 * (i.e. avoids stdin/stdout/stderr). Sets O_CLOEXEC.
2782 * @param fd the file descriptor to duplicate
2783 * @returns duplicated file descriptor
2791 #ifdef F_DUPFD_CLOEXEC
2792 dbus_bool_t cloexec_done;
2794 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2795 cloexec_done = new_fd >= 0;
2797 if (new_fd < 0 && errno == EINVAL)
2800 new_fd = fcntl(fd, F_DUPFD, 3);
2805 dbus_set_error (error, _dbus_error_from_errno (errno),
2806 "Could not duplicate fd %d", fd);
2810 #ifdef F_DUPFD_CLOEXEC
2814 _dbus_fd_set_close_on_exec(new_fd);
2821 * Sets a file descriptor to be nonblocking.
2823 * @param fd the file descriptor.
2824 * @param error address of error location.
2825 * @returns #TRUE on success.
2828 _dbus_set_fd_nonblocking (int fd,
2833 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2835 val = fcntl (fd, F_GETFL, 0);
2838 dbus_set_error (error, _dbus_error_from_errno (errno),
2839 "Failed to get flags from file descriptor %d: %s",
2840 fd, _dbus_strerror (errno));
2841 _dbus_verbose ("Failed to get flags for fd %d: %s\n", fd,
2842 _dbus_strerror (errno));
2846 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
2848 dbus_set_error (error, _dbus_error_from_errno (errno),
2849 "Failed to set nonblocking flag of file descriptor %d: %s",
2850 fd, _dbus_strerror (errno));
2851 _dbus_verbose ("Failed to set fd %d nonblocking: %s\n",
2852 fd, _dbus_strerror (errno));
2861 * On GNU libc systems, print a crude backtrace to stderr. On other
2862 * systems, print "no backtrace support" and block for possible gdb
2863 * attachment if an appropriate environment variable is set.
2866 _dbus_print_backtrace (void)
2868 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
2874 bt_size = backtrace (bt, 500);
2876 syms = backtrace_symbols (bt, bt_size);
2881 /* don't use dbus_warn since it can _dbus_abort() */
2882 fprintf (stderr, " %s\n", syms[i]);
2888 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
2889 fprintf (stderr, " D-Bus not built with -rdynamic so unable to print a backtrace\n");
2891 fprintf (stderr, " D-Bus not compiled with backtrace support so unable to print a backtrace\n");
2896 * Creates a full-duplex pipe (as in socketpair()).
2897 * Sets both ends of the pipe nonblocking.
2899 * Marks both file descriptors as close-on-exec
2901 * @todo libdbus only uses this for the debug-pipe server, so in
2902 * principle it could be in dbus-sysdeps-util.c, except that
2903 * dbus-sysdeps-util.c isn't in libdbus when tests are enabled and the
2904 * debug-pipe server is used.
2906 * @param fd1 return location for one end
2907 * @param fd2 return location for the other end
2908 * @param blocking #TRUE if pipe should be blocking
2909 * @param error error return
2910 * @returns #FALSE on failure (if error is set)
2913 _dbus_full_duplex_pipe (int *fd1,
2915 dbus_bool_t blocking,
2918 #ifdef HAVE_SOCKETPAIR
2923 dbus_bool_t cloexec_done;
2925 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
2926 cloexec_done = retval >= 0;
2928 if (retval < 0 && errno == EINVAL)
2931 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
2936 dbus_set_error (error, _dbus_error_from_errno (errno),
2937 "Could not create full-duplex pipe");
2941 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2947 _dbus_fd_set_close_on_exec (fds[0]);
2948 _dbus_fd_set_close_on_exec (fds[1]);
2952 (!_dbus_set_fd_nonblocking (fds[0], NULL) ||
2953 !_dbus_set_fd_nonblocking (fds[1], NULL)))
2955 dbus_set_error (error, _dbus_error_from_errno (errno),
2956 "Could not set full-duplex pipe nonblocking");
2958 _dbus_close (fds[0], NULL);
2959 _dbus_close (fds[1], NULL);
2967 _dbus_verbose ("full-duplex pipe %d <-> %d\n",
2972 _dbus_warn ("_dbus_full_duplex_pipe() not implemented on this OS\n");
2973 dbus_set_error (error, DBUS_ERROR_FAILED,
2974 "_dbus_full_duplex_pipe() not implemented on this OS");
2980 * Measure the length of the given format string and arguments,
2981 * not including the terminating nul.
2983 * @param format a printf-style format string
2984 * @param args arguments for the format string
2985 * @returns length of the given format string and args
2988 _dbus_printf_string_upper_bound (const char *format,
2992 return vsnprintf (&c, 1, format, args);
2996 * Gets the temporary files directory by inspecting the environment variables
2997 * TMPDIR, TMP, and TEMP in that order. If none of those are set "/tmp" is returned
2999 * @returns location of temp directory
3002 _dbus_get_tmpdir(void)
3004 static const char* tmpdir = NULL;
3008 /* TMPDIR is what glibc uses, then
3009 * glibc falls back to the P_tmpdir macro which
3010 * just expands to "/tmp"
3013 tmpdir = getenv("TMPDIR");
3015 /* These two env variables are probably
3016 * broken, but maybe some OS uses them?
3019 tmpdir = getenv("TMP");
3021 tmpdir = getenv("TEMP");
3023 /* And this is the sane fallback. */
3028 _dbus_assert(tmpdir != NULL);
3034 * Execute a subprocess, returning up to 1024 bytes of output
3037 * If successful, returns #TRUE and appends the output to @p
3038 * result. If a failure happens, returns #FALSE and
3039 * sets an error in @p error.
3041 * @note It's not an error if the subprocess terminates normally
3042 * without writing any data to stdout. Verify the @p result length
3043 * before and after this function call to cover this case.
3045 * @param progname initial path to exec (may or may not be absolute)
3046 * @param path_fallback if %TRUE, search PATH for executable
3047 * @param argv NULL-terminated list of arguments
3048 * @param result a DBusString where the output can be append
3049 * @param error a DBusError to store the error in case of failure
3050 * @returns #TRUE on success, #FALSE if an error happened
3053 _read_subprocess_line_argv (const char *progpath,
3054 dbus_bool_t path_fallback,
3059 int result_pipe[2] = { -1, -1 };
3060 int errors_pipe[2] = { -1, -1 };
3068 sigset_t new_set, old_set;
3070 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3073 /* We need to block any existing handlers for SIGCHLD temporarily; they
3074 * will cause waitpid() below to fail.
3075 * https://bugs.freedesktop.org/show_bug.cgi?id=21347
3077 sigemptyset (&new_set);
3078 sigaddset (&new_set, SIGCHLD);
3079 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3081 orig_len = _dbus_string_get_length (result);
3085 if (pipe (result_pipe) < 0)
3087 dbus_set_error (error, _dbus_error_from_errno (errno),
3088 "Failed to create a pipe to call %s: %s",
3089 progpath, _dbus_strerror (errno));
3090 _dbus_verbose ("Failed to create a pipe to call %s: %s\n",
3091 progpath, _dbus_strerror (errno));
3094 if (pipe (errors_pipe) < 0)
3096 dbus_set_error (error, _dbus_error_from_errno (errno),
3097 "Failed to create a pipe to call %s: %s",
3098 progpath, _dbus_strerror (errno));
3099 _dbus_verbose ("Failed to create a pipe to call %s: %s\n",
3100 progpath, _dbus_strerror (errno));
3107 dbus_set_error (error, _dbus_error_from_errno (errno),
3108 "Failed to fork() to call %s: %s",
3109 progpath, _dbus_strerror (errno));
3110 _dbus_verbose ("Failed to fork() to call %s: %s\n",
3111 progpath, _dbus_strerror (errno));
3121 fd = open ("/dev/null", O_RDWR);
3123 /* huh?! can't open /dev/null? */
3126 _dbus_verbose ("/dev/null fd %d opened\n", fd);
3129 close (result_pipe[READ_END]);
3130 close (errors_pipe[READ_END]);
3131 close (0); /* close stdin */
3132 close (1); /* close stdout */
3133 close (2); /* close stderr */
3135 if (dup2 (fd, 0) == -1)
3137 if (dup2 (result_pipe[WRITE_END], 1) == -1)
3139 if (dup2 (errors_pipe[WRITE_END], 2) == -1)
3142 maxfds = sysconf (_SC_OPEN_MAX);
3143 /* Pick something reasonable if for some reason sysconf
3148 /* close all inherited fds */
3149 for (i = 3; i < maxfds; i++)
3152 sigprocmask (SIG_SETMASK, &old_set, NULL);
3154 /* If it looks fully-qualified, try execv first */
3155 if (progpath[0] == '/')
3157 execv (progpath, argv);
3158 /* Ok, that failed. Now if path_fallback is given, let's
3159 * try unqualified. This is mostly a hack to work
3160 * around systems which ship dbus-launch in /usr/bin
3161 * but everything else in /bin (because dbus-launch
3165 /* We must have a slash, because we checked above */
3166 execvp (strrchr (progpath, '/')+1, argv);
3169 execvp (progpath, argv);
3171 /* still nothing, we failed */
3175 /* parent process */
3176 close (result_pipe[WRITE_END]);
3177 close (errors_pipe[WRITE_END]);
3178 result_pipe[WRITE_END] = -1;
3179 errors_pipe[WRITE_END] = -1;
3184 ret = _dbus_read (result_pipe[READ_END], result, 1024);
3188 /* reap the child process to avoid it lingering as zombie */
3191 ret = waitpid (pid, &status, 0);
3193 while (ret == -1 && errno == EINTR);
3195 /* We succeeded if the process exited with status 0 and
3196 anything was read */
3197 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
3199 /* The process ended with error */
3200 DBusString error_message;
3201 if (!_dbus_string_init (&error_message))
3203 _DBUS_SET_OOM (error);
3210 ret = _dbus_read (errors_pipe[READ_END], &error_message, 1024);
3214 _dbus_string_set_length (result, orig_len);
3215 if (_dbus_string_get_length (&error_message) > 0)
3216 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
3217 "%s terminated abnormally with the following error: %s",
3218 progpath, _dbus_string_get_data (&error_message));
3220 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
3221 "%s terminated abnormally without any error message",
3229 sigprocmask (SIG_SETMASK, &old_set, NULL);
3232 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3234 _DBUS_ASSERT_ERROR_IS_SET (error);
3236 if (result_pipe[0] != -1)
3237 close (result_pipe[0]);
3238 if (result_pipe[1] != -1)
3239 close (result_pipe[1]);
3240 if (errors_pipe[0] != -1)
3241 close (errors_pipe[0]);
3242 if (errors_pipe[1] != -1)
3243 close (errors_pipe[1]);
3249 * Returns the address of a new session bus.
3251 * If successful, returns #TRUE and appends the address to @p
3252 * address. If a failure happens, returns #FALSE and
3253 * sets an error in @p error.
3255 * @param address a DBusString where the address can be stored
3256 * @param error a DBusError to store the error in case of failure
3257 * @returns #TRUE on success, #FALSE if an error happened
3260 _dbus_get_autolaunch_address (const char *scope,
3261 DBusString *address,
3264 #ifdef DBUS_ENABLE_X11_AUTOLAUNCH
3265 /* Perform X11-based autolaunch. (We also support launchd-based autolaunch,
3266 * but that's done elsewhere, and if it worked, this function wouldn't
3268 const char *display;
3269 static char *argv[6];
3274 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3277 /* fd.o #19997: if $DISPLAY isn't set to something useful, then
3278 * dbus-launch-x11 is just going to fail. Rather than trying to
3279 * run it, we might as well bail out early with a nice error. */
3280 display = _dbus_getenv ("DISPLAY");
3282 if (display == NULL || display[0] == '\0')
3284 dbus_set_error_const (error, DBUS_ERROR_NOT_SUPPORTED,
3285 "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
3289 if (!_dbus_string_init (&uuid))
3291 _DBUS_SET_OOM (error);
3295 if (!_dbus_get_local_machine_uuid_encoded (&uuid))
3297 _DBUS_SET_OOM (error);
3302 argv[i] = "dbus-launch";
3304 argv[i] = "--autolaunch";
3306 argv[i] = _dbus_string_get_data (&uuid);
3308 argv[i] = "--binary-syntax";
3310 argv[i] = "--close-stderr";
3315 _dbus_assert (i == _DBUS_N_ELEMENTS (argv));
3317 retval = _read_subprocess_line_argv (DBUS_BINDIR "/dbus-launch",
3319 argv, address, error);
3322 _dbus_string_free (&uuid);
3325 dbus_set_error_const (error, DBUS_ERROR_NOT_SUPPORTED,
3326 "Using X11 for dbus-daemon autolaunch was disabled at compile time, "
3327 "set your DBUS_SESSION_BUS_ADDRESS instead");
3333 * Reads the uuid of the machine we're running on from
3334 * the dbus configuration. Optionally try to create it
3335 * (only root can do this usually).
3337 * On UNIX, reads a file that gets created by dbus-uuidgen
3338 * in a post-install script. On Windows, if there's a standard
3339 * machine uuid we could just use that, but I can't find one
3340 * with the right properties (the hardware profile guid can change
3341 * without rebooting I believe). If there's no standard one
3342 * we might want to use the registry instead of a file for
3343 * this, and I'm not sure how we'd ensure the uuid gets created.
3345 * @param machine_id guid to init with the machine's uuid
3346 * @param create_if_not_found try to create the uuid if it doesn't exist
3347 * @param error the error return
3348 * @returns #FALSE if the error is set
3351 _dbus_read_local_machine_uuid (DBusGUID *machine_id,
3352 dbus_bool_t create_if_not_found,
3355 DBusString filename;
3358 _dbus_string_init_const (&filename, DBUS_MACHINE_UUID_FILE);
3360 b = _dbus_read_uuid_file (&filename, machine_id, create_if_not_found, error);
3364 dbus_error_free (error);
3366 /* Fallback to the system machine ID */
3367 _dbus_string_init_const (&filename, "/etc/machine-id");
3368 return _dbus_read_uuid_file (&filename, machine_id, FALSE, error);
3371 #define DBUS_UNIX_STANDARD_SESSION_SERVICEDIR "/dbus-1/services"
3372 #define DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR "/dbus-1/system-services"
3375 * quries launchd for a specific env var which holds the socket path.
3376 * @param launchd_env_var the env var to look up
3377 * @param error a DBusError to store the error in case of failure
3378 * @return the value of the env var
3381 _dbus_lookup_launchd_socket (DBusString *socket_path,
3382 const char *launchd_env_var,
3385 #ifdef DBUS_ENABLE_LAUNCHD
3389 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3392 argv[i] = "launchctl";
3396 argv[i] = (char*)launchd_env_var;
3401 _dbus_assert (i == _DBUS_N_ELEMENTS (argv));
3403 if (!_read_subprocess_line_argv(argv[0], TRUE, argv, socket_path, error))
3408 /* no error, but no result either */
3409 if (_dbus_string_get_length(socket_path) == 0)
3414 /* strip the carriage-return */
3415 _dbus_string_shorten(socket_path, 1);
3417 #else /* DBUS_ENABLE_LAUNCHD */
3418 dbus_set_error(error, DBUS_ERROR_NOT_SUPPORTED,
3419 "can't lookup socket from launchd; launchd support not compiled in");
3424 #ifdef DBUS_ENABLE_LAUNCHD
3426 _dbus_lookup_session_address_launchd (DBusString *address, DBusError *error)
3428 dbus_bool_t valid_socket;
3429 DBusString socket_path;
3431 if (!_dbus_string_init (&socket_path))
3433 _DBUS_SET_OOM (error);
3437 valid_socket = _dbus_lookup_launchd_socket (&socket_path, "DBUS_LAUNCHD_SESSION_BUS_SOCKET", error);
3439 if (dbus_error_is_set(error))
3441 _dbus_string_free(&socket_path);
3447 dbus_set_error(error, "no socket path",
3448 "launchd did not provide a socket path, "
3449 "verify that org.freedesktop.dbus-session.plist is loaded!");
3450 _dbus_string_free(&socket_path);
3453 if (!_dbus_string_append (address, "unix:path="))
3455 _DBUS_SET_OOM (error);
3456 _dbus_string_free(&socket_path);
3459 if (!_dbus_string_copy (&socket_path, 0, address,
3460 _dbus_string_get_length (address)))
3462 _DBUS_SET_OOM (error);
3463 _dbus_string_free(&socket_path);
3467 _dbus_string_free(&socket_path);
3473 * Determines the address of the session bus by querying a
3474 * platform-specific method.
3476 * The first parameter will be a boolean specifying whether
3477 * or not a dynamic session lookup is supported on this platform.
3479 * If supported is TRUE and the return value is #TRUE, the
3480 * address will be appended to @p address.
3481 * If a failure happens, returns #FALSE and sets an error in
3484 * If supported is FALSE, ignore the return value.
3486 * @param supported returns whether this method is supported
3487 * @param address a DBusString where the address can be stored
3488 * @param error a DBusError to store the error in case of failure
3489 * @returns #TRUE on success, #FALSE if an error happened
3492 _dbus_lookup_session_address (dbus_bool_t *supported,
3493 DBusString *address,
3496 #ifdef DBUS_ENABLE_LAUNCHD
3498 return _dbus_lookup_session_address_launchd (address, error);
3500 /* On non-Mac Unix platforms, if the session address isn't already
3501 * set in DBUS_SESSION_BUS_ADDRESS environment variable, we punt and
3502 * fall back to the autolaunch: global default; see
3503 * init_session_address in dbus/dbus-bus.c. */
3510 * Returns the standard directories for a session bus to look for service
3513 * On UNIX this should be the standard xdg freedesktop.org data directories:
3515 * XDG_DATA_HOME=${XDG_DATA_HOME-$HOME/.local/share}
3516 * XDG_DATA_DIRS=${XDG_DATA_DIRS-/usr/local/share:/usr/share}
3522 * @param dirs the directory list we are returning
3523 * @returns #FALSE on OOM
3527 _dbus_get_standard_session_servicedirs (DBusList **dirs)
3529 const char *xdg_data_home;
3530 const char *xdg_data_dirs;
3531 DBusString servicedir_path;
3533 if (!_dbus_string_init (&servicedir_path))
3536 xdg_data_home = _dbus_getenv ("XDG_DATA_HOME");
3537 xdg_data_dirs = _dbus_getenv ("XDG_DATA_DIRS");
3539 if (xdg_data_home != NULL)
3541 if (!_dbus_string_append (&servicedir_path, xdg_data_home))
3546 const DBusString *homedir;
3547 DBusString local_share;
3549 if (!_dbus_homedir_from_current_process (&homedir))
3552 if (!_dbus_string_append (&servicedir_path, _dbus_string_get_const_data (homedir)))
3555 _dbus_string_init_const (&local_share, "/.local/share");
3556 if (!_dbus_concat_dir_and_file (&servicedir_path, &local_share))
3560 if (!_dbus_string_append (&servicedir_path, ":"))
3563 if (xdg_data_dirs != NULL)
3565 if (!_dbus_string_append (&servicedir_path, xdg_data_dirs))
3568 if (!_dbus_string_append (&servicedir_path, ":"))
3573 if (!_dbus_string_append (&servicedir_path, "/usr/local/share:/usr/share:"))
3578 * add configured datadir to defaults
3579 * this may be the same as an xdg dir
3580 * however the config parser should take
3581 * care of duplicates
3583 if (!_dbus_string_append (&servicedir_path, DBUS_DATADIR))
3586 if (!_dbus_split_paths_and_append (&servicedir_path,
3587 DBUS_UNIX_STANDARD_SESSION_SERVICEDIR,
3591 _dbus_string_free (&servicedir_path);
3595 _dbus_string_free (&servicedir_path);
3601 * Returns the standard directories for a system bus to look for service
3604 * On UNIX this should be the standard xdg freedesktop.org data directories:
3606 * XDG_DATA_DIRS=${XDG_DATA_DIRS-/usr/local/share:/usr/share}
3612 * On Windows there is no system bus and this function can return nothing.
3614 * @param dirs the directory list we are returning
3615 * @returns #FALSE on OOM
3619 _dbus_get_standard_system_servicedirs (DBusList **dirs)
3621 const char *xdg_data_dirs;
3622 DBusString servicedir_path;
3624 if (!_dbus_string_init (&servicedir_path))
3627 xdg_data_dirs = _dbus_getenv ("XDG_DATA_DIRS");
3629 if (xdg_data_dirs != NULL)
3631 if (!_dbus_string_append (&servicedir_path, xdg_data_dirs))
3634 if (!_dbus_string_append (&servicedir_path, ":"))
3639 if (!_dbus_string_append (&servicedir_path, "/usr/local/share:/usr/share:"))
3644 * Add configured datadir to defaults. This may be the same as one
3645 * of the XDG directories. However, the config parser should take
3646 * care of the duplicates.
3648 * Also, append /lib as counterpart of /usr/share on the root
3649 * directory (the root directory does not know /share), in order to
3650 * facilitate early boot system bus activation where /usr might not
3653 if (!_dbus_string_append (&servicedir_path,
3658 if (!_dbus_split_paths_and_append (&servicedir_path,
3659 DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR,
3663 _dbus_string_free (&servicedir_path);
3667 _dbus_string_free (&servicedir_path);
3672 * Append the absolute path of the system.conf file
3673 * (there is no system bus on Windows so this can just
3674 * return FALSE and print a warning or something)
3676 * @param str the string to append to
3677 * @returns #FALSE if no memory
3680 _dbus_append_system_config_file (DBusString *str)
3682 return _dbus_string_append (str, DBUS_SYSTEM_CONFIG_FILE);
3686 * Append the absolute path of the session.conf file.
3688 * @param str the string to append to
3689 * @returns #FALSE if no memory
3692 _dbus_append_session_config_file (DBusString *str)
3694 return _dbus_string_append (str, DBUS_SESSION_CONFIG_FILE);
3698 * Called when the bus daemon is signaled to reload its configuration; any
3699 * caches should be nuked. Of course any caches that need explicit reload
3700 * are probably broken, but c'est la vie.
3705 _dbus_flush_caches (void)
3707 _dbus_user_database_flush_system ();
3711 * Appends the directory in which a keyring for the given credentials
3712 * should be stored. The credentials should have either a Windows or
3713 * UNIX user in them. The directory should be an absolute path.
3715 * On UNIX the directory is ~/.dbus-keyrings while on Windows it should probably
3716 * be something else, since the dotfile convention is not normal on Windows.
3718 * @param directory string to append directory to
3719 * @param credentials credentials the directory should be for
3721 * @returns #FALSE on no memory
3724 _dbus_append_keyring_directory_for_credentials (DBusString *directory,
3725 DBusCredentials *credentials)
3731 _dbus_assert (credentials != NULL);
3732 _dbus_assert (!_dbus_credentials_are_anonymous (credentials));
3734 if (!_dbus_string_init (&homedir))
3737 uid = _dbus_credentials_get_unix_uid (credentials);
3738 _dbus_assert (uid != DBUS_UID_UNSET);
3740 if (!_dbus_homedir_from_uid (uid, &homedir))
3743 #ifdef DBUS_BUILD_TESTS
3745 const char *override;
3747 override = _dbus_getenv ("DBUS_TEST_HOMEDIR");
3748 if (override != NULL && *override != '\0')
3750 _dbus_string_set_length (&homedir, 0);
3751 if (!_dbus_string_append (&homedir, override))
3754 _dbus_verbose ("Using fake homedir for testing: %s\n",
3755 _dbus_string_get_const_data (&homedir));
3759 static dbus_bool_t already_warned = FALSE;
3760 if (!already_warned)
3762 _dbus_warn ("Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid\n");
3763 already_warned = TRUE;
3769 _dbus_string_init_const (&dotdir, ".dbus-keyrings");
3770 if (!_dbus_concat_dir_and_file (&homedir,
3774 if (!_dbus_string_copy (&homedir, 0,
3775 directory, _dbus_string_get_length (directory))) {
3779 _dbus_string_free (&homedir);
3783 _dbus_string_free (&homedir);
3787 //PENDING(kdab) docs
3789 _dbus_daemon_publish_session_bus_address (const char* addr,
3795 //PENDING(kdab) docs
3797 _dbus_daemon_unpublish_session_bus_address (void)
3803 * See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently
3804 * for Winsock so is abstracted)
3806 * @returns #TRUE if errno == EAGAIN or errno == EWOULDBLOCK
3809 _dbus_get_is_errno_eagain_or_ewouldblock (void)
3811 return errno == EAGAIN || errno == EWOULDBLOCK;
3815 * Removes a directory; Directory must be empty
3817 * @param filename directory filename
3818 * @param error initialized error object
3819 * @returns #TRUE on success
3822 _dbus_delete_directory (const DBusString *filename,
3825 const char *filename_c;
3827 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3829 filename_c = _dbus_string_get_const_data (filename);
3831 if (rmdir (filename_c) != 0)
3833 dbus_set_error (error, DBUS_ERROR_FAILED,
3834 "Failed to remove directory %s: %s\n",
3835 filename_c, _dbus_strerror (errno));
3843 * Checks whether file descriptors may be passed via the socket
3845 * @param fd the socket
3846 * @return TRUE when fd passing over this socket is supported
3850 _dbus_socket_can_pass_unix_fd(int fd) {
3855 struct sockaddr_storage storage;
3856 struct sockaddr_un un;
3859 socklen_t sa_len = sizeof(sa_buf);
3863 if (getsockname(fd, &sa_buf.sa, &sa_len) < 0)
3866 return sa_buf.sa.sa_family == AF_UNIX;
3876 * replaces the term DBUS_PREFIX in configure_time_path by the
3877 * current dbus installation directory. On unix this function is a noop
3879 * @param configure_time_path
3883 _dbus_replace_install_prefix (const char *configure_time_path)
3885 return configure_time_path;
3888 /* tests in dbus-sysdeps-util.c */