29#include "dbus-internals.h"
30#include "dbus-sysdeps.h"
31#include "dbus-sysdeps-unix.h"
32#include "dbus-threads.h"
33#include "dbus-protocol.h"
35#include "dbus-transport.h"
36#include "dbus-string.h"
37#include "dbus-userdb.h"
39#include "dbus-credentials.h"
40#include "dbus-nonce.h"
50#include <sys/socket.h>
59#include <netinet/in.h>
60#include <netinet/tcp.h>
68#ifdef HAVE_LINUX_CLOSE_RANGE_H
69#include <linux/close_range.h>
80#ifdef HAVE_GETPEERUCRED
86#ifdef HAVE_SYS_RANDOM_H
87#include <sys/random.h>
89#ifdef HAVE_SYS_SYSCALL_H
90#include <sys/syscall.h>
98#include <systemd/sd-daemon.h>
110#define AI_ADDRCONFIG 0
113#ifndef HAVE_SOCKLEN_T
117#if defined (__sun) || defined (__sun__)
130# define CMSG_ALIGN(len) _CMSG_DATA_ALIGN (len)
133# define CMSG_ALIGN(len) (((len) + sizeof (long) - 1) & \
134 ~(sizeof (long) - 1))
139# define CMSG_SPACE(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + \
144# define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
149#if defined(__linux__) && defined(__NR_close_range) && !defined(HAVE_CLOSE_RANGE)
154close_range (
unsigned int first,
158 return syscall (__NR_close_range, first, last, flags);
161#define HAVE_CLOSE_RANGE
180 const char **error_str_p)
182 static int const relevant_flag[] = { DBUS_FORCE_STDIN_NULL,
183 DBUS_FORCE_STDOUT_NULL,
184 DBUS_FORCE_STDERR_NULL };
186 const char *error_str =
"Failed mysteriously";
190 _DBUS_STATIC_ASSERT (STDIN_FILENO == 0);
191 _DBUS_STATIC_ASSERT (STDOUT_FILENO == 1);
192 _DBUS_STATIC_ASSERT (STDERR_FILENO == 2);
195 for (i = STDIN_FILENO; i <= STDERR_FILENO; i++)
201 devnull = open (
"/dev/null", O_RDWR);
205 error_str =
"Failed to open /dev/null";
214 if (devnull != i && (flags & relevant_flag[i]) != 0)
216 if (dup2 (devnull, i) < 0)
218 error_str =
"Failed to dup2 /dev/null onto a standard fd";
229 if (devnull > STDERR_FILENO)
232 if (error_str_p !=
NULL)
233 *error_str_p = error_str;
236 return (error_str ==
NULL);
239static dbus_bool_t _dbus_set_fd_nonblocking (
int fd,
243_dbus_open_socket (
int *fd_p,
252 *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
253 cloexec_done = *fd_p >= 0;
256 if (*fd_p < 0 && (errno == EINVAL || errno == EPROTOTYPE))
259 *fd_p = socket (domain, type, protocol);
271 _dbus_verbose (
"socket fd %d opened\n", *fd_p);
278 "Failed to open socket: %s",
279 _dbus_strerror (errno));
295_dbus_open_unix_socket (
int *fd,
298 return _dbus_open_socket(fd, AF_UNIX, SOCK_STREAM, 0, error);
320 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
323 _dbus_socket_invalidate (fd);
361#if HAVE_DECL_MSG_NOSIGNAL
369 bytes_written = send (fd.fd, data, len, MSG_NOSIGNAL);
371 if (bytes_written < 0 && errno == EINTR)
374 return bytes_written;
398 unsigned int *n_fds) {
399#ifndef HAVE_UNIX_FD_PASSING
437 m.msg_controllen = CMSG_SPACE(*n_fds *
sizeof(
int));
441 m.msg_control = alloca(m.msg_controllen);
442 memset(m.msg_control, 0, m.msg_controllen);
448 m.msg_controllen = CMSG_LEN (*n_fds *
sizeof(
int));
452 bytes_read = recvmsg (fd.fd, &m, 0
453#ifdef MSG_CMSG_CLOEXEC
474 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
475 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
478 int *payload = (
int *) (
void *) CMSG_DATA (cm);
479 size_t payload_len_bytes = (cm->cmsg_len - CMSG_LEN (0));
480 size_t payload_len_fds;
485 _DBUS_STATIC_ASSERT (
sizeof (
size_t) >=
sizeof (
unsigned int));
487 if ((m.msg_flags & MSG_CTRUNC) && CMSG_NXTHDR(&m, cm) ==
NULL &&
488 (
char *) payload + payload_len_bytes >
489 (
char *) m.msg_control + m.msg_controllen)
500 payload_len_bytes = m.msg_controllen -
501 ((
char *) payload - (
char *) m.msg_control);
504 payload_len_fds = payload_len_bytes /
sizeof (int);
506 if (_DBUS_LIKELY (payload_len_fds <= (
size_t) *n_fds))
509 fds_to_use = payload_len_fds;
517 fds_to_use = (size_t) *n_fds;
522 for (i = fds_to_use; i < payload_len_fds; i++)
528 memcpy (fds, payload, fds_to_use *
sizeof (
int));
533 *n_fds = (
unsigned int) fds_to_use;
538 for (i = 0; i < fds_to_use; i++)
547 if (m.msg_flags & MSG_CTRUNC)
558 for (i = 0; i < *n_fds; i++)
581_dbus_write_socket_with_unix_fds(
DBusSocket fd,
588#ifndef HAVE_UNIX_FD_PASSING
597 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len,
NULL, 0, 0, fds, n_fds);
602_dbus_write_socket_with_unix_fds_two(
DBusSocket fd,
612#ifndef HAVE_UNIX_FD_PASSING
620 buffer1, start1, len1,
621 buffer2, start2, len2);
635 iov[0].iov_len = len1;
640 iov[1].iov_len = len2;
645 m.msg_iovlen = buffer2 ? 2 : 1;
649 m.msg_controllen = CMSG_SPACE(n_fds *
sizeof(
int));
650 m.msg_control = alloca(m.msg_controllen);
651 memset(m.msg_control, 0, m.msg_controllen);
653 cm = CMSG_FIRSTHDR(&m);
654 cm->cmsg_level = SOL_SOCKET;
655 cm->cmsg_type = SCM_RIGHTS;
656 cm->cmsg_len = CMSG_LEN(n_fds *
sizeof(
int));
657 memcpy(CMSG_DATA(cm), fds, n_fds *
sizeof(
int));
662 bytes_written = sendmsg (fd.fd, &m, 0
663#
if HAVE_DECL_MSG_NOSIGNAL
668 if (bytes_written < 0 && errno == EINTR)
672 if (bytes_written > 0)
676 return bytes_written;
702#if HAVE_DECL_MSG_NOSIGNAL
703 struct iovec vectors[2];
726 vectors[0].iov_base = (
char*) data1;
727 vectors[0].iov_len = len1;
728 vectors[1].iov_base = (
char*) data2;
729 vectors[1].iov_len = len2;
733 m.msg_iovlen = data2 ? 2 : 1;
737 bytes_written = sendmsg (fd.fd, &m, MSG_NOSIGNAL);
739 if (bytes_written < 0 && errno == EINTR)
742 return bytes_written;
746 buffer2, start2, len2);
789 bytes_read = read (fd, data, count);
839 bytes_written = write (fd, data, len);
841 if (bytes_written < 0 && errno == EINTR)
845 if (bytes_written > 0)
849 return bytes_written;
889 struct iovec vectors[2];
905 vectors[0].iov_base = (
char*) data1;
906 vectors[0].iov_len = len1;
907 vectors[1].iov_base = (
char*) data2;
908 vectors[1].iov_len = len2;
912 bytes_written = writev (fd,
916 if (bytes_written < 0 && errno == EINTR)
919 return bytes_written;
926 if (ret1 == len1 && buffer2 !=
NULL)
963 struct sockaddr_un addr;
966 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
968 _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
972 if (!_dbus_open_unix_socket (&fd.fd, error))
974 _DBUS_ASSERT_ERROR_IS_SET(error);
977 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
980 addr.sun_family = AF_UNIX;
981 path_len = strlen (path);
986 addr.sun_path[0] =
'\0';
992 "Abstract socket name too long\n");
997 strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
1001 "Operating system does not support abstract socket namespace\n");
1011 "Socket name too long\n");
1016 strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
1019 if (connect (fd.fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1023 "Failed to connect to socket %s: %s",
1024 path, _dbus_strerror (errno));
1030 if (!_dbus_set_fd_nonblocking (fd.fd, error))
1032 _DBUS_ASSERT_ERROR_IS_SET (error);
1064 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1066 _dbus_verbose (
"connecting to process %s\n", path);
1069 retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
1070 cloexec_done = (retval >= 0);
1072 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
1075 retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
1082 "Failed to create socket pair: %s",
1083 _dbus_strerror (errno));
1104 "Failed to fork() to call %s: %s",
1105 path, _dbus_strerror (errno));
1117 dup2 (fds[1], STDIN_FILENO);
1118 dup2 (fds[1], STDOUT_FILENO);
1120 if (fds[1] != STDIN_FILENO &&
1121 fds[1] != STDOUT_FILENO)
1129 execvp (path, (
char *
const *) argv);
1131 fprintf (stderr,
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
1139 if (!_dbus_set_fd_nonblocking (fds[0], error))
1141 _DBUS_ASSERT_ERROR_IS_SET (error);
1176 struct sockaddr_un addr;
1180 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1182 _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
1185 if (!_dbus_open_unix_socket (&listen_fd, error))
1187 _DBUS_ASSERT_ERROR_IS_SET(error);
1190 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1193 addr.sun_family = AF_UNIX;
1194 path_len = strlen (path);
1202 addr.sun_path[0] =
'\0';
1208 "Abstract socket name too long\n");
1213 strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
1217 "Operating system does not support abstract socket namespace\n");
1237 if (stat (path, &sb) == 0 &&
1238 S_ISSOCK (sb.st_mode))
1245 "Socket name too long\n");
1250 strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
1253 if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1256 "Failed to bind socket \"%s\": %s",
1257 path, _dbus_strerror (errno));
1262 if (listen (listen_fd, SOMAXCONN ) < 0)
1265 "Failed to listen on socket \"%s\": %s",
1266 path, _dbus_strerror (errno));
1271 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1273 _DBUS_ASSERT_ERROR_IS_SET (error);
1281 if (!abstract && chmod (path, 0777) < 0)
1282 _dbus_warn (
"Could not set mode 0777 on socket %s", path);
1307 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1309 n = sd_listen_fds (
TRUE);
1313 "Failed to acquire systemd socket: %s",
1314 _dbus_strerror (-n));
1321 "No socket received.");
1325 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1327 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1331 "Failed to verify systemd socket type: %s",
1332 _dbus_strerror (-r));
1339 "Passed socket has wrong type.");
1351 "Failed to allocate file handle array.");
1355 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1357 if (!_dbus_set_fd_nonblocking (fd, error))
1359 _DBUS_ASSERT_ERROR_IS_SET (error);
1363 new_fds[fd - SD_LISTEN_FDS_START].fd = fd;
1371 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1380 "dbus was compiled without systemd support");
1388_dbus_error_from_gai (
int gai_res,
1454 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
1458_dbus_connect_tcp_socket_with_nonce (
const char *host,
1461 const char *noncefile,
1464 int saved_errno = 0;
1468 struct addrinfo hints;
1469 struct addrinfo *ai =
NULL;
1470 const struct addrinfo *tmp;
1473 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1478 hints.ai_family = AF_UNSPEC;
1479 else if (!strcmp(family,
"ipv4"))
1480 hints.ai_family = AF_INET;
1481 else if (!strcmp(family,
"ipv6"))
1482 hints.ai_family = AF_INET6;
1487 "Unknown address family %s", family);
1488 return _dbus_socket_get_invalid ();
1490 hints.ai_protocol = IPPROTO_TCP;
1491 hints.ai_socktype = SOCK_STREAM;
1492 hints.ai_flags = AI_ADDRCONFIG;
1494 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1497 _dbus_error_from_gai (res, errno),
1498 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1499 host, port, gai_strerror(res), res);
1506 if (!_dbus_open_socket (&fd.fd, tmp->ai_family, SOCK_STREAM, 0, error))
1508 _DBUS_ASSERT_ERROR_IS_SET(error);
1509 _dbus_socket_invalidate (&fd);
1512 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1514 if (connect (fd.fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1516 saved_errno = errno;
1521 if (connect_error ==
NULL)
1523 _DBUS_SET_OOM (error);
1528 _dbus_set_error_with_inet_sockaddr (connect_error,
1529 tmp->ai_addr, tmp->ai_addrlen,
1530 "Failed to connect to socket",
1537 _DBUS_SET_OOM (error);
1548 if (!_dbus_socket_is_valid (fd))
1550 _dbus_combine_tcp_errors (&connect_errors,
"Failed to connect",
1555 if (noncefile !=
NULL)
1560 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1569 if (!_dbus_set_fd_nonblocking (fd.fd, error))
1610 const char **retfamily,
1615 int nlisten_fd = 0, res, i;
1619 struct addrinfo hints;
1620 struct addrinfo *ai, *tmp;
1621 unsigned int reuseaddr;
1626 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1631 hints.ai_family = AF_UNSPEC;
1632 else if (!strcmp(family,
"ipv4"))
1633 hints.ai_family = AF_INET;
1634 else if (!strcmp(family,
"ipv6"))
1635 hints.ai_family = AF_INET6;
1640 "Unknown address family %s", family);
1644 hints.ai_protocol = IPPROTO_TCP;
1645 hints.ai_socktype = SOCK_STREAM;
1646 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1648 redo_lookup_with_port:
1650 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1653 _dbus_error_from_gai (res, errno),
1654 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1655 host ? host :
"*", port, gai_strerror(res), res);
1662 int fd = -1, tcp_nodelay_on;
1665 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1667 _DBUS_ASSERT_ERROR_IS_SET(error);
1670 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1673 if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1675 _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
1676 host ? host :
"*", port, _dbus_strerror (errno));
1682 if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay_on,
sizeof (tcp_nodelay_on)) == -1)
1684 _dbus_warn (
"Failed to set TCP_NODELAY socket option \"%s:%s\": %s",
1685 host ? host :
"*", port, _dbus_strerror (errno));
1688 if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1690 saved_errno = errno;
1714 if (bind_error ==
NULL)
1716 _DBUS_SET_OOM (error);
1721 _dbus_set_error_with_inet_sockaddr (bind_error, tmp->ai_addr, tmp->ai_addrlen,
1722 "Failed to bind socket",
1729 _DBUS_SET_OOM (error);
1738 if (listen (fd, 30 ) < 0)
1740 saved_errno = errno;
1742 _dbus_set_error_with_inet_sockaddr (error, tmp->ai_addr, tmp->ai_addrlen,
1743 "Failed to listen on socket",
1753 "Failed to allocate file handle array");
1756 listen_fd = newlisten_fd;
1757 listen_fd[nlisten_fd].fd = fd;
1760 if (tmp->ai_addr->sa_family == AF_INET)
1762 else if (tmp->ai_addr->sa_family == AF_INET6)
1771 if (!port || !strcmp(port,
"0"))
1774 struct sockaddr_storage addr;
1778 addrlen =
sizeof(addr);
1779 result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
1783 saved_errno = errno;
1785 "Failed to retrieve socket name for \"%s:%s\": %s",
1786 host ? host :
"*", port, _dbus_strerror (saved_errno));
1790 if ((res = getnameinfo ((
struct sockaddr*)&addr, addrlen,
NULL, 0,
1791 portbuf,
sizeof(portbuf),
1792 NI_NUMERICHOST | NI_NUMERICSERV)) != 0)
1794 saved_errno = errno;
1796 "Failed to resolve port \"%s:%s\": %s (%d)",
1797 host ? host :
"*", port, gai_strerror(res), res);
1810 goto redo_lookup_with_port;
1829 _dbus_combine_tcp_errors (&bind_errors,
"Failed to bind", host,
1834 if (have_ipv4 && !have_ipv6)
1835 *retfamily =
"ipv4";
1836 else if (!have_ipv4 && have_ipv6)
1837 *retfamily =
"ipv6";
1839 for (i = 0 ; i < nlisten_fd ; i++)
1841 if (!_dbus_set_fd_nonblocking (listen_fd[i].fd, error))
1862 for (i = 0 ; i < nlisten_fd ; i++)
1876write_credentials_byte (
int server_fd,
1880 char buf[1] = {
'\0' };
1881#if defined(HAVE_CMSGCRED)
1884 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1895 msg.msg_control = (caddr_t) &cmsg;
1896 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1898 cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
1899 cmsg.hdr.cmsg_level = SOL_SOCKET;
1900 cmsg.hdr.cmsg_type = SCM_CREDS;
1903 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1907#if defined(HAVE_CMSGCRED)
1908 bytes_written = sendmsg (server_fd, &msg, 0
1909#
if HAVE_DECL_MSG_NOSIGNAL
1917 if (bytes_written < 0 && errno == EINVAL)
1920 bytes_written = send (server_fd, buf, 1, 0
1921#
if HAVE_DECL_MSG_NOSIGNAL
1927 if (bytes_written < 0 && errno == EINTR)
1930 if (bytes_written < 0)
1933 "Failed to write credentials byte: %s",
1934 _dbus_strerror (errno));
1937 else if (bytes_written == 0)
1940 "wrote zero bytes writing credentials byte");
1946 _dbus_verbose (
"wrote credentials byte\n");
1953add_groups_to_credentials (
int client_fd,
1957#if defined(__linux__) && defined(SO_PEERGROUPS)
1958 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
1960 socklen_t len = 1024;
1968 n_gids = ((size_t) len) /
sizeof (gid_t);
1974 while (getsockopt (client_fd, SOL_SOCKET, SO_PEERGROUPS, buf, &len) < 0)
1979 _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
1980 _dbus_strerror (e), (
unsigned long) len);
1982 if (e != ERANGE || (
size_t) len <= n_gids *
sizeof (gid_t))
1984 _dbus_verbose (
"Failed to getsockopt(SO_PEERGROUPS): %s\n",
1985 _dbus_strerror (e));
1991 n_gids = ((size_t) len) /
sizeof (gid_t);
1994 if (replacement ==
NULL)
2001 _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
2006 _dbus_verbose (
"getsockopt(SO_PEERGROUPS) yielded <= 0 bytes: %ld\n",
2011 if (len > n_gids *
sizeof (gid_t))
2013 _dbus_verbose (
"%lu > %zu", (
unsigned long) len, n_gids *
sizeof (gid_t));
2017 if (len %
sizeof (gid_t) != 0)
2019 _dbus_verbose (
"getsockopt(SO_PEERGROUPS) did not return an "
2020 "integer multiple of sizeof(gid_t): %lu should be "
2022 (
unsigned long) len,
sizeof (gid_t));
2027 n_gids = ((size_t) len) /
sizeof (gid_t);
2035 _dbus_verbose (
"getsockopt(SO_PEERGROUPS) returned a huge number "
2036 "of groups (%lu bytes), ignoring",
2037 (
unsigned long) len);
2043 if (converted_gids ==
NULL)
2049 for (i = 0; i < n_gids; i++)
2053 if (converted_gids[i] == primary)
2054 need_primary =
FALSE;
2059 converted_gids[n_gids] = primary;
2076add_linux_security_label_to_credentials (
int client_fd,
2079#if defined(__linux__) && defined(SO_PEERSEC)
2081 socklen_t len = 1024;
2088 while (getsockopt (client_fd, SOL_SOCKET, SO_PEERSEC,
2093 _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
2094 _dbus_strerror (e), (
unsigned long) len);
2096 if (e != ERANGE || len <= _dbus_string_get_length_uint (&buf))
2098 _dbus_verbose (
"Failed to getsockopt(SO_PEERSEC): %s\n",
2099 _dbus_strerror (e));
2111 _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
2116 _dbus_verbose (
"getsockopt(SO_PEERSEC) yielded <= 0 bytes: %lu\n",
2117 (
unsigned long) len);
2121 if (len > _dbus_string_get_length_uint (&buf))
2123 _dbus_verbose (
"%lu > %u", (
unsigned long) len,
2124 _dbus_string_get_length_uint (&buf));
2132 _dbus_verbose (
"subtracting trailing \\0\n");
2148 _dbus_verbose (
"security label from kernel had an embedded \\0, "
2153 _dbus_verbose (
"getsockopt(SO_PEERSEC): %lu bytes excluding \\0: %s\n",
2154 (
unsigned long) len,
2229 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
2237 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
2238 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
2239 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
2245 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2249 iov.iov_base = &buf;
2256#if defined(HAVE_CMSGCRED)
2258 msg.msg_control = (caddr_t) &cmsg;
2259 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
2263 bytes_read = recvmsg (client_fd.fd, &msg, 0);
2276 "Failed to read credentials byte: %s",
2277 _dbus_strerror (errno));
2280 else if (bytes_read == 0)
2286 "Failed to read credentials byte (zero-length read)");
2289 else if (buf !=
'\0')
2292 "Credentials byte was not nul");
2296 _dbus_verbose (
"read credentials byte\n");
2309 struct sockpeercred cr;
2313 socklen_t cr_len =
sizeof (cr);
2315 if (getsockopt (client_fd.fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) != 0)
2317 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED): %s\n",
2318 _dbus_strerror (errno));
2320 else if (cr_len !=
sizeof (cr))
2322 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED), returned %d bytes, expected %d\n",
2323 cr_len, (
int)
sizeof (cr));
2333 primary_gid_read = cr.gid;
2336#elif defined(HAVE_UNPCBID) && defined(LOCAL_PEEREID)
2340 socklen_t cr_len =
sizeof (cr);
2342 if (getsockopt (client_fd.fd, 0, LOCAL_PEEREID, &cr, &cr_len) != 0)
2344 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID): %s\n",
2345 _dbus_strerror (errno));
2347 else if (cr_len !=
sizeof (cr))
2349 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID), returned %d bytes, expected %d\n",
2350 cr_len, (
int)
sizeof (cr));
2354 pid_read = cr.unp_pid;
2355 uid_read = cr.unp_euid;
2357#elif defined(HAVE_CMSGCRED)
2366 struct cmsgcred *cred;
2367 struct cmsghdr *cmsgp;
2369 for (cmsgp = CMSG_FIRSTHDR (&msg);
2371 cmsgp = CMSG_NXTHDR (&msg, cmsgp))
2373 if (cmsgp->cmsg_type == SCM_CREDS &&
2374 cmsgp->cmsg_level == SOL_SOCKET &&
2375 cmsgp->cmsg_len >= CMSG_LEN (
sizeof (
struct cmsgcred)))
2377 cred = (
struct cmsgcred *) (
void *) CMSG_DATA (cmsgp);
2378 pid_read = cred->cmcred_pid;
2379 uid_read = cred->cmcred_euid;
2384#elif defined(HAVE_GETPEERUCRED)
2388 ucred_t * ucred =
NULL;
2389 if (getpeerucred (client_fd.fd, &ucred) == 0)
2392 adt_session_data_t *adth =
NULL;
2394 pid_read = ucred_getpid (ucred);
2395 uid_read = ucred_geteuid (ucred);
2398 if (adt_start_session (&adth,
NULL, 0) || (adth ==
NULL))
2400 _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
2404 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
2406 _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
2410 adt_export_data_t *data =
NULL;
2411 size_t size = adt_export_session_data (adth, &data);
2414 _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
2422 (void) adt_end_session (adth);
2428 _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
2438#elif defined(HAVE_GETPEEREID)
2456 if (getpeereid (client_fd.fd, &euid, &egid) == 0)
2462 _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
2466#warning Socket credentials not supported on this Unix OS
2467#warning Please tell https:
2473#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
2474 defined(__linux__) || \
2475 defined(__OpenBSD__) || \
2477# error Credentials passing not working on this OS is a regression!
2480 _dbus_verbose (
"Socket credentials not supported on this OS\n");
2484 _dbus_verbose (
"Credentials:"
2495 _DBUS_SET_OOM (error);
2504 _DBUS_SET_OOM (error);
2509 if (!add_linux_security_label_to_credentials (client_fd.fd, credentials))
2511 _DBUS_SET_OOM (error);
2517 if (!add_groups_to_credentials (client_fd.fd, credentials, primary_gid_read))
2519 _DBUS_SET_OOM (error);
2547 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2549 if (write_credentials_byte (server_fd.fd, error))
2568 struct sockaddr addr;
2574 addrlen =
sizeof (addr);
2584 client_fd.fd = accept4 (listen_fd.fd, &addr, &addrlen, SOCK_CLOEXEC);
2585 cloexec_done = client_fd.fd >= 0;
2587 if (client_fd.fd < 0 && (errno == ENOSYS || errno == EINVAL))
2590 client_fd.fd = accept (listen_fd.fd, &addr, &addrlen);
2593 if (client_fd.fd < 0)
2599 _dbus_verbose (
"client fd %d accepted\n", client_fd.fd);
2622 const char *directory;
2625 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2629 if (stat (directory, &sb) < 0)
2632 "%s", _dbus_strerror (errno));
2637 if (sb.st_uid != geteuid ())
2640 "%s directory is owned by user %lu, not %lu",
2642 (
unsigned long) sb.st_uid,
2643 (
unsigned long) geteuid ());
2647 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
2648 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
2651 "%s directory is not private to the user", directory);
2659fill_user_info_from_passwd (
struct passwd *p,
2666 info->
uid = p->pw_uid;
2687 const char *username_c;
2700 if (username !=
NULL)
2710#ifdef HAVE_GETPWNAM_R
2716 struct passwd p_str;
2719 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
2725 if ((
long) buflen <= 0)
2740 result = getpwuid_r (uid, &p_str, buf, buflen,
2743 result = getpwnam_r (username_c, &p_str, buf, buflen,
2746 if (result == ERANGE && buflen < 512 * 1024)
2756 if (result == 0 && p == &p_str)
2758 if (!fill_user_info_from_passwd (p, info, error))
2768 "User \"%s\" unknown or no memory to allocate password entry\n",
2769 username_c ? username_c :
"???");
2770 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2780#warning getpwnam_r() not available, please report this to the dbus maintainers with details of your OS
2785 p = getpwnam (username_c);
2789 if (!fill_user_info_from_passwd (p, info, error))
2797 "User \"%s\" unknown or no memory to allocate password entry\n",
2798 username_c ? username_c :
"???");
2799 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2808#ifdef HAVE_GETGROUPLIST
2813 int initial_buf_count;
2815 initial_buf_count = 17;
2816 buf_count = initial_buf_count;
2824 if (getgrouplist (username_c,
2826 buf, &buf_count) < 0)
2842 if (buf_count == initial_buf_count)
2857 if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
2861 _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2862 username_c, buf_count, buf_count);
2868 "Failed to get groups for username \"%s\" primary GID "
2871 _dbus_strerror (errno));
2886 for (i = 0; i < buf_count; ++i)
2909 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2914 _DBUS_ASSERT_ERROR_IS_SET (error);
2948 return fill_user_info (info, uid,
2972 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
2973 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
2974 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
3048static pthread_mutex_t atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
3061 return __sync_add_and_fetch(&atomic->
value, 1)-1;
3065 pthread_mutex_lock (&atomic_mutex);
3066 res = atomic->
value;
3068 pthread_mutex_unlock (&atomic_mutex);
3084 return __sync_sub_and_fetch(&atomic->
value, 1)+1;
3088 pthread_mutex_lock (&atomic_mutex);
3089 res = atomic->
value;
3091 pthread_mutex_unlock (&atomic_mutex);
3108 __sync_synchronize ();
3109 return atomic->
value;
3113 pthread_mutex_lock (&atomic_mutex);
3114 res = atomic->
value;
3115 pthread_mutex_unlock (&atomic_mutex);
3131 __sync_and_and_fetch (&atomic->
value, 0);
3133 pthread_mutex_lock (&atomic_mutex);
3135 pthread_mutex_unlock (&atomic_mutex);
3149 __sync_or_and_fetch (&atomic->
value, 1);
3151 pthread_mutex_lock (&atomic_mutex);
3153 pthread_mutex_unlock (&atomic_mutex);
3168 int timeout_milliseconds)
3170#if defined(HAVE_POLL) && !defined(BROKEN_POLL)
3172 if (timeout_milliseconds < -1)
3174 timeout_milliseconds = -1;
3179 timeout_milliseconds);
3182 fd_set read_set, write_set, err_set;
3188 FD_ZERO (&read_set);
3189 FD_ZERO (&write_set);
3192 for (i = 0; i < n_fds; i++)
3197 FD_SET (fdp->
fd, &read_set);
3200 FD_SET (fdp->
fd, &write_set);
3202 FD_SET (fdp->
fd, &err_set);
3204 max_fd = MAX (max_fd, fdp->
fd);
3207 tv.tv_sec = timeout_milliseconds / 1000;
3208 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
3210 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
3211 timeout_milliseconds < 0 ?
NULL : &tv);
3215 for (i = 0; i < n_fds; i++)
3221 if (FD_ISSET (fdp->
fd, &read_set))
3224 if (FD_ISSET (fdp->
fd, &write_set))
3227 if (FD_ISSET (fdp->
fd, &err_set))
3247#ifdef HAVE_MONOTONIC_CLOCK
3249 clock_gettime (CLOCK_MONOTONIC, &ts);
3252 *tv_sec = ts.tv_sec;
3254 *tv_usec = ts.tv_nsec / 1000;
3258 gettimeofday (&t,
NULL);
3263 *tv_usec = t.tv_usec;
3280 gettimeofday (&t,
NULL);
3285 *tv_usec = t.tv_usec;
3300 const char *filename_c;
3302 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3306 if (mkdir (filename_c, 0700) < 0)
3308 if (errno == EEXIST)
3312 "Failed to create directory %s: %s\n",
3313 filename_c, _dbus_strerror (errno));
3332 const char *filename_c;
3334 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3338 if (mkdir (filename_c, 0700) < 0)
3341 "Failed to create directory %s: %s\n",
3342 filename_c, _dbus_strerror (errno));
3375 if (dir_ends_in_slash && file_starts_with_slash)
3379 else if (!(dir_ends_in_slash || file_starts_with_slash))
3390#define NANOSECONDS_PER_SECOND 1000000000
3392#define MICROSECONDS_PER_SECOND 1000000
3394#define MILLISECONDS_PER_SECOND 1000
3396#define NANOSECONDS_PER_MILLISECOND 1000000
3398#define MICROSECONDS_PER_MILLISECOND 1000
3407#ifdef HAVE_NANOSLEEP
3408 struct timespec req;
3409 struct timespec rem;
3411 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
3412 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
3416 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
3418#elif defined (HAVE_USLEEP)
3419 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
3421 sleep (MAX (milliseconds / 1000, 1));
3442#ifdef HAVE_GETRANDOM
3447 _DBUS_SET_OOM (error);
3452 result = getrandom (buffer, n_bytes, GRND_NONBLOCK);
3454 if (result == n_bytes)
3461 fd = open (
"/dev/urandom", O_RDONLY);
3466 "Could not open /dev/urandom: %s",
3467 _dbus_strerror (errno));
3471 _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
3475 if (result != n_bytes)
3479 "Could not read /dev/urandom: %s",
3480 _dbus_strerror (errno));
3483 "Short read from /dev/urandom");
3490 _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
3518_dbus_strerror (
int error_number)
3522 msg = strerror (error_number);
3535 signal (SIGPIPE, SIG_IGN);
3550 val = fcntl (fd, F_GETFD, 0);
3557 fcntl (fd, F_SETFD, val);
3572 val = fcntl (fd, F_GETFD, 0);
3579 fcntl (fd, F_SETFD, val);
3593 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3602 "Could not close fd %d", fd);
3623#ifdef F_DUPFD_CLOEXEC
3626 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
3627 cloexec_done = new_fd >= 0;
3629 if (new_fd < 0 && errno == EINVAL)
3632 new_fd = fcntl(fd, F_DUPFD, 3);
3638 "Could not duplicate fd %d", fd);
3642#ifdef F_DUPFD_CLOEXEC
3663 return _dbus_set_fd_nonblocking (fd.fd, error);
3667_dbus_set_fd_nonblocking (
int fd,
3672 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3674 val = fcntl (fd, F_GETFL, 0);
3678 "Failed to get flags from file descriptor %d: %s",
3679 fd, _dbus_strerror (errno));
3680 _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
3681 _dbus_strerror (errno));
3685 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
3688 "Failed to set nonblocking flag of file descriptor %d: %s",
3689 fd, _dbus_strerror (errno));
3690 _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
3691 fd, _dbus_strerror (errno));
3707#if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
3713 bt_size = backtrace (bt, 500);
3715 syms = backtrace_symbols (bt, bt_size);
3721 fprintf (stderr,
" %s\n", syms[i]);
3727#elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
3728 fprintf (stderr,
" D-Bus not built with -rdynamic so unable to print a backtrace\n");
3730 fprintf (stderr,
" D-Bus not compiled with backtrace support so unable to print a backtrace\n");
3752#ifdef HAVE_SOCKETPAIR
3759 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
3760 cloexec_done = retval >= 0;
3762 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
3765 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
3771 "Could not create full-duplex pipe");
3775 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3786 (!_dbus_set_fd_nonblocking (fds[0],
NULL) ||
3787 !_dbus_set_fd_nonblocking (fds[1],
NULL)))
3790 "Could not set full-duplex pipe nonblocking");
3801 _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
3806 _dbus_warn (
"_dbus_socketpair() not implemented on this OS");
3808 "_dbus_socketpair() not implemented on this OS");
3825 char static_buf[1024];
3826 int bufsize =
sizeof (static_buf);
3830 va_copy (args_copy, args);
3831 len = vsnprintf (static_buf, bufsize, format, args_copy);
3848 va_copy (args_copy, args);
3850 if (vsnprintf (static_buf, 1, format, args_copy) == 1)
3869 va_copy (args_copy, args);
3870 len = vsnprintf (buf, bufsize, format, args_copy);
3895 static const char* tmpdir =
NULL;
3907 tmpdir = getenv(
"TMPDIR");
3913 tmpdir = getenv(
"TMP");
3915 tmpdir = getenv(
"TEMP");
3929#if defined(DBUS_ENABLE_X11_AUTOLAUNCH) || defined(DBUS_ENABLE_LAUNCHD)
3950_read_subprocess_line_argv (
const char *progpath,
3952 const char *
const *argv,
3956 int result_pipe[2] = { -1, -1 };
3957 int errors_pipe[2] = { -1, -1 };
3964 sigset_t new_set, old_set;
3966 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3973 sigemptyset (&new_set);
3974 sigaddset (&new_set, SIGCHLD);
3975 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3981 if (pipe (result_pipe) < 0)
3984 "Failed to create a pipe to call %s: %s",
3985 progpath, _dbus_strerror (errno));
3986 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3987 progpath, _dbus_strerror (errno));
3990 if (pipe (errors_pipe) < 0)
3993 "Failed to create a pipe to call %s: %s",
3994 progpath, _dbus_strerror (errno));
3995 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3996 progpath, _dbus_strerror (errno));
4009 "Failed to fork() to call %s: %s",
4010 progpath, _dbus_strerror (errno));
4011 _dbus_verbose (
"Failed to fork() to call %s: %s\n",
4012 progpath, _dbus_strerror (errno));
4019 const char *error_str;
4023 int saved_errno = errno;
4028 if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0 ||
4029 write (errors_pipe[
WRITE_END],
": ", 2) < 0)
4034 error_str = _dbus_strerror (saved_errno);
4036 if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0)
4048 if (dup2 (result_pipe[
WRITE_END], 1) == -1)
4050 if (dup2 (errors_pipe[
WRITE_END], 2) == -1)
4055 sigprocmask (SIG_SETMASK, &old_set,
NULL);
4058 if (progpath[0] ==
'/')
4060 execv (progpath, (
char *
const *) argv);
4069 execvp (strrchr (progpath,
'/')+1, (
char *
const *) argv);
4072 execvp (progpath, (
char *
const *) argv);
4094 ret = waitpid (pid, &status, 0);
4096 while (ret == -1 && errno == EINTR);
4100 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
4106 _DBUS_SET_OOM (error);
4120 "%s terminated abnormally with the following error: %s",
4124 "%s terminated abnormally without any error message",
4132 sigprocmask (SIG_SETMASK, &old_set,
NULL);
4134 _DBUS_ASSERT_ERROR_XOR_BOOL (error, retval);
4136 if (result_pipe[0] != -1)
4137 close (result_pipe[0]);
4138 if (result_pipe[1] != -1)
4139 close (result_pipe[1]);
4140 if (errors_pipe[0] != -1)
4141 close (errors_pipe[0]);
4142 if (errors_pipe[1] != -1)
4143 close (errors_pipe[1]);
4166#ifdef DBUS_ENABLE_X11_AUTOLAUNCH
4167 static const char arg_dbus_launch[] =
"dbus-launch";
4168 static const char arg_autolaunch[] =
"--autolaunch";
4169 static const char arg_binary_syntax[] =
"--binary-syntax";
4170 static const char arg_close_stderr[] =
"--close-stderr";
4175 const char *display;
4176 const char *progpath;
4177 const char *argv[6];
4185 "Unable to autolaunch when setuid");
4189 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4202 if (display ==
NULL || display[0] ==
'\0')
4205 "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
4211 _DBUS_SET_OOM (error);
4220#ifdef DBUS_ENABLE_EMBEDDED_TESTS
4223 if (progpath ==
NULL)
4225 progpath = DBUS_BINDIR
"/dbus-launch";
4232 argv[i] = arg_dbus_launch;
4234 argv[i] = arg_autolaunch;
4238 argv[i] = arg_binary_syntax;
4240 argv[i] = arg_close_stderr;
4247 retval = _read_subprocess_line_argv (progpath,
4249 argv, address, error);
4256 "Using X11 for dbus-daemon autolaunch was disabled at compile time, "
4257 "set your DBUS_SESSION_BUS_ADDRESS instead");
4302 if (create_if_not_found)
4314 if (!create_if_not_found)
4317 "D-Bus library appears to be incorrectly set up: "
4318 "see the manual page for dbus-uuidgen to correct "
4319 "this issue. (%s; %s)",
4347 const char *launchd_env_var,
4350#ifdef DBUS_ENABLE_LAUNCHD
4354 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4359 "Unable to find launchd socket when setuid");
4364 argv[i] =
"launchctl";
4368 argv[i] = (
char*)launchd_env_var;
4375 if (!_read_subprocess_line_argv(argv[0],
TRUE, argv, socket_path, error))
4391 "can't lookup socket from launchd; launchd support not compiled in");
4396#ifdef DBUS_ENABLE_LAUNCHD
4406 "Unable to find launchd socket when setuid");
4412 _DBUS_SET_OOM (error);
4427 "launchd did not provide a socket path, "
4428 "verify that org.freedesktop.dbus-session.plist is loaded!");
4434 _DBUS_SET_OOM (error);
4441 _DBUS_SET_OOM (error);
4456 const char *runtime_dir =
_dbus_getenv (
"XDG_RUNTIME_DIR");
4461 if (runtime_dir ==
NULL)
4463 _dbus_verbose (
"XDG_RUNTIME_DIR not found in environment");
4470 _DBUS_SET_OOM (error);
4476 _DBUS_SET_OOM (error);
4482 _dbus_verbose (
"XDG_RUNTIME_DIR/bus not available: %s",
4483 _dbus_strerror (errno));
4489 if (stbuf.st_uid != getuid ())
4491 _dbus_verbose (
"XDG_RUNTIME_DIR/bus owned by uid %ld, not our uid %ld",
4492 (
long) stbuf.st_uid, (
long) getuid ());
4498 if ((stbuf.st_mode & S_IFMT) != S_IFSOCK)
4500 _dbus_verbose (
"XDG_RUNTIME_DIR/bus is not a socket: st_mode = 0o%lo",
4501 (
long) stbuf.st_mode);
4510 _DBUS_SET_OOM (error);
4546#ifdef DBUS_ENABLE_LAUNCHD
4548 return _dbus_lookup_session_address_launchd (address, error);
4552 if (!_dbus_lookup_user_bus (supported, address, error))
4554 else if (*supported)
4612#ifdef DBUS_ENABLE_EMBEDDED_TESTS
4614 const char *
override;
4617 if (
override !=
NULL && *
override !=
'\0')
4623 _dbus_verbose (
"Using fake homedir for testing: %s\n",
4631 if (!already_warned)
4633 _dbus_warn (
"Using %s for testing, set DBUS_TEST_HOMEDIR to avoid",
4635 already_warned =
TRUE;
4661_dbus_daemon_unpublish_session_bus_address (
void)
4679#if EAGAIN == EWOULDBLOCK
4682 return e == EAGAIN || e == EWOULDBLOCK;
4697 const char *filename_c;
4699 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4703 if (rmdir (filename_c) != 0)
4706 "Failed to remove directory %s: %s\n",
4707 filename_c, _dbus_strerror (errno));
4727 struct sockaddr_storage storage;
4728 struct sockaddr_un un;
4731 socklen_t sa_len =
sizeof(sa_buf);
4735 if (getsockname(fd.fd, &sa_buf.sa, &sa_len) < 0)
4738 return sa_buf.sa.sa_family == AF_UNIX;
4751act_on_fds_3_and_up (
void (*func) (
int fd))
4755#if defined(__linux__) && defined(__GLIBC__)
4761 d = opendir (
"/proc/self/fd");
4775 if (de->d_name[0] ==
'.')
4779 l = strtol (de->d_name, &e, 10);
4780 if (errno != 0 || e ==
NULL || *e !=
'\0')
4787 if (fd == dirfd (d))
4798 maxfds = sysconf (_SC_OPEN_MAX);
4807 for (i = 3; i < maxfds; i++)
4814#if defined(HAVE_CLOSEFROM) && ( \
4815 defined(__FreeBSD__) || \
4816 defined(__NetBSD__) || \
4817 defined(__OpenBSD__) || \
4818 defined(__sun__) && defined(F_CLOSEFROM) \
4820#define CLOSEFROM_SIGNAL_SAFE 1
4822#define CLOSEFROM_SIGNAL_SAFE 0
4824close_ignore_error (
int fd)
4837#ifdef HAVE_CLOSE_RANGE
4838 if (close_range (3, INT_MAX, 0) == 0)
4842#if CLOSEFROM_SIGNAL_SAFE
4845 act_on_fds_3_and_up (close_ignore_error);
4856#if defined(HAVE_CLOSE_RANGE) && defined(CLOSE_RANGE_CLOEXEC)
4857 if (close_range (3, INT_MAX, CLOSE_RANGE_CLOEXEC) == 0)
4879#if 0 && defined(HAVE_LIBC_ENABLE_SECURE)
4882 extern int __libc_enable_secure;
4883 return __libc_enable_secure;
4885#elif defined(HAVE_ISSETUGID)
4887 return issetugid ();
4889 uid_t ruid, euid, suid;
4890 gid_t rgid, egid, sgid;
4897 if (_DBUS_UNLIKELY (!check_setuid_initialised))
4899#ifdef HAVE_GETRESUID
4900 if (getresuid (&ruid, &euid, &suid) != 0 ||
4901 getresgid (&rgid, &egid, &sgid) != 0)
4904 suid = ruid = getuid ();
4905 sgid = rgid = getgid ();
4910 check_setuid_initialised =
TRUE;
4911 is_setuid = (ruid != euid || ruid != suid ||
4912 rgid != egid || rgid != sgid);
4933 struct sockaddr_storage storage;
4934 struct sockaddr_un un;
4935 struct sockaddr_in ipv4;
4936 struct sockaddr_in6 ipv6;
4938 char hostip[INET6_ADDRSTRLEN];
4939 socklen_t size =
sizeof (socket);
4941 const char *family_name =
NULL;
4944 if (getsockname (fd.fd, &socket.sa, &size))
4947 switch (socket.sa.sa_family)
4950 if (socket.un.sun_path[0]==
'\0')
4960 _DBUS_SET_OOM (error);
4974 _DBUS_SET_OOM (error);
4987 if (_dbus_inet_sockaddr_to_string (&socket, size, hostip,
sizeof (hostip),
4988 &family_name, &port, error))
4991 family_name, port) &&
4998 _DBUS_SET_OOM (error);
5012 "Failed to read address from socket: Unknown socket type.");
5018 "Failed to read address from socket: %s",
5019 _dbus_strerror (errno));
5024_dbus_save_socket_errno (
void)
5030_dbus_restore_socket_errno (
int saved_errno)
5032 errno = saved_errno;
5035static const char *syslog_tag =
"dbus";
5037static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
5060 (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
5067 if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
5068 openlog (tag, LOG_PID, LOG_DAEMON);
5086 if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
5091 case DBUS_SYSTEM_LOG_INFO:
5092 flags = LOG_DAEMON | LOG_INFO;
5094 case DBUS_SYSTEM_LOG_WARNING:
5095 flags = LOG_DAEMON | LOG_WARNING;
5097 case DBUS_SYSTEM_LOG_SECURITY:
5098 flags = LOG_AUTH | LOG_NOTICE;
5100 case DBUS_SYSTEM_LOG_ERROR:
5101 flags = LOG_DAEMON|LOG_CRIT;
5107 va_copy (tmp, args);
5108 vsyslog (flags, msg, tmp);
5114 if (log_flags & DBUS_LOG_FLAGS_STDERR)
5117 va_copy (tmp, args);
5119 vfprintf (stderr, msg, tmp);
5120 fputc (
'\n', stderr);
5134_dbus_get_low_level_socket_errno (
void)
dbus_bool_t _dbus_address_append_escaped(DBusString *escaped, const DBusString *unescaped)
Appends an escaped version of one string to another string, using the D-Bus address escaping mechanis...
void _dbus_credentials_clear(DBusCredentials *credentials)
Clear all credentials in the object.
dbus_uid_t _dbus_credentials_get_unix_uid(DBusCredentials *credentials)
Gets the UNIX user ID in the credentials, or DBUS_UID_UNSET if the credentials object doesn't contain...
dbus_bool_t _dbus_credentials_add_linux_security_label(DBusCredentials *credentials, const char *label)
Add a Linux security label, as used by LSMs such as SELinux, Smack and AppArmor, to the credentials.
void _dbus_credentials_take_unix_gids(DBusCredentials *credentials, dbus_gid_t *gids, size_t n_gids)
Add UNIX group IDs to the credentials, replacing any group IDs that might already have been present.
dbus_bool_t _dbus_credentials_add_unix_uid(DBusCredentials *credentials, dbus_uid_t uid)
Add a UNIX user ID to the credentials.
dbus_bool_t _dbus_credentials_add_pid(DBusCredentials *credentials, dbus_pid_t pid)
Add a UNIX process ID to the credentials.
dbus_bool_t _dbus_credentials_add_adt_audit_data(DBusCredentials *credentials, void *audit_data, dbus_int32_t size)
Add ADT audit data to the credentials.
dbus_bool_t _dbus_credentials_are_anonymous(DBusCredentials *credentials)
Checks whether a credentials object contains a user identity.
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
void dbus_set_error_const(DBusError *error, const char *name, const char *message)
Assigns an error name and message to a DBusError.
void dbus_error_init(DBusError *error)
Initializes a DBusError structure.
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
void dbus_error_free(DBusError *error)
Frees an error that's been set (or just initialized), then reinitializes the error as in dbus_error_i...
dbus_bool_t dbus_error_is_set(const DBusError *error)
Checks whether an error occurred (the error is set).
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
#define READ_END
Helps remember which end of the pipe is which.
#define WRITE_END
Helps remember which end of the pipe is which.
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary.
const char * _dbus_error_from_errno(int error_number)
Converts a UNIX errno, or Windows errno or WinSock error value into a DBusError name.
dbus_bool_t _dbus_generate_uuid(DBusGUID *uuid, DBusError *error)
Generates a new UUID.
char * _dbus_strdup(const char *str)
Duplicates a string.
dbus_bool_t _dbus_read_uuid_file(const DBusString *filename, DBusGUID *uuid, dbus_bool_t create_if_not_found, DBusError *error)
Reads (and optionally writes) a uuid to a file.
void _dbus_user_database_flush_system(void)
Flushes the system global user database;.
dbus_bool_t _dbus_get_local_machine_uuid_encoded(DBusString *uuid_str, DBusError *error)
Gets the hex-encoded UUID of the machine this function is executed on.
dbus_bool_t _dbus_write_uuid_file(const DBusString *filename, const DBusGUID *uuid, DBusError *error)
Write the give UUID to a file.
dbus_bool_t _dbus_homedir_from_uid(dbus_uid_t uid, DBusString *homedir)
Gets the home directory for the given user.
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof().
#define _DBUS_ZERO(object)
Sets all bits in an object to zero.
#define _DBUS_INT32_MAX
Maximum value of type "int32".
void * _dbus_list_pop_first(DBusList **list)
Removes the first value in the list and returns it.
dbus_bool_t _dbus_list_append(DBusList **list, void *data)
Appends a value to the list.
#define NULL
A null pointer, defined appropriately for C or C++.
#define TRUE
Expands to "1".
#define FALSE
Expands to "0".
DBUS_PRIVATE_EXPORT void _dbus_verbose_bytes_of_string(const DBusString *str, int start, int len)
Dump the given part of the string to verbose log.
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
void * dbus_realloc(void *memory, size_t bytes)
Resizes a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
#define DBUS_MAXIMUM_MESSAGE_UNIX_FDS
The maximum total number of unix fds in a message.
#define DBUS_ERROR_NOT_SUPPORTED
Requested operation isn't supported (like ENOSYS on UNIX).
#define DBUS_ERROR_BAD_ADDRESS
A D-Bus bus address was malformed.
#define DBUS_ERROR_IO_ERROR
Something went wrong reading or writing to a socket, for example.
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
#define DBUS_ERROR_SPAWN_EXEC_FAILED
While starting a new process, the exec() call failed.
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
dbus_bool_t _dbus_string_init_preallocated(DBusString *str, int allocate_size)
Initializes a string that can be up to the given allocation size before it has to realloc.
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
char * _dbus_string_get_data(DBusString *str)
Gets the raw character buffer from the string.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(), and fills it with the same contents as #_DBUS_STRING_I...
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
int _dbus_string_get_length(const DBusString *str)
Gets the length of a string (not including nul termination).
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_append_uint(DBusString *str, unsigned long value)
Appends an unsigned integer to a DBusString.
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
dbus_bool_t _dbus_string_append_printf(DBusString *str, const char *format,...)
Appends a printf-style formatted string to the DBusString.
const char * _dbus_string_get_const_data_len(const DBusString *str, int start, int len)
const version of _dbus_string_get_data_len().
const char * _dbus_string_get_const_data(const DBusString *str)
Gets the raw character buffer from a const string.
unsigned char _dbus_string_get_byte(const DBusString *str, int start)
Gets the byte at the given position.
void _dbus_fd_clear_close_on_exec(int fd)
Sets the file descriptor to not be close-on-exec.
void _dbus_fd_set_all_close_on_exec(void)
Sets all file descriptors except the first three (i.e.
dbus_bool_t _dbus_close(int fd, DBusError *error)
Closes a file descriptor.
int _dbus_write(int fd, const DBusString *buffer, int start, int len)
Thin wrapper around the write() system call that writes a part of a DBusString and handles EINTR for ...
int _dbus_write_two(int fd, const DBusString *buffer1, int start1, int len1, const DBusString *buffer2, int start2, int len2)
Like _dbus_write() but will use writev() if possible to write both buffers in sequence.
dbus_bool_t _dbus_lookup_launchd_socket(DBusString *socket_path, const char *launchd_env_var, DBusError *error)
quries launchd for a specific env var which holds the socket path.
int _dbus_listen_systemd_sockets(DBusSocket **fds, DBusError *error)
Acquires one or more sockets passed in from systemd.
dbus_bool_t _dbus_append_address_from_socket(DBusSocket fd, DBusString *address, DBusError *error)
Read the address from the socket and append it to the string.
dbus_bool_t _dbus_user_info_fill(DBusUserInfo *info, const DBusString *username, DBusError *error)
Gets user info for the given username.
void _dbus_close_all(void)
Closes all file descriptors except the first three (i.e.
int _dbus_dup(int fd, DBusError *error)
Duplicates a file descriptor.
void _dbus_fd_set_close_on_exec(int fd)
Sets the file descriptor to be close on exec.
int _dbus_read(int fd, DBusString *buffer, int count)
Thin wrapper around the read() system call that appends the data it reads to the DBusString buffer.
dbus_bool_t _dbus_ensure_standard_fds(DBusEnsureStandardFdsFlags flags, const char **error_str_p)
Ensure that the standard file descriptors stdin, stdout and stderr are open, by opening /dev/null if ...
dbus_uid_t _dbus_geteuid(void)
Gets our effective UID.
dbus_bool_t _dbus_user_info_fill_uid(DBusUserInfo *info, dbus_uid_t uid, DBusError *error)
Gets user info for the given user ID.
void _dbus_logv(DBusSystemLogSeverity severity, const char *msg, va_list args)
Log a message to the system log file (e.g.
dbus_bool_t _dbus_read_local_machine_uuid(DBusGUID *machine_id, dbus_bool_t create_if_not_found, DBusError *error)
Reads the uuid of the machine we're running on from the dbus configuration.
#define _DBUS_POLLOUT
Writing now will not block.
unsigned long dbus_uid_t
A user ID.
dbus_bool_t _dbus_get_is_errno_eagain_or_ewouldblock(int e)
See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently for Winsock so is abstracted)
unsigned long _dbus_pid_for_log(void)
The only reason this is separate from _dbus_getpid() is to allow it on Windows for logging but not fo...
unsigned long dbus_pid_t
A process ID.
int _dbus_read_socket(DBusSocket fd, DBusString *buffer, int count)
Like _dbus_read(), but only works on sockets so is available on Windows.
void _dbus_exit(int code)
Exit the process, returning the given value.
#define _DBUS_POLLERR
Error condition.
dbus_bool_t _dbus_socket_can_pass_unix_fd(DBusSocket fd)
Checks whether file descriptors may be passed via the socket.
int _dbus_write_socket(DBusSocket fd, const DBusString *buffer, int start, int len)
Like _dbus_write(), but only supports sockets and is thus available on Windows.
void _dbus_atomic_set_nonzero(DBusAtomic *atomic)
Atomically set the value of an integer to something nonzero.
dbus_bool_t _dbus_socketpair(DBusSocket *fd1, DBusSocket *fd2, dbus_bool_t blocking, DBusError *error)
Creates pair of connect sockets (as in socketpair()).
unsigned long dbus_gid_t
A group ID.
int _dbus_read_socket_with_unix_fds(DBusSocket fd, DBusString *buffer, int count, int *fds, unsigned int *n_fds)
Like _dbus_read_socket() but also tries to read unix fds from the socket.
dbus_bool_t _dbus_append_keyring_directory_for_credentials(DBusString *directory, DBusCredentials *credentials)
Appends the directory in which a keyring for the given credentials should be stored.
#define DBUS_UID_UNSET
an invalid UID used to represent an uninitialized dbus_uid_t field
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
dbus_bool_t _dbus_read_credentials_socket(DBusSocket client_fd, DBusCredentials *credentials, DBusError *error)
Reads a single byte which must be nul (an error occurs otherwise), and reads unix credentials if avai...
#define DBUS_PID_UNSET
an invalid PID used to represent an uninitialized dbus_pid_t field
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
DBusSocket _dbus_listen_unix_socket(const char *path, dbus_bool_t abstract, DBusError *error)
Creates a socket and binds it to the given path, then listens on the socket.
dbus_pid_t _dbus_getpid(void)
Gets our process ID.
dbus_int32_t _dbus_atomic_get(DBusAtomic *atomic)
Atomically get the value of an integer.
dbus_bool_t _dbus_set_socket_nonblocking(DBusSocket fd, DBusError *error)
Sets a file descriptor to be nonblocking.
dbus_bool_t _dbus_lookup_session_address(dbus_bool_t *supported, DBusString *address, DBusError *error)
Determines the address of the session bus by querying a platform-specific method.
DBusSocket _dbus_connect_tcp_socket(const char *host, const char *port, const char *family, DBusError *error)
Creates a socket and connects to a socket at the given host and port.
void _dbus_disable_sigpipe(void)
signal (SIGPIPE, SIG_IGN);
dbus_bool_t _dbus_check_setuid(void)
NOTE: If you modify this function, please also consider making the corresponding change in GLib.
void _dbus_sleep_milliseconds(int milliseconds)
Sleeps the given number of milliseconds.
#define DBUS_GID_UNSET
an invalid GID used to represent an uninitialized dbus_gid_t field
dbus_bool_t _dbus_check_dir_is_private_to_user(DBusString *dir, DBusError *error)
Checks to make sure the given directory is private to the user.
#define _DBUS_POLLIN
There is data to read.
int _dbus_listen_tcp_socket(const char *host, const char *port, const char *family, DBusString *retport, const char **retfamily, DBusSocket **fds_p, DBusError *error)
Creates a socket and binds it to the given path, then listens on the socket.
dbus_bool_t _dbus_send_credentials_socket(DBusSocket server_fd, DBusError *error)
Sends a single nul byte with our UNIX credentials as ancillary data.
dbus_uid_t _dbus_getuid(void)
Gets our UID.
dbus_bool_t _dbus_credentials_add_from_current_process(DBusCredentials *credentials)
Adds the most important credentials of the current process (the uid and pid) to the passed-in credent...
dbus_bool_t _dbus_close_socket(DBusSocket *fd, DBusError *error)
Closes a socket and invalidates it.
DBusSocket _dbus_connect_unix_socket(const char *path, dbus_bool_t abstract, DBusError *error)
Creates a socket and connects it to the UNIX domain socket at the given path.
void _dbus_atomic_set_zero(DBusAtomic *atomic)
Atomically set the value of an integer to 0.
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
dbus_bool_t _dbus_generate_random_bytes(DBusString *str, int n_bytes, DBusError *error)
Generates the given number of securely random bytes, using the best mechanism we can come up with.
#define DBUS_GID_FORMAT
an appropriate printf format for dbus_gid_t
int _dbus_printf_string_upper_bound(const char *format, va_list args)
Measure the length of the given format string and arguments, not including the terminating nul.
void _dbus_get_monotonic_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
dbus_bool_t _dbus_delete_directory(const DBusString *filename, DBusError *error)
Removes a directory; Directory must be empty.
#define DBUS_UID_FORMAT
an appropriate printf format for dbus_uid_t
void _dbus_get_real_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll().
dbus_bool_t _dbus_get_autolaunch_address(const char *scope, DBusString *address, DBusError *error)
Returns the address of a new session bus.
int _dbus_write_socket_two(DBusSocket fd, const DBusString *buffer1, int start1, int len1, const DBusString *buffer2, int start2, int len2)
Like _dbus_write_two() but only works on sockets and is thus available on Windows.
dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory.
DBusSocket _dbus_connect_exec(const char *path, char *const argv[], DBusError *error)
Creates a UNIX domain socket and connects it to the specified process to execute.
void _dbus_print_backtrace(void)
On GNU libc systems, print a crude backtrace to stderr.
void _dbus_init_system_log(const char *tag, DBusLogFlags flags)
Initialize the system log.
DBusSocket _dbus_accept(DBusSocket listen_fd)
Accepts a connection on a listening socket.
#define _DBUS_MAX_SUN_PATH_LENGTH
Maximum length of the path to a UNIX domain socket, sockaddr_un::sun_path member.
dbus_bool_t _dbus_append_user_from_current_process(DBusString *str)
Append to the string the identity we would like to have when we authenticate, on UNIX this is the cur...
void _dbus_flush_caches(void)
Called when the bus daemon is signaled to reload its configuration; any caches should be nuked.
const char * _dbus_get_tmpdir(void)
Gets the temporary files directory by inspecting the environment variables TMPDIR,...
#define DBUS_PID_FORMAT
an appropriate printf format for dbus_pid_t
dbus_bool_t _dbus_ensure_directory(const DBusString *filename, DBusError *error)
Creates a directory; succeeds if the directory is created or already existed.
dbus_bool_t _dbus_create_directory(const DBusString *filename, DBusError *error)
Creates a directory.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
unsigned short dbus_uint16_t
A 16-bit unsigned integer on all platforms.
int dbus_int32_t
A 32-bit signed integer on all platforms.
An atomic integer safe to increment or decrement from multiple threads.
volatile dbus_int32_t value
Value of the atomic integer.
Object representing an exception.
const char * name
public error name field
const char * message
public error message field
short events
Events to poll for.
short revents
Events that occurred.
DBusPollable fd
File descriptor.
Information about a UNIX user.
int n_group_ids
Size of group IDs array.
char * homedir
Home directory.
dbus_gid_t * group_ids
Groups IDs, including above primary group.
dbus_gid_t primary_gid
GID.
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...