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 _dbus_open_tcp_socket (int *fd,
139 return _dbus_open_socket(fd, AF_INET, SOCK_STREAM, 0, error);
143 * Opens a UNIX domain socket (as in the socket() call).
144 * Does not bind the socket.
146 * This will set FD_CLOEXEC for the socket returned
148 * @param fd return location for socket descriptor
149 * @param error return location for an error
150 * @returns #FALSE if error is set
153 _dbus_open_unix_socket (int *fd,
156 return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);
160 * Closes a socket. Should not be used on non-socket
161 * file descriptors or handles.
163 * @param fd the socket
164 * @param error return location for an error
165 * @returns #FALSE if error is set
168 _dbus_close_socket (int fd,
171 return _dbus_close (fd, error);
175 * Like _dbus_read(), but only works on sockets so is
176 * available on Windows.
178 * @param fd the socket
179 * @param buffer string to append data to
180 * @param count max amount of data to read
181 * @returns number of bytes appended to the string
184 _dbus_read_socket (int fd,
188 return _dbus_read (fd, buffer, count);
192 * Like _dbus_write(), but only supports sockets
193 * and is thus available on Windows.
195 * @param fd the file descriptor to write
196 * @param buffer the buffer to write data from
197 * @param start the first byte in the buffer to write
198 * @param len the number of bytes to try to write
199 * @returns the number of bytes written or -1 on error
202 _dbus_write_socket (int fd,
203 const DBusString *buffer,
211 data = _dbus_string_get_const_data_len (buffer, start, len);
215 bytes_written = send (fd, data, len, MSG_NOSIGNAL);
217 if (bytes_written < 0 && errno == EINTR)
220 return bytes_written;
223 return _dbus_write (fd, buffer, start, len);
228 * Like _dbus_read_socket() but also tries to read unix fds from the
229 * socket. When there are more fds to read than space in the array
230 * passed this function will fail with ENOSPC.
232 * @param fd the socket
233 * @param buffer string to append data to
234 * @param count max amount of data to read
235 * @param fds array to place read file descriptors in
236 * @param n_fds on input space in fds array, on output how many fds actually got read
237 * @returns number of bytes appended to string
240 _dbus_read_socket_with_unix_fds (int fd,
245 #ifndef HAVE_UNIX_FD_PASSING
248 if ((r = _dbus_read_socket(fd, buffer, count)) < 0)
260 _dbus_assert (count >= 0);
261 _dbus_assert (*n_fds >= 0);
263 start = _dbus_string_get_length (buffer);
265 if (!_dbus_string_lengthen (buffer, count))
272 iov.iov_base = _dbus_string_get_data_len (buffer, start, count);
279 /* Hmm, we have no clue how long the control data will actually be
280 that is queued for us. The least we can do is assume that the
281 caller knows. Hence let's make space for the number of fds that
282 we shall read at max plus the cmsg header. */
283 m.msg_controllen = CMSG_SPACE(*n_fds * sizeof(int));
285 /* It's probably safe to assume that systems with SCM_RIGHTS also
287 m.msg_control = alloca(m.msg_controllen);
288 memset(m.msg_control, 0, m.msg_controllen);
292 bytes_read = recvmsg(fd, &m, 0
293 #ifdef MSG_CMSG_CLOEXEC
304 /* put length back (note that this doesn't actually realloc anything) */
305 _dbus_string_set_length (buffer, start);
312 dbus_bool_t found = FALSE;
314 if (m.msg_flags & MSG_CTRUNC)
316 /* Hmm, apparently the control data was truncated. The bad
317 thing is that we might have completely lost a couple of fds
318 without chance to recover them. Hence let's treat this as a
322 _dbus_string_set_length (buffer, start);
326 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
327 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
331 _dbus_assert(cm->cmsg_len <= CMSG_LEN(*n_fds * sizeof(int)));
332 *n_fds = (cm->cmsg_len - CMSG_LEN(0)) / sizeof(int);
334 memcpy(fds, CMSG_DATA(cm), *n_fds * sizeof(int));
337 /* Linux doesn't tell us whether MSG_CMSG_CLOEXEC actually
338 worked, hence we need to go through this list and set
339 CLOEXEC everywhere in any case */
340 for (i = 0; i < *n_fds; i++)
341 _dbus_fd_set_close_on_exec(fds[i]);
349 /* put length back (doesn't actually realloc) */
350 _dbus_string_set_length (buffer, start + bytes_read);
354 _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
363 _dbus_write_socket_with_unix_fds(int fd,
364 const DBusString *buffer,
370 #ifndef HAVE_UNIX_FD_PASSING
377 return _dbus_write_socket(fd, buffer, start, len);
379 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len, NULL, 0, 0, fds, n_fds);
384 _dbus_write_socket_with_unix_fds_two(int fd,
385 const DBusString *buffer1,
388 const DBusString *buffer2,
394 #ifndef HAVE_UNIX_FD_PASSING
401 return _dbus_write_socket_two(fd,
402 buffer1, start1, len1,
403 buffer2, start2, len2);
411 _dbus_assert (len1 >= 0);
412 _dbus_assert (len2 >= 0);
413 _dbus_assert (n_fds >= 0);
416 iov[0].iov_base = (char*) _dbus_string_get_const_data_len (buffer1, start1, len1);
417 iov[0].iov_len = len1;
421 iov[1].iov_base = (char*) _dbus_string_get_const_data_len (buffer2, start2, len2);
422 iov[1].iov_len = len2;
427 m.msg_iovlen = buffer2 ? 2 : 1;
431 m.msg_controllen = CMSG_SPACE(n_fds * sizeof(int));
432 m.msg_control = alloca(m.msg_controllen);
433 memset(m.msg_control, 0, m.msg_controllen);
435 cm = CMSG_FIRSTHDR(&m);
436 cm->cmsg_level = SOL_SOCKET;
437 cm->cmsg_type = SCM_RIGHTS;
438 cm->cmsg_len = CMSG_LEN(n_fds * sizeof(int));
439 memcpy(CMSG_DATA(cm), fds, n_fds * sizeof(int));
444 bytes_written = sendmsg (fd, &m, 0
450 if (bytes_written < 0 && errno == EINTR)
454 if (bytes_written > 0)
455 _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
458 return bytes_written;
463 * Like _dbus_write_two() but only works on sockets and is thus
464 * available on Windows.
466 * @param fd the file descriptor
467 * @param buffer1 first buffer
468 * @param start1 first byte to write in first buffer
469 * @param len1 number of bytes to write from first buffer
470 * @param buffer2 second buffer, or #NULL
471 * @param start2 first byte to write in second buffer
472 * @param len2 number of bytes to write in second buffer
473 * @returns total bytes written from both buffers, or -1 on error
476 _dbus_write_socket_two (int fd,
477 const DBusString *buffer1,
480 const DBusString *buffer2,
485 struct iovec vectors[2];
491 _dbus_assert (buffer1 != NULL);
492 _dbus_assert (start1 >= 0);
493 _dbus_assert (start2 >= 0);
494 _dbus_assert (len1 >= 0);
495 _dbus_assert (len2 >= 0);
497 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
500 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
508 vectors[0].iov_base = (char*) data1;
509 vectors[0].iov_len = len1;
510 vectors[1].iov_base = (char*) data2;
511 vectors[1].iov_len = len2;
515 m.msg_iovlen = data2 ? 2 : 1;
519 bytes_written = sendmsg (fd, &m, MSG_NOSIGNAL);
521 if (bytes_written < 0 && errno == EINTR)
524 return bytes_written;
527 return _dbus_write_two (fd, buffer1, start1, len1,
528 buffer2, start2, len2);
533 _dbus_socket_is_invalid (int fd)
535 return fd < 0 ? TRUE : FALSE;
539 * Thin wrapper around the read() system call that appends
540 * the data it reads to the DBusString buffer. It appends
541 * up to the given count, and returns the same value
542 * and same errno as read(). The only exception is that
543 * _dbus_read() handles EINTR for you. Also, _dbus_read() can
544 * return ENOMEM, even though regular UNIX read doesn't.
546 * Unlike _dbus_read_socket(), _dbus_read() is not available
549 * @param fd the file descriptor to read from
550 * @param buffer the buffer to append data to
551 * @param count the amount of data to read
552 * @returns the number of bytes read or -1
563 _dbus_assert (count >= 0);
565 start = _dbus_string_get_length (buffer);
567 if (!_dbus_string_lengthen (buffer, count))
573 data = _dbus_string_get_data_len (buffer, start, count);
577 bytes_read = read (fd, data, count);
585 /* put length back (note that this doesn't actually realloc anything) */
586 _dbus_string_set_length (buffer, start);
592 /* put length back (doesn't actually realloc) */
593 _dbus_string_set_length (buffer, start + bytes_read);
597 _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
605 * Thin wrapper around the write() system call that writes a part of a
606 * DBusString and handles EINTR for you.
608 * @param fd the file descriptor to write
609 * @param buffer the buffer to write data from
610 * @param start the first byte in the buffer to write
611 * @param len the number of bytes to try to write
612 * @returns the number of bytes written or -1 on error
616 const DBusString *buffer,
623 data = _dbus_string_get_const_data_len (buffer, start, len);
627 bytes_written = write (fd, data, len);
629 if (bytes_written < 0 && errno == EINTR)
633 if (bytes_written > 0)
634 _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
637 return bytes_written;
641 * Like _dbus_write() but will use writev() if possible
642 * to write both buffers in sequence. The return value
643 * is the number of bytes written in the first buffer,
644 * plus the number written in the second. If the first
645 * buffer is written successfully and an error occurs
646 * writing the second, the number of bytes in the first
647 * is returned (i.e. the error is ignored), on systems that
648 * don't have writev. Handles EINTR for you.
649 * The second buffer may be #NULL.
651 * @param fd the file descriptor
652 * @param buffer1 first buffer
653 * @param start1 first byte to write in first buffer
654 * @param len1 number of bytes to write from first buffer
655 * @param buffer2 second buffer, or #NULL
656 * @param start2 first byte to write in second buffer
657 * @param len2 number of bytes to write in second buffer
658 * @returns total bytes written from both buffers, or -1 on error
661 _dbus_write_two (int fd,
662 const DBusString *buffer1,
665 const DBusString *buffer2,
669 _dbus_assert (buffer1 != NULL);
670 _dbus_assert (start1 >= 0);
671 _dbus_assert (start2 >= 0);
672 _dbus_assert (len1 >= 0);
673 _dbus_assert (len2 >= 0);
677 struct iovec vectors[2];
682 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
685 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
693 vectors[0].iov_base = (char*) data1;
694 vectors[0].iov_len = len1;
695 vectors[1].iov_base = (char*) data2;
696 vectors[1].iov_len = len2;
700 bytes_written = writev (fd,
704 if (bytes_written < 0 && errno == EINTR)
707 return bytes_written;
709 #else /* HAVE_WRITEV */
713 ret1 = _dbus_write (fd, buffer1, start1, len1);
714 if (ret1 == len1 && buffer2 != NULL)
716 ret2 = _dbus_write (fd, buffer2, start2, len2);
718 ret2 = 0; /* we can't report an error as the first write was OK */
725 #endif /* !HAVE_WRITEV */
728 #define _DBUS_MAX_SUN_PATH_LENGTH 99
731 * @def _DBUS_MAX_SUN_PATH_LENGTH
733 * Maximum length of the path to a UNIX domain socket,
734 * sockaddr_un::sun_path member. POSIX requires that all systems
735 * support at least 100 bytes here, including the nul termination.
736 * We use 99 for the max value to allow for the nul.
738 * We could probably also do sizeof (addr.sun_path)
739 * but this way we are the same on all platforms
740 * which is probably a good idea.
744 * Creates a socket and connects it to the UNIX domain socket at the
745 * given path. The connection fd is returned, and is set up as
748 * Uses abstract sockets instead of filesystem-linked sockets if
749 * requested (it's possible only on Linux; see "man 7 unix" on Linux).
750 * On non-Linux abstract socket usage always fails.
752 * This will set FD_CLOEXEC for the socket returned.
754 * @param path the path to UNIX domain socket
755 * @param abstract #TRUE to use abstract namespace
756 * @param error return location for error code
757 * @returns connection file descriptor or -1 on error
760 _dbus_connect_unix_socket (const char *path,
761 dbus_bool_t abstract,
766 struct sockaddr_un addr;
768 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
770 _dbus_verbose ("connecting to unix socket %s abstract=%d\n",
774 if (!_dbus_open_unix_socket (&fd, error))
776 _DBUS_ASSERT_ERROR_IS_SET(error);
779 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
782 addr.sun_family = AF_UNIX;
783 path_len = strlen (path);
787 #ifdef HAVE_ABSTRACT_SOCKETS
788 addr.sun_path[0] = '\0'; /* this is what says "use abstract" */
789 path_len++; /* Account for the extra nul byte added to the start of sun_path */
791 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
793 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
794 "Abstract socket name too long\n");
795 _dbus_close (fd, NULL);
799 strncpy (&addr.sun_path[1], path, path_len);
800 /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */
801 #else /* HAVE_ABSTRACT_SOCKETS */
802 dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
803 "Operating system does not support abstract socket namespace\n");
804 _dbus_close (fd, NULL);
806 #endif /* ! HAVE_ABSTRACT_SOCKETS */
810 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
812 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
813 "Socket name too long\n");
814 _dbus_close (fd, NULL);
818 strncpy (addr.sun_path, path, path_len);
821 if (connect (fd, (struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (struct sockaddr_un, sun_path) + path_len) < 0)
823 dbus_set_error (error,
824 _dbus_error_from_errno (errno),
825 "Failed to connect to socket %s: %s",
826 path, _dbus_strerror (errno));
828 _dbus_close (fd, NULL);
834 if (!_dbus_set_fd_nonblocking (fd, error))
836 _DBUS_ASSERT_ERROR_IS_SET (error);
838 _dbus_close (fd, NULL);
848 * Enables or disables the reception of credentials on the given socket during
849 * the next message transmission. This is only effective if the #LOCAL_CREDS
850 * system feature exists, in which case the other side of the connection does
851 * not have to do anything special to send the credentials.
853 * @param fd socket on which to change the #LOCAL_CREDS flag.
854 * @param on whether to enable or disable the #LOCAL_CREDS flag.
857 _dbus_set_local_creds (int fd, dbus_bool_t on)
859 dbus_bool_t retval = TRUE;
861 #if defined(HAVE_CMSGCRED)
862 /* NOOP just to make sure only one codepath is used
863 * and to prefer CMSGCRED
865 #elif defined(LOCAL_CREDS)
866 int val = on ? 1 : 0;
867 if (setsockopt (fd, 0, LOCAL_CREDS, &val, sizeof (val)) < 0)
869 _dbus_verbose ("Unable to set LOCAL_CREDS socket option on fd %d\n", fd);
873 _dbus_verbose ("LOCAL_CREDS %s for further messages on fd %d\n",
874 on ? "enabled" : "disabled", fd);
881 * Creates a socket and binds it to the given path,
882 * then listens on the socket. The socket is
883 * set to be nonblocking.
885 * Uses abstract sockets instead of filesystem-linked
886 * sockets if requested (it's possible only on Linux;
887 * see "man 7 unix" on Linux).
888 * On non-Linux abstract socket usage always fails.
890 * This will set FD_CLOEXEC for the socket returned
892 * @param path the socket name
893 * @param abstract #TRUE to use abstract namespace
894 * @param error return location for errors
895 * @returns the listening file descriptor or -1 on error
898 _dbus_listen_unix_socket (const char *path,
899 dbus_bool_t abstract,
903 struct sockaddr_un addr;
906 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
908 _dbus_verbose ("listening on unix socket %s abstract=%d\n",
911 if (!_dbus_open_unix_socket (&listen_fd, error))
913 _DBUS_ASSERT_ERROR_IS_SET(error);
916 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
919 addr.sun_family = AF_UNIX;
920 path_len = strlen (path);
924 #ifdef HAVE_ABSTRACT_SOCKETS
925 /* remember that abstract names aren't nul-terminated so we rely
926 * on sun_path being filled in with zeroes above.
928 addr.sun_path[0] = '\0'; /* this is what says "use abstract" */
929 path_len++; /* Account for the extra nul byte added to the start of sun_path */
931 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
933 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
934 "Abstract socket name too long\n");
935 _dbus_close (listen_fd, NULL);
939 strncpy (&addr.sun_path[1], path, path_len);
940 /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */
941 #else /* HAVE_ABSTRACT_SOCKETS */
942 dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
943 "Operating system does not support abstract socket namespace\n");
944 _dbus_close (listen_fd, NULL);
946 #endif /* ! HAVE_ABSTRACT_SOCKETS */
950 /* Discussed security implications of this with Nalin,
951 * and we couldn't think of where it would kick our ass, but
952 * it still seems a bit sucky. It also has non-security suckage;
953 * really we'd prefer to exit if the socket is already in use.
954 * But there doesn't seem to be a good way to do this.
956 * Just to be extra careful, I threw in the stat() - clearly
957 * the stat() can't *fix* any security issue, but it at least
958 * avoids inadvertent/accidental data loss.
963 if (stat (path, &sb) == 0 &&
964 S_ISSOCK (sb.st_mode))
968 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
970 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
971 "Abstract socket name too long\n");
972 _dbus_close (listen_fd, NULL);
976 strncpy (addr.sun_path, path, path_len);
979 if (bind (listen_fd, (struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (struct sockaddr_un, sun_path) + path_len) < 0)
981 dbus_set_error (error, _dbus_error_from_errno (errno),
982 "Failed to bind socket \"%s\": %s",
983 path, _dbus_strerror (errno));
984 _dbus_close (listen_fd, NULL);
988 if (listen (listen_fd, 30 /* backlog */) < 0)
990 dbus_set_error (error, _dbus_error_from_errno (errno),
991 "Failed to listen on socket \"%s\": %s",
992 path, _dbus_strerror (errno));
993 _dbus_close (listen_fd, NULL);
997 if (!_dbus_set_local_creds (listen_fd, TRUE))
999 dbus_set_error (error, _dbus_error_from_errno (errno),
1000 "Failed to enable LOCAL_CREDS on socket \"%s\": %s",
1001 path, _dbus_strerror (errno));
1006 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1008 _DBUS_ASSERT_ERROR_IS_SET (error);
1009 _dbus_close (listen_fd, NULL);
1013 /* Try opening up the permissions, but if we can't, just go ahead
1014 * and continue, maybe it will be good enough.
1016 if (!abstract && chmod (path, 0777) < 0)
1017 _dbus_warn ("Could not set mode 0777 on socket %s\n",
1024 * Acquires one or more sockets passed in from systemd. The sockets
1025 * are set to be nonblocking.
1027 * This will set FD_CLOEXEC for the sockets returned.
1029 * @oaram fds the file descriptors
1030 * @param error return location for errors
1031 * @returns the number of file descriptors
1034 _dbus_listen_systemd_sockets (int **fds,
1041 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1043 n = sd_listen_fds (TRUE);
1046 dbus_set_error (error, _dbus_error_from_errno (-n),
1047 "Failed to acquire systemd socket: %s",
1048 _dbus_strerror (-n));
1054 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
1055 "No socket received.");
1059 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1061 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1064 dbus_set_error (error, _dbus_error_from_errno (-r),
1065 "Failed to verify systemd socket type: %s",
1066 _dbus_strerror (-r));
1072 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
1073 "Passed socket has wrong type.");
1078 /* OK, the file descriptors are all good, so let's take posession of
1081 new_fds = dbus_new (int, n);
1084 dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
1085 "Failed to allocate file handle array.");
1089 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1091 if (!_dbus_set_local_creds (fd, TRUE))
1093 dbus_set_error (error, _dbus_error_from_errno (errno),
1094 "Failed to enable LOCAL_CREDS on systemd socket: %s",
1095 _dbus_strerror (errno));
1099 if (!_dbus_set_fd_nonblocking (fd, error))
1101 _DBUS_ASSERT_ERROR_IS_SET (error);
1105 new_fds[fd - SD_LISTEN_FDS_START] = fd;
1113 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1115 _dbus_close (fd, NULL);
1118 dbus_free (new_fds);
1123 * Creates a socket and connects to a socket at the given host
1124 * and port. The connection fd is returned, and is set up as
1127 * This will set FD_CLOEXEC for the socket returned
1129 * @param host the host name to connect to
1130 * @param port the port to connect to
1131 * @param family the address family to listen on, NULL for all
1132 * @param error return location for error code
1133 * @returns connection file descriptor or -1 on error
1136 _dbus_connect_tcp_socket (const char *host,
1141 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (const char*)NULL, error);
1145 _dbus_connect_tcp_socket_with_nonce (const char *host,
1148 const char *noncefile,
1151 int saved_errno = 0;
1153 struct addrinfo hints;
1154 struct addrinfo *ai, *tmp;
1156 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1158 if (!_dbus_open_tcp_socket (&fd, error))
1160 _DBUS_ASSERT_ERROR_IS_SET(error);
1164 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1169 hints.ai_family = AF_UNSPEC;
1170 else if (!strcmp(family, "ipv4"))
1171 hints.ai_family = AF_INET;
1172 else if (!strcmp(family, "ipv6"))
1173 hints.ai_family = AF_INET6;
1176 dbus_set_error (error,
1177 DBUS_ERROR_BAD_ADDRESS,
1178 "Unknown address family %s", family);
1181 hints.ai_protocol = IPPROTO_TCP;
1182 hints.ai_socktype = SOCK_STREAM;
1183 hints.ai_flags = AI_ADDRCONFIG;
1185 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1187 dbus_set_error (error,
1188 _dbus_error_from_errno (errno),
1189 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1190 host, port, gai_strerror(res), res);
1191 _dbus_close (fd, NULL);
1198 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1201 _DBUS_ASSERT_ERROR_IS_SET(error);
1204 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1206 if (connect (fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1208 saved_errno = errno;
1209 _dbus_close(fd, NULL);
1221 dbus_set_error (error,
1222 _dbus_error_from_errno (saved_errno),
1223 "Failed to connect to socket \"%s:%s\" %s",
1224 host, port, _dbus_strerror(saved_errno));
1228 if (noncefile != NULL)
1230 DBusString noncefileStr;
1232 _dbus_string_init_const (&noncefileStr, noncefile);
1233 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1234 _dbus_string_free (&noncefileStr);
1238 _dbus_close (fd, NULL);
1243 if (!_dbus_set_fd_nonblocking (fd, error))
1245 _dbus_close (fd, NULL);
1253 * Creates a socket and binds it to the given path, then listens on
1254 * the socket. The socket is set to be nonblocking. In case of port=0
1255 * a random free port is used and returned in the port parameter.
1256 * If inaddr_any is specified, the hostname is ignored.
1258 * This will set FD_CLOEXEC for the socket returned
1260 * @param host the host name to listen on
1261 * @param port the port to listen on, if zero a free port will be used
1262 * @param family the address family to listen on, NULL for all
1263 * @param retport string to return the actual port listened on
1264 * @param fds_p location to store returned file descriptors
1265 * @param error return location for errors
1266 * @returns the number of listening file descriptors or -1 on error
1269 _dbus_listen_tcp_socket (const char *host,
1272 DBusString *retport,
1277 int nlisten_fd = 0, *listen_fd = NULL, res, i;
1278 struct addrinfo hints;
1279 struct addrinfo *ai, *tmp;
1282 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1287 hints.ai_family = AF_UNSPEC;
1288 else if (!strcmp(family, "ipv4"))
1289 hints.ai_family = AF_INET;
1290 else if (!strcmp(family, "ipv6"))
1291 hints.ai_family = AF_INET6;
1294 dbus_set_error (error,
1295 DBUS_ERROR_BAD_ADDRESS,
1296 "Unknown address family %s", family);
1300 hints.ai_protocol = IPPROTO_TCP;
1301 hints.ai_socktype = SOCK_STREAM;
1302 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1304 redo_lookup_with_port:
1305 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1307 dbus_set_error (error,
1308 _dbus_error_from_errno (errno),
1309 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1310 host ? host : "*", port, gai_strerror(res), res);
1317 int fd = -1, *newlisten_fd;
1318 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1320 _DBUS_ASSERT_ERROR_IS_SET(error);
1323 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1325 if (bind (fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1327 saved_errno = errno;
1328 _dbus_close(fd, NULL);
1329 if (saved_errno == EADDRINUSE)
1331 /* Depending on kernel policy, it may or may not
1332 be neccessary to bind to both IPv4 & 6 addresses
1333 so ignore EADDRINUSE here */
1337 dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1338 "Failed to bind socket \"%s:%s\": %s",
1339 host ? host : "*", port, _dbus_strerror (saved_errno));
1343 if (listen (fd, 30 /* backlog */) < 0)
1345 saved_errno = errno;
1346 _dbus_close (fd, NULL);
1347 dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1348 "Failed to listen on socket \"%s:%s\": %s",
1349 host ? host : "*", port, _dbus_strerror (saved_errno));
1353 newlisten_fd = dbus_realloc(listen_fd, sizeof(int)*(nlisten_fd+1));
1356 saved_errno = errno;
1357 _dbus_close (fd, NULL);
1358 dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1359 "Failed to allocate file handle array: %s",
1360 _dbus_strerror (saved_errno));
1363 listen_fd = newlisten_fd;
1364 listen_fd[nlisten_fd] = fd;
1367 if (!_dbus_string_get_length(retport))
1369 /* If the user didn't specify a port, or used 0, then
1370 the kernel chooses a port. After the first address
1371 is bound to, we need to force all remaining addresses
1372 to use the same port */
1373 if (!port || !strcmp(port, "0"))
1375 struct sockaddr_storage addr;
1379 addrlen = sizeof(addr);
1380 getsockname(fd, (struct sockaddr*) &addr, &addrlen);
1382 if ((res = getnameinfo((struct sockaddr*)&addr, addrlen, NULL, 0,
1383 portbuf, sizeof(portbuf),
1384 NI_NUMERICHOST)) != 0)
1386 dbus_set_error (error, _dbus_error_from_errno (errno),
1387 "Failed to resolve port \"%s:%s\": %s (%s)",
1388 host ? host : "*", port, gai_strerror(res), res);
1391 if (!_dbus_string_append(retport, portbuf))
1393 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1397 /* Release current address list & redo lookup */
1398 port = _dbus_string_get_const_data(retport);
1400 goto redo_lookup_with_port;
1404 if (!_dbus_string_append(retport, port))
1406 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1420 dbus_set_error (error, _dbus_error_from_errno (errno),
1421 "Failed to bind socket \"%s:%s\": %s",
1422 host ? host : "*", port, _dbus_strerror (errno));
1426 for (i = 0 ; i < nlisten_fd ; i++)
1428 if (!_dbus_set_fd_nonblocking (listen_fd[i], error))
1441 for (i = 0 ; i < nlisten_fd ; i++)
1442 _dbus_close(listen_fd[i], NULL);
1443 dbus_free(listen_fd);
1448 write_credentials_byte (int server_fd,
1452 char buf[1] = { '\0' };
1453 #if defined(HAVE_CMSGCRED)
1456 char cred[CMSG_SPACE (sizeof (struct cmsgcred))];
1467 msg.msg_control = (caddr_t) &cmsg;
1468 msg.msg_controllen = CMSG_SPACE (sizeof (struct cmsgcred));
1470 cmsg.hdr.cmsg_len = CMSG_LEN (sizeof (struct cmsgcred));
1471 cmsg.hdr.cmsg_level = SOL_SOCKET;
1472 cmsg.hdr.cmsg_type = SCM_CREDS;
1475 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1479 #if defined(HAVE_CMSGCRED)
1480 bytes_written = sendmsg (server_fd, &msg, 0);
1482 bytes_written = write (server_fd, buf, 1);
1485 if (bytes_written < 0 && errno == EINTR)
1488 if (bytes_written < 0)
1490 dbus_set_error (error, _dbus_error_from_errno (errno),
1491 "Failed to write credentials byte: %s",
1492 _dbus_strerror (errno));
1495 else if (bytes_written == 0)
1497 dbus_set_error (error, DBUS_ERROR_IO_ERROR,
1498 "wrote zero bytes writing credentials byte");
1503 _dbus_assert (bytes_written == 1);
1504 _dbus_verbose ("wrote credentials byte\n");
1510 * Reads a single byte which must be nul (an error occurs otherwise),
1511 * and reads unix credentials if available. Clears the credentials
1512 * object, then adds pid/uid if available, so any previous credentials
1513 * stored in the object are lost.
1515 * Return value indicates whether a byte was read, not whether
1516 * we got valid credentials. On some systems, such as Linux,
1517 * reading/writing the byte isn't actually required, but we do it
1518 * anyway just to avoid multiple codepaths.
1520 * Fails if no byte is available, so you must select() first.
1522 * The point of the byte is that on some systems we have to
1523 * use sendmsg()/recvmsg() to transmit credentials.
1525 * @param client_fd the client file descriptor
1526 * @param credentials object to add client credentials to
1527 * @param error location to store error code
1528 * @returns #TRUE on success
1531 _dbus_read_credentials_socket (int client_fd,
1532 DBusCredentials *credentials,
1538 dbus_uid_t uid_read;
1539 dbus_pid_t pid_read;
1542 #ifdef HAVE_CMSGCRED
1545 char cred[CMSG_SPACE (sizeof (struct cmsgcred))];
1548 #elif defined(LOCAL_CREDS)
1551 struct sockcred cred;
1555 uid_read = DBUS_UID_UNSET;
1556 pid_read = DBUS_PID_UNSET;
1558 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1560 /* The POSIX spec certainly doesn't promise this, but
1561 * we need these assertions to fail as soon as we're wrong about
1562 * it so we can do the porting fixups
1564 _dbus_assert (sizeof (pid_t) <= sizeof (dbus_pid_t));
1565 _dbus_assert (sizeof (uid_t) <= sizeof (dbus_uid_t));
1566 _dbus_assert (sizeof (gid_t) <= sizeof (dbus_gid_t));
1568 _dbus_credentials_clear (credentials);
1570 /* Systems supporting LOCAL_CREDS are configured to have this feature
1571 * enabled (if it does not conflict with HAVE_CMSGCRED) prior accepting
1572 * the connection. Therefore, the received message must carry the
1573 * credentials information without doing anything special.
1576 iov.iov_base = &buf;
1583 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
1585 msg.msg_control = (caddr_t) &cmsg;
1586 msg.msg_controllen = CMSG_SPACE (sizeof (struct cmsgcred));
1590 bytes_read = recvmsg (client_fd, &msg, 0);
1597 /* EAGAIN or EWOULDBLOCK would be unexpected here since we would
1598 * normally only call read_credentials if the socket was ready
1602 dbus_set_error (error, _dbus_error_from_errno (errno),
1603 "Failed to read credentials byte: %s",
1604 _dbus_strerror (errno));
1607 else if (bytes_read == 0)
1609 /* this should not happen unless we are using recvmsg wrong,
1610 * so is essentially here for paranoia
1612 dbus_set_error (error, DBUS_ERROR_FAILED,
1613 "Failed to read credentials byte (zero-length read)");
1616 else if (buf != '\0')
1618 dbus_set_error (error, DBUS_ERROR_FAILED,
1619 "Credentials byte was not nul");
1623 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
1624 if (cmsg.hdr.cmsg_len < CMSG_LEN (sizeof (struct cmsgcred))
1625 || cmsg.hdr.cmsg_type != SCM_CREDS)
1627 dbus_set_error (error, DBUS_ERROR_FAILED,
1628 "Message from recvmsg() was not SCM_CREDS");
1633 _dbus_verbose ("read credentials byte\n");
1638 int cr_len = sizeof (cr);
1640 if (getsockopt (client_fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) == 0 &&
1641 cr_len == sizeof (cr))
1648 _dbus_verbose ("Failed to getsockopt() credentials, returned len %d/%d: %s\n",
1649 cr_len, (int) sizeof (cr), _dbus_strerror (errno));
1651 #elif defined(HAVE_CMSGCRED)
1652 struct cmsgcred *cred;
1654 cred = (struct cmsgcred *) CMSG_DATA (&cmsg.hdr);
1655 pid_read = cred->cmcred_pid;
1656 uid_read = cred->cmcred_euid;
1657 #elif defined(LOCAL_CREDS)
1658 pid_read = DBUS_PID_UNSET;
1659 uid_read = cmsg.cred.sc_uid;
1660 /* Since we have already got the credentials from this socket, we can
1661 * disable its LOCAL_CREDS flag if it was ever set. */
1662 _dbus_set_local_creds (client_fd, FALSE);
1663 #elif defined(HAVE_GETPEEREID)
1666 if (getpeereid (client_fd, &euid, &egid) == 0)
1672 _dbus_verbose ("Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
1674 #elif defined(HAVE_GETPEERUCRED)
1675 ucred_t * ucred = NULL;
1676 if (getpeerucred (client_fd, &ucred) == 0)
1678 pid_read = ucred_getpid (ucred);
1679 uid_read = ucred_geteuid (ucred);
1681 /* generate audit session data based on socket ucred */
1682 adt_session_data_t *adth = NULL;
1683 adt_export_data_t *data = NULL;
1685 if (adt_start_session (&adth, NULL, 0) || (adth == NULL))
1687 _dbus_verbose ("Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
1691 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
1693 _dbus_verbose ("Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
1697 size = adt_export_session_data (adth, &data);
1700 _dbus_verbose ("Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
1704 _dbus_credentials_add_adt_audit_data (credentials, data, size);
1708 (void) adt_end_session (adth);
1710 #endif /* HAVE_ADT */
1714 _dbus_verbose ("Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
1718 #else /* !SO_PEERCRED && !HAVE_CMSGCRED && !HAVE_GETPEEREID && !HAVE_GETPEERUCRED */
1719 _dbus_verbose ("Socket credentials not supported on this OS\n");
1723 _dbus_verbose ("Credentials:"
1724 " pid "DBUS_PID_FORMAT
1725 " uid "DBUS_UID_FORMAT
1730 if (pid_read != DBUS_PID_UNSET)
1732 if (!_dbus_credentials_add_unix_pid (credentials, pid_read))
1734 _DBUS_SET_OOM (error);
1739 if (uid_read != DBUS_UID_UNSET)
1741 if (!_dbus_credentials_add_unix_uid (credentials, uid_read))
1743 _DBUS_SET_OOM (error);
1752 * Sends a single nul byte with our UNIX credentials as ancillary
1753 * data. Returns #TRUE if the data was successfully written. On
1754 * systems that don't support sending credentials, just writes a byte,
1755 * doesn't send any credentials. On some systems, such as Linux,
1756 * reading/writing the byte isn't actually required, but we do it
1757 * anyway just to avoid multiple codepaths.
1759 * Fails if no byte can be written, so you must select() first.
1761 * The point of the byte is that on some systems we have to
1762 * use sendmsg()/recvmsg() to transmit credentials.
1764 * @param server_fd file descriptor for connection to server
1765 * @param error return location for error code
1766 * @returns #TRUE if the byte was sent
1769 _dbus_send_credentials_socket (int server_fd,
1772 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1774 if (write_credentials_byte (server_fd, error))
1781 * Accepts a connection on a listening socket.
1782 * Handles EINTR for you.
1784 * This will enable FD_CLOEXEC for the returned socket.
1786 * @param listen_fd the listen file descriptor
1787 * @returns the connection fd of the client, or -1 on error
1790 _dbus_accept (int listen_fd)
1793 struct sockaddr addr;
1796 dbus_bool_t cloexec_done;
1799 addrlen = sizeof (addr);
1804 /* We assume that if accept4 is available SOCK_CLOEXEC is too */
1805 client_fd = accept4 (listen_fd, &addr, &addrlen, SOCK_CLOEXEC);
1806 cloexec_done = client_fd >= 0;
1808 if (client_fd < 0 && errno == ENOSYS)
1811 client_fd = accept (listen_fd, &addr, &addrlen);
1820 _dbus_verbose ("client fd %d accepted\n", client_fd);
1826 _dbus_fd_set_close_on_exec(client_fd);
1833 * Checks to make sure the given directory is
1834 * private to the user
1836 * @param dir the name of the directory
1837 * @param error error return
1838 * @returns #FALSE on failure
1841 _dbus_check_dir_is_private_to_user (DBusString *dir, DBusError *error)
1843 const char *directory;
1846 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1848 directory = _dbus_string_get_const_data (dir);
1850 if (stat (directory, &sb) < 0)
1852 dbus_set_error (error, _dbus_error_from_errno (errno),
1853 "%s", _dbus_strerror (errno));
1858 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
1859 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
1861 dbus_set_error (error, DBUS_ERROR_FAILED,
1862 "%s directory is not private to the user", directory);
1870 fill_user_info_from_passwd (struct passwd *p,
1874 _dbus_assert (p->pw_name != NULL);
1875 _dbus_assert (p->pw_dir != NULL);
1877 info->uid = p->pw_uid;
1878 info->primary_gid = p->pw_gid;
1879 info->username = _dbus_strdup (p->pw_name);
1880 info->homedir = _dbus_strdup (p->pw_dir);
1882 if (info->username == NULL ||
1883 info->homedir == NULL)
1885 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1893 fill_user_info (DBusUserInfo *info,
1895 const DBusString *username,
1898 const char *username_c;
1900 /* exactly one of username/uid provided */
1901 _dbus_assert (username != NULL || uid != DBUS_UID_UNSET);
1902 _dbus_assert (username == NULL || uid == DBUS_UID_UNSET);
1904 info->uid = DBUS_UID_UNSET;
1905 info->primary_gid = DBUS_GID_UNSET;
1906 info->group_ids = NULL;
1907 info->n_group_ids = 0;
1908 info->username = NULL;
1909 info->homedir = NULL;
1911 if (username != NULL)
1912 username_c = _dbus_string_get_const_data (username);
1916 /* For now assuming that the getpwnam() and getpwuid() flavors
1917 * are always symmetrical, if not we have to add more configure
1921 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
1927 struct passwd p_str;
1929 /* retrieve maximum needed size for buf */
1930 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
1932 /* sysconf actually returns a long, but everything else expects size_t,
1933 * so just recast here.
1934 * https://bugs.freedesktop.org/show_bug.cgi?id=17061
1936 if ((long) buflen <= 0)
1942 buf = dbus_malloc (buflen);
1945 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1950 #ifdef HAVE_POSIX_GETPWNAM_R
1951 if (uid != DBUS_UID_UNSET)
1952 result = getpwuid_r (uid, &p_str, buf, buflen,
1955 result = getpwnam_r (username_c, &p_str, buf, buflen,
1958 if (uid != DBUS_UID_UNSET)
1959 p = getpwuid_r (uid, &p_str, buf, buflen);
1961 p = getpwnam_r (username_c, &p_str, buf, buflen);
1963 #endif /* !HAVE_POSIX_GETPWNAM_R */
1964 //Try a bigger buffer if ERANGE was returned
1965 if (result == ERANGE && buflen < 512 * 1024)
1975 if (result == 0 && p == &p_str)
1977 if (!fill_user_info_from_passwd (p, info, error))
1986 dbus_set_error (error, _dbus_error_from_errno (errno),
1987 "User \"%s\" unknown or no memory to allocate password entry\n",
1988 username_c ? username_c : "???");
1989 _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
1994 #else /* ! HAVE_GETPWNAM_R */
1996 /* I guess we're screwed on thread safety here */
1999 if (uid != DBUS_UID_UNSET)
2002 p = getpwnam (username_c);
2006 if (!fill_user_info_from_passwd (p, info, error))
2013 dbus_set_error (error, _dbus_error_from_errno (errno),
2014 "User \"%s\" unknown or no memory to allocate password entry\n",
2015 username_c ? username_c : "???");
2016 _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
2020 #endif /* ! HAVE_GETPWNAM_R */
2022 /* Fill this in so we can use it to get groups */
2023 username_c = info->username;
2025 #ifdef HAVE_GETGROUPLIST
2030 int initial_buf_count;
2032 initial_buf_count = 17;
2033 buf_count = initial_buf_count;
2034 buf = dbus_new (gid_t, buf_count);
2037 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2041 if (getgrouplist (username_c,
2043 buf, &buf_count) < 0)
2046 /* Presumed cause of negative return code: buf has insufficient
2047 entries to hold the entire group list. The Linux behavior in this
2048 case is to pass back the actual number of groups in buf_count, but
2049 on Mac OS X 10.5, buf_count is unhelpfully left alone.
2050 So as a hack, try to help out a bit by guessing a larger
2051 number of groups, within reason.. might still fail, of course,
2052 but we can at least print a more informative message. I looked up
2053 the "right way" to do this by downloading Apple's own source code
2054 for the "id" command, and it turns out that they use an
2055 undocumented library function getgrouplist_2 (!) which is not
2056 declared in any header in /usr/include (!!). That did not seem
2057 like the way to go here.
2059 if (buf_count == initial_buf_count)
2061 buf_count *= 16; /* Retry with an arbitrarily scaled-up array */
2063 new = dbus_realloc (buf, buf_count * sizeof (buf[0]));
2066 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2074 if (getgrouplist (username_c, info->primary_gid, buf, &buf_count) < 0)
2078 _dbus_warn ("It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2079 username_c, buf_count, buf_count);
2083 dbus_set_error (error,
2084 _dbus_error_from_errno (errno),
2085 "Failed to get groups for username \"%s\" primary GID "
2086 DBUS_GID_FORMAT ": %s\n",
2087 username_c, info->primary_gid,
2088 _dbus_strerror (errno));
2095 info->group_ids = dbus_new (dbus_gid_t, buf_count);
2096 if (info->group_ids == NULL)
2098 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2103 for (i = 0; i < buf_count; ++i)
2104 info->group_ids[i] = buf[i];
2106 info->n_group_ids = buf_count;
2110 #else /* HAVE_GETGROUPLIST */
2112 /* We just get the one group ID */
2113 info->group_ids = dbus_new (dbus_gid_t, 1);
2114 if (info->group_ids == NULL)
2116 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2120 info->n_group_ids = 1;
2122 (info->group_ids)[0] = info->primary_gid;
2124 #endif /* HAVE_GETGROUPLIST */
2126 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2131 _DBUS_ASSERT_ERROR_IS_SET (error);
2136 * Gets user info for the given username.
2138 * @param info user info object to initialize
2139 * @param username the username
2140 * @param error error return
2141 * @returns #TRUE on success
2144 _dbus_user_info_fill (DBusUserInfo *info,
2145 const DBusString *username,
2148 return fill_user_info (info, DBUS_UID_UNSET,
2153 * Gets user info for the given user ID.
2155 * @param info user info object to initialize
2156 * @param uid the user ID
2157 * @param error error return
2158 * @returns #TRUE on success
2161 _dbus_user_info_fill_uid (DBusUserInfo *info,
2165 return fill_user_info (info, uid,
2170 * Adds the credentials of the current process to the
2171 * passed-in credentials object.
2173 * @param credentials credentials to add to
2174 * @returns #FALSE if no memory; does not properly roll back on failure, so only some credentials may have been added
2177 _dbus_credentials_add_from_current_process (DBusCredentials *credentials)
2179 /* The POSIX spec certainly doesn't promise this, but
2180 * we need these assertions to fail as soon as we're wrong about
2181 * it so we can do the porting fixups
2183 _dbus_assert (sizeof (pid_t) <= sizeof (dbus_pid_t));
2184 _dbus_assert (sizeof (uid_t) <= sizeof (dbus_uid_t));
2185 _dbus_assert (sizeof (gid_t) <= sizeof (dbus_gid_t));
2187 if (!_dbus_credentials_add_unix_pid(credentials, _dbus_getpid()))
2189 if (!_dbus_credentials_add_unix_uid(credentials, _dbus_geteuid()))
2196 * Append to the string the identity we would like to have when we
2197 * authenticate, on UNIX this is the current process UID and on
2198 * Windows something else, probably a Windows SID string. No escaping
2199 * is required, that is done in dbus-auth.c. The username here
2200 * need not be anything human-readable, it can be the machine-readable
2201 * form i.e. a user id.
2203 * @param str the string to append to
2204 * @returns #FALSE on no memory
2207 _dbus_append_user_from_current_process (DBusString *str)
2209 return _dbus_string_append_uint (str,
2214 * Gets our process ID
2215 * @returns process ID
2224 * @returns process UID
2232 /** Gets our effective UID
2233 * @returns process effective UID
2236 _dbus_geteuid (void)
2242 * The only reason this is separate from _dbus_getpid() is to allow it
2243 * on Windows for logging but not for other purposes.
2245 * @returns process ID to put in log messages
2248 _dbus_pid_for_log (void)
2254 * Gets a UID from a UID string.
2256 * @param uid_str the UID in string form
2257 * @param uid UID to fill in
2258 * @returns #TRUE if successfully filled in UID
2261 _dbus_parse_uid (const DBusString *uid_str,
2267 if (_dbus_string_get_length (uid_str) == 0)
2269 _dbus_verbose ("UID string was zero length\n");
2275 if (!_dbus_string_parse_int (uid_str, 0, &val,
2278 _dbus_verbose ("could not parse string as a UID\n");
2282 if (end != _dbus_string_get_length (uid_str))
2284 _dbus_verbose ("string contained trailing stuff after UID\n");
2294 _DBUS_DEFINE_GLOBAL_LOCK (atomic);
2298 * Atomically increments an integer
2300 * @param atomic pointer to the integer to increment
2301 * @returns the value before incrementing
2304 _dbus_atomic_inc (DBusAtomic *atomic)
2307 return __sync_add_and_fetch(&atomic->value, 1)-1;
2310 _DBUS_LOCK (atomic);
2311 res = atomic->value;
2313 _DBUS_UNLOCK (atomic);
2319 * Atomically decrement an integer
2321 * @param atomic pointer to the integer to decrement
2322 * @returns the value before decrementing
2325 _dbus_atomic_dec (DBusAtomic *atomic)
2328 return __sync_sub_and_fetch(&atomic->value, 1)+1;
2332 _DBUS_LOCK (atomic);
2333 res = atomic->value;
2335 _DBUS_UNLOCK (atomic);
2340 #ifdef DBUS_BUILD_TESTS
2342 * @returns process GID
2352 * Wrapper for poll().
2354 * @param fds the file descriptors to poll
2355 * @param n_fds number of descriptors in the array
2356 * @param timeout_milliseconds timeout or -1 for infinite
2357 * @returns numbers of fds with revents, or <0 on error
2360 _dbus_poll (DBusPollFD *fds,
2362 int timeout_milliseconds)
2364 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
2365 /* This big thing is a constant expression and should get optimized
2366 * out of existence. So it's more robust than a configure check at
2369 if (_DBUS_POLLIN == POLLIN &&
2370 _DBUS_POLLPRI == POLLPRI &&
2371 _DBUS_POLLOUT == POLLOUT &&
2372 _DBUS_POLLERR == POLLERR &&
2373 _DBUS_POLLHUP == POLLHUP &&
2374 _DBUS_POLLNVAL == POLLNVAL &&
2375 sizeof (DBusPollFD) == sizeof (struct pollfd) &&
2376 _DBUS_STRUCT_OFFSET (DBusPollFD, fd) ==
2377 _DBUS_STRUCT_OFFSET (struct pollfd, fd) &&
2378 _DBUS_STRUCT_OFFSET (DBusPollFD, events) ==
2379 _DBUS_STRUCT_OFFSET (struct pollfd, events) &&
2380 _DBUS_STRUCT_OFFSET (DBusPollFD, revents) ==
2381 _DBUS_STRUCT_OFFSET (struct pollfd, revents))
2383 return poll ((struct pollfd*) fds,
2385 timeout_milliseconds);
2389 /* We have to convert the DBusPollFD to an array of
2390 * struct pollfd, poll, and convert back.
2392 _dbus_warn ("didn't implement poll() properly for this system yet\n");
2395 #else /* ! HAVE_POLL */
2397 fd_set read_set, write_set, err_set;
2403 FD_ZERO (&read_set);
2404 FD_ZERO (&write_set);
2407 for (i = 0; i < n_fds; i++)
2409 DBusPollFD *fdp = &fds[i];
2411 if (fdp->events & _DBUS_POLLIN)
2412 FD_SET (fdp->fd, &read_set);
2414 if (fdp->events & _DBUS_POLLOUT)
2415 FD_SET (fdp->fd, &write_set);
2417 FD_SET (fdp->fd, &err_set);
2419 max_fd = MAX (max_fd, fdp->fd);
2422 tv.tv_sec = timeout_milliseconds / 1000;
2423 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
2425 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
2426 timeout_milliseconds < 0 ? NULL : &tv);
2430 for (i = 0; i < n_fds; i++)
2432 DBusPollFD *fdp = &fds[i];
2436 if (FD_ISSET (fdp->fd, &read_set))
2437 fdp->revents |= _DBUS_POLLIN;
2439 if (FD_ISSET (fdp->fd, &write_set))
2440 fdp->revents |= _DBUS_POLLOUT;
2442 if (FD_ISSET (fdp->fd, &err_set))
2443 fdp->revents |= _DBUS_POLLERR;
2452 * Get current time, as in gettimeofday(). Use the monotonic clock if
2453 * available, to avoid problems when the system time changes.
2455 * @param tv_sec return location for number of seconds
2456 * @param tv_usec return location for number of microseconds (thousandths)
2459 _dbus_get_current_time (long *tv_sec,
2464 #ifdef HAVE_MONOTONIC_CLOCK
2466 clock_gettime (CLOCK_MONOTONIC, &ts);
2469 *tv_sec = ts.tv_sec;
2471 *tv_usec = ts.tv_nsec / 1000;
2473 gettimeofday (&t, NULL);
2478 *tv_usec = t.tv_usec;
2483 * Creates a directory; succeeds if the directory
2484 * is created or already existed.
2486 * @param filename directory filename
2487 * @param error initialized error object
2488 * @returns #TRUE on success
2491 _dbus_create_directory (const DBusString *filename,
2494 const char *filename_c;
2496 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2498 filename_c = _dbus_string_get_const_data (filename);
2500 if (mkdir (filename_c, 0700) < 0)
2502 if (errno == EEXIST)
2505 dbus_set_error (error, DBUS_ERROR_FAILED,
2506 "Failed to create directory %s: %s\n",
2507 filename_c, _dbus_strerror (errno));
2515 * Appends the given filename to the given directory.
2517 * @todo it might be cute to collapse multiple '/' such as "foo//"
2520 * @param dir the directory name
2521 * @param next_component the filename
2522 * @returns #TRUE on success
2525 _dbus_concat_dir_and_file (DBusString *dir,
2526 const DBusString *next_component)
2528 dbus_bool_t dir_ends_in_slash;
2529 dbus_bool_t file_starts_with_slash;
2531 if (_dbus_string_get_length (dir) == 0 ||
2532 _dbus_string_get_length (next_component) == 0)
2535 dir_ends_in_slash = '/' == _dbus_string_get_byte (dir,
2536 _dbus_string_get_length (dir) - 1);
2538 file_starts_with_slash = '/' == _dbus_string_get_byte (next_component, 0);
2540 if (dir_ends_in_slash && file_starts_with_slash)
2542 _dbus_string_shorten (dir, 1);
2544 else if (!(dir_ends_in_slash || file_starts_with_slash))
2546 if (!_dbus_string_append_byte (dir, '/'))
2550 return _dbus_string_copy (next_component, 0, dir,
2551 _dbus_string_get_length (dir));
2554 /** nanoseconds in a second */
2555 #define NANOSECONDS_PER_SECOND 1000000000
2556 /** microseconds in a second */
2557 #define MICROSECONDS_PER_SECOND 1000000
2558 /** milliseconds in a second */
2559 #define MILLISECONDS_PER_SECOND 1000
2560 /** nanoseconds in a millisecond */
2561 #define NANOSECONDS_PER_MILLISECOND 1000000
2562 /** microseconds in a millisecond */
2563 #define MICROSECONDS_PER_MILLISECOND 1000
2566 * Sleeps the given number of milliseconds.
2567 * @param milliseconds number of milliseconds
2570 _dbus_sleep_milliseconds (int milliseconds)
2572 #ifdef HAVE_NANOSLEEP
2573 struct timespec req;
2574 struct timespec rem;
2576 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
2577 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
2581 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
2583 #elif defined (HAVE_USLEEP)
2584 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
2585 #else /* ! HAVE_USLEEP */
2586 sleep (MAX (milliseconds / 1000, 1));
2591 _dbus_generate_pseudorandom_bytes (DBusString *str,
2597 old_len = _dbus_string_get_length (str);
2599 if (!_dbus_string_lengthen (str, n_bytes))
2602 p = _dbus_string_get_data_len (str, old_len, n_bytes);
2604 _dbus_generate_pseudorandom_bytes_buffer (p, n_bytes);
2610 * Generates the given number of random bytes,
2611 * using the best mechanism we can come up with.
2613 * @param str the string
2614 * @param n_bytes the number of random bytes to append to string
2615 * @returns #TRUE on success, #FALSE if no memory
2618 _dbus_generate_random_bytes (DBusString *str,
2624 /* FALSE return means "no memory", if it could
2625 * mean something else then we'd need to return
2626 * a DBusError. So we always fall back to pseudorandom
2630 old_len = _dbus_string_get_length (str);
2633 /* note, urandom on linux will fall back to pseudorandom */
2634 fd = open ("/dev/urandom", O_RDONLY);
2636 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2638 _dbus_verbose ("/dev/urandom fd %d opened\n", fd);
2640 if (_dbus_read (fd, str, n_bytes) != n_bytes)
2642 _dbus_close (fd, NULL);
2643 _dbus_string_set_length (str, old_len);
2644 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2647 _dbus_verbose ("Read %d bytes from /dev/urandom\n",
2650 _dbus_close (fd, NULL);
2656 * Exit the process, returning the given value.
2658 * @param code the exit code
2661 _dbus_exit (int code)
2667 * A wrapper around strerror() because some platforms
2668 * may be lame and not have strerror(). Also, never
2671 * @param error_number errno.
2672 * @returns error description.
2675 _dbus_strerror (int error_number)
2679 msg = strerror (error_number);
2687 * signal (SIGPIPE, SIG_IGN);
2690 _dbus_disable_sigpipe (void)
2692 signal (SIGPIPE, SIG_IGN);
2696 * Sets the file descriptor to be close
2697 * on exec. Should be called for all file
2698 * descriptors in D-Bus code.
2700 * @param fd the file descriptor
2703 _dbus_fd_set_close_on_exec (intptr_t fd)
2707 val = fcntl (fd, F_GETFD, 0);
2714 fcntl (fd, F_SETFD, val);
2718 * Closes a file descriptor.
2720 * @param fd the file descriptor
2721 * @param error error object
2722 * @returns #FALSE if error set
2725 _dbus_close (int fd,
2728 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2736 dbus_set_error (error, _dbus_error_from_errno (errno),
2737 "Could not close fd %d", fd);
2745 * Duplicates a file descriptor. Makes sure the fd returned is >= 3
2746 * (i.e. avoids stdin/stdout/stderr). Sets O_CLOEXEC.
2748 * @param fd the file descriptor to duplicate
2749 * @returns duplicated file descriptor
2757 #ifdef F_DUPFD_CLOEXEC
2758 dbus_bool_t cloexec_done;
2760 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2761 cloexec_done = new_fd >= 0;
2763 if (new_fd < 0 && errno == EINVAL)
2766 new_fd = fcntl(fd, F_DUPFD, 3);
2771 dbus_set_error (error, _dbus_error_from_errno (errno),
2772 "Could not duplicate fd %d", fd);
2776 #ifdef F_DUPFD_CLOEXEC
2780 _dbus_fd_set_close_on_exec(new_fd);
2787 * Sets a file descriptor to be nonblocking.
2789 * @param fd the file descriptor.
2790 * @param error address of error location.
2791 * @returns #TRUE on success.
2794 _dbus_set_fd_nonblocking (int fd,
2799 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2801 val = fcntl (fd, F_GETFL, 0);
2804 dbus_set_error (error, _dbus_error_from_errno (errno),
2805 "Failed to get flags from file descriptor %d: %s",
2806 fd, _dbus_strerror (errno));
2807 _dbus_verbose ("Failed to get flags for fd %d: %s\n", fd,
2808 _dbus_strerror (errno));
2812 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
2814 dbus_set_error (error, _dbus_error_from_errno (errno),
2815 "Failed to set nonblocking flag of file descriptor %d: %s",
2816 fd, _dbus_strerror (errno));
2817 _dbus_verbose ("Failed to set fd %d nonblocking: %s\n",
2818 fd, _dbus_strerror (errno));
2827 * On GNU libc systems, print a crude backtrace to stderr. On other
2828 * systems, print "no backtrace support" and block for possible gdb
2829 * attachment if an appropriate environment variable is set.
2832 _dbus_print_backtrace (void)
2834 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
2840 bt_size = backtrace (bt, 500);
2842 syms = backtrace_symbols (bt, bt_size);
2847 /* don't use dbus_warn since it can _dbus_abort() */
2848 fprintf (stderr, " %s\n", syms[i]);
2854 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
2855 fprintf (stderr, " D-Bus not built with -rdynamic so unable to print a backtrace\n");
2857 fprintf (stderr, " D-Bus not compiled with backtrace support so unable to print a backtrace\n");
2862 * Creates a full-duplex pipe (as in socketpair()).
2863 * Sets both ends of the pipe nonblocking.
2865 * Marks both file descriptors as close-on-exec
2867 * @todo libdbus only uses this for the debug-pipe server, so in
2868 * principle it could be in dbus-sysdeps-util.c, except that
2869 * dbus-sysdeps-util.c isn't in libdbus when tests are enabled and the
2870 * debug-pipe server is used.
2872 * @param fd1 return location for one end
2873 * @param fd2 return location for the other end
2874 * @param blocking #TRUE if pipe should be blocking
2875 * @param error error return
2876 * @returns #FALSE on failure (if error is set)
2879 _dbus_full_duplex_pipe (int *fd1,
2881 dbus_bool_t blocking,
2884 #ifdef HAVE_SOCKETPAIR
2889 dbus_bool_t cloexec_done;
2891 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
2892 cloexec_done = retval >= 0;
2894 if (retval < 0 && errno == EINVAL)
2897 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
2902 dbus_set_error (error, _dbus_error_from_errno (errno),
2903 "Could not create full-duplex pipe");
2907 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2913 _dbus_fd_set_close_on_exec (fds[0]);
2914 _dbus_fd_set_close_on_exec (fds[1]);
2918 (!_dbus_set_fd_nonblocking (fds[0], NULL) ||
2919 !_dbus_set_fd_nonblocking (fds[1], NULL)))
2921 dbus_set_error (error, _dbus_error_from_errno (errno),
2922 "Could not set full-duplex pipe nonblocking");
2924 _dbus_close (fds[0], NULL);
2925 _dbus_close (fds[1], NULL);
2933 _dbus_verbose ("full-duplex pipe %d <-> %d\n",
2938 _dbus_warn ("_dbus_full_duplex_pipe() not implemented on this OS\n");
2939 dbus_set_error (error, DBUS_ERROR_FAILED,
2940 "_dbus_full_duplex_pipe() not implemented on this OS");
2946 * Measure the length of the given format string and arguments,
2947 * not including the terminating nul.
2949 * @param format a printf-style format string
2950 * @param args arguments for the format string
2951 * @returns length of the given format string and args
2954 _dbus_printf_string_upper_bound (const char *format,
2958 return vsnprintf (&c, 1, format, args);
2962 * Gets the temporary files directory by inspecting the environment variables
2963 * TMPDIR, TMP, and TEMP in that order. If none of those are set "/tmp" is returned
2965 * @returns location of temp directory
2968 _dbus_get_tmpdir(void)
2970 static const char* tmpdir = NULL;
2974 /* TMPDIR is what glibc uses, then
2975 * glibc falls back to the P_tmpdir macro which
2976 * just expands to "/tmp"
2979 tmpdir = getenv("TMPDIR");
2981 /* These two env variables are probably
2982 * broken, but maybe some OS uses them?
2985 tmpdir = getenv("TMP");
2987 tmpdir = getenv("TEMP");
2989 /* And this is the sane fallback. */
2994 _dbus_assert(tmpdir != NULL);
3000 * Execute a subprocess, returning up to 1024 bytes of output
3003 * If successful, returns #TRUE and appends the output to @p
3004 * result. If a failure happens, returns #FALSE and
3005 * sets an error in @p error.
3007 * @note It's not an error if the subprocess terminates normally
3008 * without writing any data to stdout. Verify the @p result length
3009 * before and after this function call to cover this case.
3011 * @param progname initial path to exec (may or may not be absolute)
3012 * @param path_fallback if %TRUE, search PATH for executable
3013 * @param argv NULL-terminated list of arguments
3014 * @param result a DBusString where the output can be append
3015 * @param error a DBusError to store the error in case of failure
3016 * @returns #TRUE on success, #FALSE if an error happened
3019 _read_subprocess_line_argv (const char *progpath,
3020 dbus_bool_t path_fallback,
3025 int result_pipe[2] = { -1, -1 };
3026 int errors_pipe[2] = { -1, -1 };
3034 sigset_t new_set, old_set;
3036 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3039 /* We need to block any existing handlers for SIGCHLD temporarily; they
3040 * will cause waitpid() below to fail.
3041 * https://bugs.freedesktop.org/show_bug.cgi?id=21347
3043 sigemptyset (&new_set);
3044 sigaddset (&new_set, SIGCHLD);
3045 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3047 orig_len = _dbus_string_get_length (result);
3051 if (pipe (result_pipe) < 0)
3053 dbus_set_error (error, _dbus_error_from_errno (errno),
3054 "Failed to create a pipe to call %s: %s",
3055 progpath, _dbus_strerror (errno));
3056 _dbus_verbose ("Failed to create a pipe to call %s: %s\n",
3057 progpath, _dbus_strerror (errno));
3060 if (pipe (errors_pipe) < 0)
3062 dbus_set_error (error, _dbus_error_from_errno (errno),
3063 "Failed to create a pipe to call %s: %s",
3064 progpath, _dbus_strerror (errno));
3065 _dbus_verbose ("Failed to create a pipe to call %s: %s\n",
3066 progpath, _dbus_strerror (errno));
3073 dbus_set_error (error, _dbus_error_from_errno (errno),
3074 "Failed to fork() to call %s: %s",
3075 progpath, _dbus_strerror (errno));
3076 _dbus_verbose ("Failed to fork() to call %s: %s\n",
3077 progpath, _dbus_strerror (errno));
3087 fd = open ("/dev/null", O_RDWR);
3089 /* huh?! can't open /dev/null? */
3092 _dbus_verbose ("/dev/null fd %d opened\n", fd);
3095 close (result_pipe[READ_END]);
3096 close (errors_pipe[READ_END]);
3097 close (0); /* close stdin */
3098 close (1); /* close stdout */
3099 close (2); /* close stderr */
3101 if (dup2 (fd, 0) == -1)
3103 if (dup2 (result_pipe[WRITE_END], 1) == -1)
3105 if (dup2 (errors_pipe[WRITE_END], 2) == -1)
3108 maxfds = sysconf (_SC_OPEN_MAX);
3109 /* Pick something reasonable if for some reason sysconf
3114 /* close all inherited fds */
3115 for (i = 3; i < maxfds; i++)
3118 sigprocmask (SIG_SETMASK, &old_set, NULL);
3120 /* If it looks fully-qualified, try execv first */
3121 if (progpath[0] == '/')
3123 execv (progpath, argv);
3124 /* Ok, that failed. Now if path_fallback is given, let's
3125 * try unqualified. This is mostly a hack to work
3126 * around systems which ship dbus-launch in /usr/bin
3127 * but everything else in /bin (because dbus-launch
3131 /* We must have a slash, because we checked above */
3132 execvp (strrchr (progpath, '/')+1, argv);
3135 execvp (progpath, argv);
3137 /* still nothing, we failed */
3141 /* parent process */
3142 close (result_pipe[WRITE_END]);
3143 close (errors_pipe[WRITE_END]);
3144 result_pipe[WRITE_END] = -1;
3145 errors_pipe[WRITE_END] = -1;
3150 ret = _dbus_read (result_pipe[READ_END], result, 1024);
3154 /* reap the child process to avoid it lingering as zombie */
3157 ret = waitpid (pid, &status, 0);
3159 while (ret == -1 && errno == EINTR);
3161 /* We succeeded if the process exited with status 0 and
3162 anything was read */
3163 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
3165 /* The process ended with error */
3166 DBusString error_message;
3167 _dbus_string_init (&error_message);
3171 ret = _dbus_read (errors_pipe[READ_END], &error_message, 1024);
3175 _dbus_string_set_length (result, orig_len);
3176 if (_dbus_string_get_length (&error_message) > 0)
3177 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
3178 "%s terminated abnormally with the following error: %s",
3179 progpath, _dbus_string_get_data (&error_message));
3181 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
3182 "%s terminated abnormally without any error message",
3190 sigprocmask (SIG_SETMASK, &old_set, NULL);
3193 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3195 _DBUS_ASSERT_ERROR_IS_SET (error);
3197 if (result_pipe[0] != -1)
3198 close (result_pipe[0]);
3199 if (result_pipe[1] != -1)
3200 close (result_pipe[1]);
3201 if (errors_pipe[0] != -1)
3202 close (errors_pipe[0]);
3203 if (errors_pipe[1] != -1)
3204 close (errors_pipe[1]);
3210 * Returns the address of a new session bus.
3212 * If successful, returns #TRUE and appends the address to @p
3213 * address. If a failure happens, returns #FALSE and
3214 * sets an error in @p error.
3216 * @param address a DBusString where the address can be stored
3217 * @param error a DBusError to store the error in case of failure
3218 * @returns #TRUE on success, #FALSE if an error happened
3221 _dbus_get_autolaunch_address (DBusString *address,
3224 static char *argv[6];
3229 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3232 if (!_dbus_string_init (&uuid))
3234 _DBUS_SET_OOM (error);
3238 if (!_dbus_get_local_machine_uuid_encoded (&uuid))
3240 _DBUS_SET_OOM (error);
3245 argv[i] = "dbus-launch";
3247 argv[i] = "--autolaunch";
3249 argv[i] = _dbus_string_get_data (&uuid);
3251 argv[i] = "--binary-syntax";
3253 argv[i] = "--close-stderr";
3258 _dbus_assert (i == _DBUS_N_ELEMENTS (argv));
3260 retval = _read_subprocess_line_argv (DBUS_BINDIR "/dbus-launch",
3262 argv, address, error);
3265 _dbus_string_free (&uuid);
3270 * Reads the uuid of the machine we're running on from
3271 * the dbus configuration. Optionally try to create it
3272 * (only root can do this usually).
3274 * On UNIX, reads a file that gets created by dbus-uuidgen
3275 * in a post-install script. On Windows, if there's a standard
3276 * machine uuid we could just use that, but I can't find one
3277 * with the right properties (the hardware profile guid can change
3278 * without rebooting I believe). If there's no standard one
3279 * we might want to use the registry instead of a file for
3280 * this, and I'm not sure how we'd ensure the uuid gets created.
3282 * @param machine_id guid to init with the machine's uuid
3283 * @param create_if_not_found try to create the uuid if it doesn't exist
3284 * @param error the error return
3285 * @returns #FALSE if the error is set
3288 _dbus_read_local_machine_uuid (DBusGUID *machine_id,
3289 dbus_bool_t create_if_not_found,
3292 DBusString filename;
3293 _dbus_string_init_const (&filename, DBUS_MACHINE_UUID_FILE);
3294 return _dbus_read_uuid_file (&filename, machine_id, create_if_not_found, error);
3297 #define DBUS_UNIX_STANDARD_SESSION_SERVICEDIR "/dbus-1/services"
3298 #define DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR "/dbus-1/system-services"
3301 * Determines the address of the session bus by querying a
3302 * platform-specific method.
3304 * The first parameter will be a boolean specifying whether
3305 * or not a dynamic session lookup is supported on this platform.
3307 * If supported is TRUE and the return value is #TRUE, the
3308 * address will be appended to @p address.
3309 * If a failure happens, returns #FALSE and sets an error in
3312 * If supported is FALSE, ignore the return value.
3314 * @param supported returns whether this method is supported
3315 * @param address a DBusString where the address can be stored
3316 * @param error a DBusError to store the error in case of failure
3317 * @returns #TRUE on success, #FALSE if an error happened
3320 _dbus_lookup_session_address (dbus_bool_t *supported,
3321 DBusString *address,
3324 /* On non-Mac Unix platforms, if the session address isn't already
3325 * set in DBUS_SESSION_BUS_ADDRESS environment variable, we punt and
3326 * fall back to the autolaunch: global default; see
3327 * init_session_address in dbus/dbus-bus.c. */
3333 * Returns the standard directories for a session bus to look for service
3336 * On UNIX this should be the standard xdg freedesktop.org data directories:
3338 * XDG_DATA_HOME=${XDG_DATA_HOME-$HOME/.local/share}
3339 * XDG_DATA_DIRS=${XDG_DATA_DIRS-/usr/local/share:/usr/share}
3345 * @param dirs the directory list we are returning
3346 * @returns #FALSE on OOM
3350 _dbus_get_standard_session_servicedirs (DBusList **dirs)
3352 const char *xdg_data_home;
3353 const char *xdg_data_dirs;
3354 DBusString servicedir_path;
3356 if (!_dbus_string_init (&servicedir_path))
3359 xdg_data_home = _dbus_getenv ("XDG_DATA_HOME");
3360 xdg_data_dirs = _dbus_getenv ("XDG_DATA_DIRS");
3362 if (xdg_data_dirs != NULL)
3364 if (!_dbus_string_append (&servicedir_path, xdg_data_dirs))
3367 if (!_dbus_string_append (&servicedir_path, ":"))
3372 if (!_dbus_string_append (&servicedir_path, "/usr/local/share:/usr/share:"))
3377 * add configured datadir to defaults
3378 * this may be the same as an xdg dir
3379 * however the config parser should take
3380 * care of duplicates
3382 if (!_dbus_string_append (&servicedir_path, DBUS_DATADIR":"))
3385 if (xdg_data_home != NULL)
3387 if (!_dbus_string_append (&servicedir_path, xdg_data_home))
3392 const DBusString *homedir;
3393 DBusString local_share;
3395 if (!_dbus_homedir_from_current_process (&homedir))
3398 if (!_dbus_string_append (&servicedir_path, _dbus_string_get_const_data (homedir)))
3401 _dbus_string_init_const (&local_share, "/.local/share");
3402 if (!_dbus_concat_dir_and_file (&servicedir_path, &local_share))
3406 if (!_dbus_split_paths_and_append (&servicedir_path,
3407 DBUS_UNIX_STANDARD_SESSION_SERVICEDIR,
3411 _dbus_string_free (&servicedir_path);
3415 _dbus_string_free (&servicedir_path);
3421 * Returns the standard directories for a system bus to look for service
3424 * On UNIX this should be the standard xdg freedesktop.org data directories:
3426 * XDG_DATA_DIRS=${XDG_DATA_DIRS-/usr/local/share:/usr/share}
3432 * On Windows there is no system bus and this function can return nothing.
3434 * @param dirs the directory list we are returning
3435 * @returns #FALSE on OOM
3439 _dbus_get_standard_system_servicedirs (DBusList **dirs)
3441 const char *xdg_data_dirs;
3442 DBusString servicedir_path;
3444 if (!_dbus_string_init (&servicedir_path))
3447 xdg_data_dirs = _dbus_getenv ("XDG_DATA_DIRS");
3449 if (xdg_data_dirs != NULL)
3451 if (!_dbus_string_append (&servicedir_path, xdg_data_dirs))
3454 if (!_dbus_string_append (&servicedir_path, ":"))
3459 if (!_dbus_string_append (&servicedir_path, "/usr/local/share:/usr/share:"))
3464 * add configured datadir to defaults
3465 * this may be the same as an xdg dir
3466 * however the config parser should take
3467 * care of duplicates
3469 if (!_dbus_string_append (&servicedir_path, DBUS_DATADIR":"))
3472 if (!_dbus_split_paths_and_append (&servicedir_path,
3473 DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR,
3477 _dbus_string_free (&servicedir_path);
3481 _dbus_string_free (&servicedir_path);
3486 * Append the absolute path of the system.conf file
3487 * (there is no system bus on Windows so this can just
3488 * return FALSE and print a warning or something)
3490 * @param str the string to append to
3491 * @returns #FALSE if no memory
3494 _dbus_append_system_config_file (DBusString *str)
3496 return _dbus_string_append (str, DBUS_SYSTEM_CONFIG_FILE);
3500 * Append the absolute path of the session.conf file.
3502 * @param str the string to append to
3503 * @returns #FALSE if no memory
3506 _dbus_append_session_config_file (DBusString *str)
3508 return _dbus_string_append (str, DBUS_SESSION_CONFIG_FILE);
3512 * Called when the bus daemon is signaled to reload its configuration; any
3513 * caches should be nuked. Of course any caches that need explicit reload
3514 * are probably broken, but c'est la vie.
3519 _dbus_flush_caches (void)
3521 _dbus_user_database_flush_system ();
3525 * Appends the directory in which a keyring for the given credentials
3526 * should be stored. The credentials should have either a Windows or
3527 * UNIX user in them. The directory should be an absolute path.
3529 * On UNIX the directory is ~/.dbus-keyrings while on Windows it should probably
3530 * be something else, since the dotfile convention is not normal on Windows.
3532 * @param directory string to append directory to
3533 * @param credentials credentials the directory should be for
3535 * @returns #FALSE on no memory
3538 _dbus_append_keyring_directory_for_credentials (DBusString *directory,
3539 DBusCredentials *credentials)
3545 _dbus_assert (credentials != NULL);
3546 _dbus_assert (!_dbus_credentials_are_anonymous (credentials));
3548 if (!_dbus_string_init (&homedir))
3551 uid = _dbus_credentials_get_unix_uid (credentials);
3552 _dbus_assert (uid != DBUS_UID_UNSET);
3554 if (!_dbus_homedir_from_uid (uid, &homedir))
3557 #ifdef DBUS_BUILD_TESTS
3559 const char *override;
3561 override = _dbus_getenv ("DBUS_TEST_HOMEDIR");
3562 if (override != NULL && *override != '\0')
3564 _dbus_string_set_length (&homedir, 0);
3565 if (!_dbus_string_append (&homedir, override))
3568 _dbus_verbose ("Using fake homedir for testing: %s\n",
3569 _dbus_string_get_const_data (&homedir));
3573 static dbus_bool_t already_warned = FALSE;
3574 if (!already_warned)
3576 _dbus_warn ("Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid\n");
3577 already_warned = TRUE;
3583 _dbus_string_init_const (&dotdir, ".dbus-keyrings");
3584 if (!_dbus_concat_dir_and_file (&homedir,
3588 if (!_dbus_string_copy (&homedir, 0,
3589 directory, _dbus_string_get_length (directory))) {
3593 _dbus_string_free (&homedir);
3597 _dbus_string_free (&homedir);
3601 //PENDING(kdab) docs
3603 _dbus_daemon_publish_session_bus_address (const char* addr)
3608 //PENDING(kdab) docs
3610 _dbus_daemon_unpublish_session_bus_address (void)
3616 * See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently
3617 * for Winsock so is abstracted)
3619 * @returns #TRUE if errno == EAGAIN or errno == EWOULDBLOCK
3622 _dbus_get_is_errno_eagain_or_ewouldblock (void)
3624 return errno == EAGAIN || errno == EWOULDBLOCK;
3628 * Removes a directory; Directory must be empty
3630 * @param filename directory filename
3631 * @param error initialized error object
3632 * @returns #TRUE on success
3635 _dbus_delete_directory (const DBusString *filename,
3638 const char *filename_c;
3640 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3642 filename_c = _dbus_string_get_const_data (filename);
3644 if (rmdir (filename_c) != 0)
3646 dbus_set_error (error, DBUS_ERROR_FAILED,
3647 "Failed to remove directory %s: %s\n",
3648 filename_c, _dbus_strerror (errno));
3656 * Checks whether file descriptors may be passed via the socket
3658 * @param fd the socket
3659 * @return TRUE when fd passing over this socket is supported
3663 _dbus_socket_can_pass_unix_fd(int fd) {
3668 struct sockaddr_storage storage;
3669 struct sockaddr_un un;
3672 socklen_t sa_len = sizeof(sa_buf);
3676 if (getsockname(fd, &sa_buf.sa, &sa_len) < 0)
3679 return sa_buf.sa.sa_family == AF_UNIX;
3689 * replaces the term DBUS_PREFIX in configure_time_path by the
3690 * current dbus installation directory. On unix this function is a noop
3692 * @param configure_time_path
3696 _dbus_replace_install_prefix (const char *configure_time_path)
3698 return configure_time_path;
3701 /* tests in dbus-sysdeps-util.c */