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-file.h"
33 #include "dbus-transport.h"
34 #include "dbus-string.h"
35 #include "dbus-userdb.h"
36 #include "dbus-list.h"
37 #include "dbus-credentials.h"
38 #include "dbus-nonce.h"
41 #include <sys/types.h>
48 #include <sys/socket.h>
57 #include <netinet/in.h>
58 #include <netinet/tcp.h>
61 #include <arpa/inet.h>
66 #ifdef HAVE_LINUX_CLOSE_RANGE_H
67 #include <linux/close_range.h>
78 #ifdef HAVE_GETPEERUCRED
84 #ifdef HAVE_SYS_RANDOM_H
85 #include <sys/random.h>
87 #ifdef HAVE_SYS_SYSCALL_H
88 #include <sys/syscall.h>
96 #include <systemd/sd-daemon.h>
107 #ifndef AI_ADDRCONFIG
108 #define AI_ADDRCONFIG 0
111 #ifndef HAVE_SOCKLEN_T
112 #define socklen_t int
115 #if defined (__sun) || defined (__sun__)
128 # define CMSG_ALIGN(len) _CMSG_DATA_ALIGN (len)
131 # define CMSG_ALIGN(len) (((len) + sizeof (long) - 1) & \
132 ~(sizeof (long) - 1))
137 # define CMSG_SPACE(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + \
142 # define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
147 #if defined(__linux__) && defined(__NR_close_range) && !defined(HAVE_CLOSE_RANGE)
152 close_range (
unsigned int first,
156 return syscall (__NR_close_range, first, last, flags);
159 #define HAVE_CLOSE_RANGE
178 const char **error_str_p)
180 static int const relevant_flag[] = { DBUS_FORCE_STDIN_NULL,
181 DBUS_FORCE_STDOUT_NULL,
182 DBUS_FORCE_STDERR_NULL };
184 const char *error_str =
"Failed mysteriously";
188 _DBUS_STATIC_ASSERT (STDIN_FILENO == 0);
189 _DBUS_STATIC_ASSERT (STDOUT_FILENO == 1);
190 _DBUS_STATIC_ASSERT (STDERR_FILENO == 2);
193 for (i = STDIN_FILENO; i <= STDERR_FILENO; i++)
199 devnull = open (
"/dev/null", O_RDWR);
203 error_str =
"Failed to open /dev/null";
212 if (devnull != i && (flags & relevant_flag[i]) != 0)
214 if (dup2 (devnull, i) < 0)
216 error_str =
"Failed to dup2 /dev/null onto a standard fd";
227 if (devnull > STDERR_FILENO)
230 if (error_str_p !=
NULL)
231 *error_str_p = error_str;
234 return (error_str ==
NULL);
237 static dbus_bool_t _dbus_set_fd_nonblocking (
int fd,
241 _dbus_open_socket (
int *fd_p,
250 *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
251 cloexec_done = *fd_p >= 0;
254 if (*fd_p < 0 && (errno == EINVAL || errno == EPROTOTYPE))
257 *fd_p = socket (domain, type, protocol);
269 _dbus_verbose (
"socket fd %d opened\n", *fd_p);
276 "Failed to open socket: %s",
277 _dbus_strerror (errno));
293 _dbus_open_unix_socket (
int *fd,
296 return _dbus_open_socket(fd, AF_UNIX, SOCK_STREAM, 0, error);
318 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
321 _dbus_socket_invalidate (fd);
359 #if HAVE_DECL_MSG_NOSIGNAL
363 data = _dbus_string_get_const_data_len (buffer, start, len);
367 bytes_written = send (fd.fd, data, len, MSG_NOSIGNAL);
369 if (bytes_written < 0 && errno == EINTR)
372 return bytes_written;
396 unsigned int *n_fds) {
397 #ifndef HAVE_UNIX_FD_PASSING
415 start = _dbus_string_get_length (buffer);
435 m.msg_controllen = CMSG_SPACE(*n_fds *
sizeof(
int));
439 m.msg_control = alloca(m.msg_controllen);
440 memset(m.msg_control, 0, m.msg_controllen);
446 m.msg_controllen = CMSG_LEN (*n_fds *
sizeof(
int));
450 bytes_read = recvmsg (fd.fd, &m, 0
451 #ifdef MSG_CMSG_CLOEXEC
472 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
473 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
476 int *payload = (
int *) (
void *) CMSG_DATA (cm);
477 size_t payload_len_bytes = (cm->cmsg_len - CMSG_LEN (0));
478 size_t payload_len_fds;
483 _DBUS_STATIC_ASSERT (
sizeof (
size_t) >=
sizeof (
unsigned int));
485 if ((m.msg_flags & MSG_CTRUNC) && CMSG_NXTHDR(&m, cm) ==
NULL &&
486 (
char *) payload + payload_len_bytes >
487 (
char *) m.msg_control + m.msg_controllen)
498 payload_len_bytes = m.msg_controllen -
499 ((
char *) payload - (
char *) m.msg_control);
502 payload_len_fds = payload_len_bytes /
sizeof (int);
504 if (_DBUS_LIKELY (payload_len_fds <= (
size_t) *n_fds))
507 fds_to_use = payload_len_fds;
515 fds_to_use = (size_t) *n_fds;
520 for (i = fds_to_use; i < payload_len_fds; i++)
526 memcpy (fds, payload, fds_to_use *
sizeof (
int));
531 *n_fds = (
unsigned int) fds_to_use;
536 for (i = 0; i < fds_to_use; i++)
545 if (m.msg_flags & MSG_CTRUNC)
556 for (i = 0; i < *n_fds; i++)
579 _dbus_write_socket_with_unix_fds(
DBusSocket fd,
586 #ifndef HAVE_UNIX_FD_PASSING
595 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len,
NULL, 0, 0, fds, n_fds);
600 _dbus_write_socket_with_unix_fds_two(
DBusSocket fd,
610 #ifndef HAVE_UNIX_FD_PASSING
618 buffer1, start1, len1,
619 buffer2, start2, len2);
632 iov[0].iov_base = (
char*) _dbus_string_get_const_data_len (buffer1, start1, len1);
633 iov[0].iov_len = len1;
637 iov[1].iov_base = (
char*) _dbus_string_get_const_data_len (buffer2, start2, len2);
638 iov[1].iov_len = len2;
643 m.msg_iovlen = buffer2 ? 2 : 1;
647 m.msg_controllen = CMSG_SPACE(n_fds *
sizeof(
int));
648 m.msg_control = alloca(m.msg_controllen);
649 memset(m.msg_control, 0, m.msg_controllen);
651 cm = CMSG_FIRSTHDR(&m);
652 cm->cmsg_level = SOL_SOCKET;
653 cm->cmsg_type = SCM_RIGHTS;
654 cm->cmsg_len = CMSG_LEN(n_fds *
sizeof(
int));
655 memcpy(CMSG_DATA(cm), fds, n_fds *
sizeof(
int));
660 bytes_written = sendmsg (fd.fd, &m, 0
661 #
if HAVE_DECL_MSG_NOSIGNAL
666 if (bytes_written < 0 && errno == EINTR)
670 if (bytes_written > 0)
674 return bytes_written;
700 #if HAVE_DECL_MSG_NOSIGNAL
701 struct iovec vectors[2];
713 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
716 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
724 vectors[0].iov_base = (
char*) data1;
725 vectors[0].iov_len = len1;
726 vectors[1].iov_base = (
char*) data2;
727 vectors[1].iov_len = len2;
731 m.msg_iovlen = data2 ? 2 : 1;
735 bytes_written = sendmsg (fd.fd, &m, MSG_NOSIGNAL);
737 if (bytes_written < 0 && errno == EINTR)
740 return bytes_written;
744 buffer2, start2, len2);
775 start = _dbus_string_get_length (buffer);
787 bytes_read = read (fd, data, count);
833 data = _dbus_string_get_const_data_len (buffer, start, len);
837 bytes_written = write (fd, data, len);
839 if (bytes_written < 0 && errno == EINTR)
843 if (bytes_written > 0)
847 return bytes_written;
887 struct iovec vectors[2];
892 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
895 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
903 vectors[0].iov_base = (
char*) data1;
904 vectors[0].iov_len = len1;
905 vectors[1].iov_base = (
char*) data2;
906 vectors[1].iov_len = len2;
910 bytes_written = writev (fd,
914 if (bytes_written < 0 && errno == EINTR)
917 return bytes_written;
924 if (ret1 == len1 && buffer2 !=
NULL)
961 struct sockaddr_un addr;
964 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
966 _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
970 if (!_dbus_open_unix_socket (&fd.fd, error))
972 _DBUS_ASSERT_ERROR_IS_SET(error);
975 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
978 addr.sun_family = AF_UNIX;
979 path_len = strlen (path);
984 addr.sun_path[0] =
'\0';
990 "Abstract socket name too long\n");
995 strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
999 "Operating system does not support abstract socket namespace\n");
1009 "Socket name too long\n");
1014 strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
1017 if (connect (fd.fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1021 "Failed to connect to socket %s: %s",
1022 path, _dbus_strerror (errno));
1028 if (!_dbus_set_fd_nonblocking (fd.fd, error))
1030 _DBUS_ASSERT_ERROR_IS_SET (error);
1062 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1064 _dbus_verbose (
"connecting to process %s\n", path);
1067 retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
1068 cloexec_done = (retval >= 0);
1070 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
1073 retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
1080 "Failed to create socket pair: %s",
1081 _dbus_strerror (errno));
1102 "Failed to fork() to call %s: %s",
1103 path, _dbus_strerror (errno));
1115 dup2 (fds[1], STDIN_FILENO);
1116 dup2 (fds[1], STDOUT_FILENO);
1118 if (fds[1] != STDIN_FILENO &&
1119 fds[1] != STDOUT_FILENO)
1127 execvp (path, (
char *
const *) argv);
1129 fprintf (stderr,
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
1137 if (!_dbus_set_fd_nonblocking (fds[0], error))
1139 _DBUS_ASSERT_ERROR_IS_SET (error);
1174 struct sockaddr_un addr;
1178 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1180 _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
1183 if (!_dbus_open_unix_socket (&listen_fd, error))
1185 _DBUS_ASSERT_ERROR_IS_SET(error);
1188 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1191 addr.sun_family = AF_UNIX;
1192 path_len = strlen (path);
1200 addr.sun_path[0] =
'\0';
1206 "Abstract socket name too long\n");
1211 strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
1215 "Operating system does not support abstract socket namespace\n");
1235 if (stat (path, &sb) == 0 &&
1236 S_ISSOCK (sb.st_mode))
1243 "Socket name too long\n");
1248 strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
1251 if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1254 "Failed to bind socket \"%s\": %s",
1255 path, _dbus_strerror (errno));
1260 if (listen (listen_fd, SOMAXCONN ) < 0)
1263 "Failed to listen on socket \"%s\": %s",
1264 path, _dbus_strerror (errno));
1269 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1271 _DBUS_ASSERT_ERROR_IS_SET (error);
1279 if (!
abstract && chmod (path, 0777) < 0)
1280 _dbus_warn (
"Could not set mode 0777 on socket %s", path);
1305 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1307 n = sd_listen_fds (
TRUE);
1311 "Failed to acquire systemd socket: %s",
1312 _dbus_strerror (-n));
1319 "No socket received.");
1323 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1325 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1329 "Failed to verify systemd socket type: %s",
1330 _dbus_strerror (-r));
1337 "Passed socket has wrong type.");
1349 "Failed to allocate file handle array.");
1353 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1355 if (!_dbus_set_fd_nonblocking (fd, error))
1357 _DBUS_ASSERT_ERROR_IS_SET (error);
1361 new_fds[fd - SD_LISTEN_FDS_START].fd = fd;
1369 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1378 "dbus was compiled without systemd support");
1386 _dbus_error_from_gai (
int gai_res,
1452 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
1456 _dbus_connect_tcp_socket_with_nonce (
const char *host,
1459 const char *noncefile,
1462 int saved_errno = 0;
1466 struct addrinfo hints;
1467 struct addrinfo *ai =
NULL;
1468 const struct addrinfo *tmp;
1471 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1476 hints.ai_family = AF_UNSPEC;
1477 else if (!strcmp(family,
"ipv4"))
1478 hints.ai_family = AF_INET;
1479 else if (!strcmp(family,
"ipv6"))
1480 hints.ai_family = AF_INET6;
1485 "Unknown address family %s", family);
1486 return _dbus_socket_get_invalid ();
1488 hints.ai_protocol = IPPROTO_TCP;
1489 hints.ai_socktype = SOCK_STREAM;
1490 hints.ai_flags = AI_ADDRCONFIG;
1492 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1495 _dbus_error_from_gai (res, errno),
1496 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1497 host, port, gai_strerror(res), res);
1504 if (!_dbus_open_socket (&fd.fd, tmp->ai_family, SOCK_STREAM, 0, error))
1506 _DBUS_ASSERT_ERROR_IS_SET(error);
1507 _dbus_socket_invalidate (&fd);
1510 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1512 if (connect (fd.fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1514 saved_errno = errno;
1519 if (connect_error ==
NULL)
1521 _DBUS_SET_OOM (error);
1526 _dbus_set_error_with_inet_sockaddr (connect_error,
1527 tmp->ai_addr, tmp->ai_addrlen,
1528 "Failed to connect to socket",
1535 _DBUS_SET_OOM (error);
1546 if (!_dbus_socket_is_valid (fd))
1548 _dbus_combine_tcp_errors (&connect_errors,
"Failed to connect",
1553 if (noncefile !=
NULL)
1558 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1567 if (!_dbus_set_fd_nonblocking (fd.fd, error))
1608 const char **retfamily,
1613 int nlisten_fd = 0, res, i;
1617 struct addrinfo hints;
1618 struct addrinfo *ai, *tmp;
1619 unsigned int reuseaddr;
1624 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1629 hints.ai_family = AF_UNSPEC;
1630 else if (!strcmp(family,
"ipv4"))
1631 hints.ai_family = AF_INET;
1632 else if (!strcmp(family,
"ipv6"))
1633 hints.ai_family = AF_INET6;
1638 "Unknown address family %s", family);
1642 hints.ai_protocol = IPPROTO_TCP;
1643 hints.ai_socktype = SOCK_STREAM;
1644 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1646 redo_lookup_with_port:
1648 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1651 _dbus_error_from_gai (res, errno),
1652 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1653 host ? host :
"*", port, gai_strerror(res), res);
1660 int fd = -1, tcp_nodelay_on;
1663 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1665 _DBUS_ASSERT_ERROR_IS_SET(error);
1668 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1671 if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1673 _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
1674 host ? host :
"*", port, _dbus_strerror (errno));
1680 if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay_on,
sizeof (tcp_nodelay_on)) == -1)
1682 _dbus_warn (
"Failed to set TCP_NODELAY socket option \"%s:%s\": %s",
1683 host ? host :
"*", port, _dbus_strerror (errno));
1686 if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1688 saved_errno = errno;
1712 if (bind_error ==
NULL)
1714 _DBUS_SET_OOM (error);
1719 _dbus_set_error_with_inet_sockaddr (bind_error, tmp->ai_addr, tmp->ai_addrlen,
1720 "Failed to bind socket",
1727 _DBUS_SET_OOM (error);
1736 if (listen (fd, 30 ) < 0)
1738 saved_errno = errno;
1740 _dbus_set_error_with_inet_sockaddr (error, tmp->ai_addr, tmp->ai_addrlen,
1741 "Failed to listen on socket",
1751 "Failed to allocate file handle array");
1754 listen_fd = newlisten_fd;
1755 listen_fd[nlisten_fd].fd = fd;
1758 if (tmp->ai_addr->sa_family == AF_INET)
1760 else if (tmp->ai_addr->sa_family == AF_INET6)
1763 if (!_dbus_string_get_length(retport))
1769 if (!port || !strcmp(port,
"0"))
1772 struct sockaddr_storage addr;
1776 addrlen =
sizeof(addr);
1777 result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
1781 saved_errno = errno;
1783 "Failed to retrieve socket name for \"%s:%s\": %s",
1784 host ? host :
"*", port, _dbus_strerror (saved_errno));
1788 if ((res = getnameinfo ((
struct sockaddr*)&addr, addrlen,
NULL, 0,
1789 portbuf,
sizeof(portbuf),
1790 NI_NUMERICHOST | NI_NUMERICSERV)) != 0)
1792 saved_errno = errno;
1794 "Failed to resolve port \"%s:%s\": %s (%d)",
1795 host ? host :
"*", port, gai_strerror(res), res);
1806 port = _dbus_string_get_const_data(retport);
1808 goto redo_lookup_with_port;
1827 _dbus_combine_tcp_errors (&bind_errors,
"Failed to bind", host,
1832 if (have_ipv4 && !have_ipv6)
1833 *retfamily =
"ipv4";
1834 else if (!have_ipv4 && have_ipv6)
1835 *retfamily =
"ipv6";
1837 for (i = 0 ; i < nlisten_fd ; i++)
1839 if (!_dbus_set_fd_nonblocking (listen_fd[i].fd, error))
1860 for (i = 0 ; i < nlisten_fd ; i++)
1874 write_credentials_byte (
int server_fd,
1878 char buf[1] = {
'\0' };
1879 #if defined(HAVE_CMSGCRED)
1882 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1893 msg.msg_control = (caddr_t) &cmsg;
1894 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1896 cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
1897 cmsg.hdr.cmsg_level = SOL_SOCKET;
1898 cmsg.hdr.cmsg_type = SCM_CREDS;
1901 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1905 #if defined(HAVE_CMSGCRED)
1906 bytes_written = sendmsg (server_fd, &msg, 0
1907 #
if HAVE_DECL_MSG_NOSIGNAL
1915 if (bytes_written < 0 && errno == EINVAL)
1918 bytes_written = send (server_fd, buf, 1, 0
1919 #
if HAVE_DECL_MSG_NOSIGNAL
1925 if (bytes_written < 0 && errno == EINTR)
1928 if (bytes_written < 0)
1931 "Failed to write credentials byte: %s",
1932 _dbus_strerror (errno));
1935 else if (bytes_written == 0)
1938 "wrote zero bytes writing credentials byte");
1944 _dbus_verbose (
"wrote credentials byte\n");
1951 add_groups_to_credentials (
int client_fd,
1955 #if defined(__linux__) && defined(SO_PEERGROUPS)
1956 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
1958 socklen_t len = 1024;
1966 n_gids = ((size_t) len) /
sizeof (gid_t);
1972 while (getsockopt (client_fd, SOL_SOCKET, SO_PEERGROUPS, buf, &len) < 0)
1977 _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
1978 _dbus_strerror (e), (
unsigned long) len);
1980 if (e != ERANGE || (
size_t) len <= n_gids *
sizeof (gid_t))
1982 _dbus_verbose (
"Failed to getsockopt(SO_PEERGROUPS): %s\n",
1983 _dbus_strerror (e));
1989 n_gids = ((size_t) len) /
sizeof (gid_t);
1992 if (replacement ==
NULL)
1999 _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
2004 _dbus_verbose (
"getsockopt(SO_PEERGROUPS) yielded <= 0 bytes: %ld\n",
2009 if (len > n_gids *
sizeof (gid_t))
2011 _dbus_verbose (
"%lu > %zu", (
unsigned long) len, n_gids *
sizeof (gid_t));
2015 if (len %
sizeof (gid_t) != 0)
2017 _dbus_verbose (
"getsockopt(SO_PEERGROUPS) did not return an "
2018 "integer multiple of sizeof(gid_t): %lu should be "
2020 (
unsigned long) len,
sizeof (gid_t));
2025 n_gids = ((size_t) len) /
sizeof (gid_t);
2033 _dbus_verbose (
"getsockopt(SO_PEERGROUPS) returned a huge number "
2034 "of groups (%lu bytes), ignoring",
2035 (
unsigned long) len);
2041 if (converted_gids ==
NULL)
2047 for (i = 0; i < n_gids; i++)
2051 if (converted_gids[i] == primary)
2052 need_primary =
FALSE;
2057 converted_gids[n_gids] = primary;
2074 add_linux_security_label_to_credentials (
int client_fd,
2077 #if defined(__linux__) && defined(SO_PEERSEC)
2079 socklen_t len = 1024;
2086 while (getsockopt (client_fd, SOL_SOCKET, SO_PEERSEC,
2087 _dbus_string_get_data (&buf), &len) < 0)
2091 _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
2092 _dbus_strerror (e), (
unsigned long) len);
2094 if (e != ERANGE || len <= _dbus_string_get_length_uint (&buf))
2096 _dbus_verbose (
"Failed to getsockopt(SO_PEERSEC): %s\n",
2097 _dbus_strerror (e));
2109 _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
2114 _dbus_verbose (
"getsockopt(SO_PEERSEC) yielded <= 0 bytes: %lu\n",
2115 (
unsigned long) len);
2119 if (len > _dbus_string_get_length_uint (&buf))
2121 _dbus_verbose (
"%lu > %u", (
unsigned long) len,
2122 _dbus_string_get_length_uint (&buf));
2126 if (_dbus_string_get_byte (&buf, len - 1) == 0)
2130 _dbus_verbose (
"subtracting trailing \\0\n");
2141 if (strlen (_dbus_string_get_const_data (&buf)) != len)
2146 _dbus_verbose (
"security label from kernel had an embedded \\0, "
2151 _dbus_verbose (
"getsockopt(SO_PEERSEC): %lu bytes excluding \\0: %s\n",
2152 (
unsigned long) len,
2153 _dbus_string_get_const_data (&buf));
2156 _dbus_string_get_const_data (&buf)))
2224 #ifdef HAVE_CMSGCRED
2227 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
2235 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
2236 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
2237 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
2243 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2247 iov.iov_base = &buf;
2254 #if defined(HAVE_CMSGCRED)
2256 msg.msg_control = (caddr_t) &cmsg;
2257 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
2261 bytes_read = recvmsg (client_fd.fd, &msg, 0);
2274 "Failed to read credentials byte: %s",
2275 _dbus_strerror (errno));
2278 else if (bytes_read == 0)
2284 "Failed to read credentials byte (zero-length read)");
2287 else if (buf !=
'\0')
2290 "Credentials byte was not nul");
2294 _dbus_verbose (
"read credentials byte\n");
2307 struct sockpeercred cr;
2311 socklen_t cr_len =
sizeof (cr);
2313 if (getsockopt (client_fd.fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) != 0)
2315 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED): %s\n",
2316 _dbus_strerror (errno));
2318 else if (cr_len !=
sizeof (cr))
2320 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED), returned %d bytes, expected %d\n",
2321 cr_len, (
int)
sizeof (cr));
2331 primary_gid_read = cr.gid;
2334 #elif defined(HAVE_UNPCBID) && defined(LOCAL_PEEREID)
2338 socklen_t cr_len =
sizeof (cr);
2340 if (getsockopt (client_fd.fd, 0, LOCAL_PEEREID, &cr, &cr_len) != 0)
2342 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID): %s\n",
2343 _dbus_strerror (errno));
2345 else if (cr_len !=
sizeof (cr))
2347 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID), returned %d bytes, expected %d\n",
2348 cr_len, (
int)
sizeof (cr));
2352 pid_read = cr.unp_pid;
2353 uid_read = cr.unp_euid;
2355 #elif defined(HAVE_CMSGCRED)
2364 struct cmsgcred *cred;
2365 struct cmsghdr *cmsgp;
2367 for (cmsgp = CMSG_FIRSTHDR (&msg);
2369 cmsgp = CMSG_NXTHDR (&msg, cmsgp))
2371 if (cmsgp->cmsg_type == SCM_CREDS &&
2372 cmsgp->cmsg_level == SOL_SOCKET &&
2373 cmsgp->cmsg_len >= CMSG_LEN (
sizeof (
struct cmsgcred)))
2375 cred = (
struct cmsgcred *) (
void *) CMSG_DATA (cmsgp);
2376 pid_read = cred->cmcred_pid;
2377 uid_read = cred->cmcred_euid;
2382 #elif defined(HAVE_GETPEERUCRED)
2386 ucred_t * ucred =
NULL;
2387 if (getpeerucred (client_fd.fd, &ucred) == 0)
2390 adt_session_data_t *adth =
NULL;
2392 pid_read = ucred_getpid (ucred);
2393 uid_read = ucred_geteuid (ucred);
2396 if (adt_start_session (&adth,
NULL, 0) || (adth ==
NULL))
2398 _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
2402 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
2404 _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
2408 adt_export_data_t *data =
NULL;
2409 size_t size = adt_export_session_data (adth, &data);
2412 _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
2420 (void) adt_end_session (adth);
2426 _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
2436 #elif defined(HAVE_GETPEEREID)
2454 if (getpeereid (client_fd.fd, &euid, &egid) == 0)
2460 _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
2464 #warning Socket credentials not supported on this Unix OS
2465 #warning Please tell https:
2471 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
2472 defined(__linux__) || \
2473 defined(__OpenBSD__) || \
2475 # error Credentials passing not working on this OS is a regression!
2478 _dbus_verbose (
"Socket credentials not supported on this OS\n");
2482 _dbus_verbose (
"Credentials:"
2493 _DBUS_SET_OOM (error);
2502 _DBUS_SET_OOM (error);
2507 if (!add_linux_security_label_to_credentials (client_fd.fd, credentials))
2509 _DBUS_SET_OOM (error);
2515 if (!add_groups_to_credentials (client_fd.fd, credentials, primary_gid_read))
2517 _DBUS_SET_OOM (error);
2545 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2547 if (write_credentials_byte (server_fd.fd, error))
2566 struct sockaddr addr;
2572 addrlen =
sizeof (addr);
2582 client_fd.fd = accept4 (listen_fd.fd, &addr, &addrlen, SOCK_CLOEXEC);
2583 cloexec_done = client_fd.fd >= 0;
2585 if (client_fd.fd < 0 && (errno == ENOSYS || errno == EINVAL))
2588 client_fd.fd = accept (listen_fd.fd, &addr, &addrlen);
2591 if (client_fd.fd < 0)
2597 _dbus_verbose (
"client fd %d accepted\n", client_fd.fd);
2620 const char *directory;
2623 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2625 directory = _dbus_string_get_const_data (dir);
2627 if (stat (directory, &sb) < 0)
2630 "%s", _dbus_strerror (errno));
2635 if (sb.st_uid != geteuid ())
2638 "%s directory is owned by user %lu, not %lu",
2640 (
unsigned long) sb.st_uid,
2641 (
unsigned long) geteuid ());
2645 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
2646 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
2649 "%s directory is not private to the user", directory);
2657 fill_user_info_from_passwd (
struct passwd *p,
2664 info->
uid = p->pw_uid;
2685 const char *username_c;
2698 if (username !=
NULL)
2699 username_c = _dbus_string_get_const_data (username);
2708 #ifdef HAVE_GETPWNAM_R
2714 struct passwd p_str;
2717 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
2723 if ((
long) buflen <= 0)
2738 result = getpwuid_r (uid, &p_str, buf, buflen,
2741 result = getpwnam_r (username_c, &p_str, buf, buflen,
2744 if (result == ERANGE && buflen < 512 * 1024)
2754 if (result == 0 && p == &p_str)
2756 if (!fill_user_info_from_passwd (p, info, error))
2766 "User \"%s\" unknown or no memory to allocate password entry\n",
2767 username_c ? username_c :
"???");
2768 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2778 #warning getpwnam_r() not available, please report this to the dbus maintainers with details of your OS
2783 p = getpwnam (username_c);
2787 if (!fill_user_info_from_passwd (p, info, error))
2795 "User \"%s\" unknown or no memory to allocate password entry\n",
2796 username_c ? username_c :
"???");
2797 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2806 #ifdef HAVE_GETGROUPLIST
2811 int initial_buf_count;
2813 initial_buf_count = 17;
2814 buf_count = initial_buf_count;
2822 if (getgrouplist (username_c,
2824 buf, &buf_count) < 0)
2840 if (buf_count == initial_buf_count)
2855 if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
2859 _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2860 username_c, buf_count, buf_count);
2866 "Failed to get groups for username \"%s\" primary GID "
2869 _dbus_strerror (errno));
2884 for (i = 0; i < buf_count; ++i)
2907 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2912 _DBUS_ASSERT_ERROR_IS_SET (error);
2946 return fill_user_info (info, uid,
2970 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
2971 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
2972 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
3046 static pthread_mutex_t atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
3059 return __sync_add_and_fetch(&atomic->
value, 1)-1;
3063 pthread_mutex_lock (&atomic_mutex);
3064 res = atomic->
value;
3066 pthread_mutex_unlock (&atomic_mutex);
3082 return __sync_sub_and_fetch(&atomic->
value, 1)+1;
3086 pthread_mutex_lock (&atomic_mutex);
3087 res = atomic->
value;
3089 pthread_mutex_unlock (&atomic_mutex);
3106 __sync_synchronize ();
3107 return atomic->
value;
3111 pthread_mutex_lock (&atomic_mutex);
3112 res = atomic->
value;
3113 pthread_mutex_unlock (&atomic_mutex);
3129 __sync_and_and_fetch (&atomic->
value, 0);
3131 pthread_mutex_lock (&atomic_mutex);
3133 pthread_mutex_unlock (&atomic_mutex);
3147 __sync_or_and_fetch (&atomic->
value, 1);
3149 pthread_mutex_lock (&atomic_mutex);
3151 pthread_mutex_unlock (&atomic_mutex);
3166 int timeout_milliseconds)
3168 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
3170 if (timeout_milliseconds < -1)
3172 timeout_milliseconds = -1;
3177 timeout_milliseconds);
3180 fd_set read_set, write_set, err_set;
3186 FD_ZERO (&read_set);
3187 FD_ZERO (&write_set);
3190 for (i = 0; i < n_fds; i++)
3195 FD_SET (fdp->
fd, &read_set);
3198 FD_SET (fdp->
fd, &write_set);
3200 FD_SET (fdp->
fd, &err_set);
3202 max_fd = MAX (max_fd, fdp->
fd);
3205 tv.tv_sec = timeout_milliseconds / 1000;
3206 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
3208 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
3209 timeout_milliseconds < 0 ?
NULL : &tv);
3213 for (i = 0; i < n_fds; i++)
3219 if (FD_ISSET (fdp->
fd, &read_set))
3222 if (FD_ISSET (fdp->
fd, &write_set))
3225 if (FD_ISSET (fdp->
fd, &err_set))
3245 #ifdef HAVE_MONOTONIC_CLOCK
3247 clock_gettime (CLOCK_MONOTONIC, &ts);
3250 *tv_sec = ts.tv_sec;
3252 *tv_usec = ts.tv_nsec / 1000;
3256 gettimeofday (&t,
NULL);
3261 *tv_usec = t.tv_usec;
3278 gettimeofday (&t,
NULL);
3283 *tv_usec = t.tv_usec;
3298 const char *filename_c;
3300 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3302 filename_c = _dbus_string_get_const_data (filename);
3304 if (mkdir (filename_c, 0700) < 0)
3306 if (errno == EEXIST)
3310 "Failed to create directory %s: %s\n",
3311 filename_c, _dbus_strerror (errno));
3330 const char *filename_c;
3332 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3334 filename_c = _dbus_string_get_const_data (filename);
3336 if (mkdir (filename_c, 0700) < 0)
3339 "Failed to create directory %s: %s\n",
3340 filename_c, _dbus_strerror (errno));
3364 if (_dbus_string_get_length (dir) == 0 ||
3365 _dbus_string_get_length (next_component) == 0)
3368 dir_ends_in_slash =
'/' == _dbus_string_get_byte (dir,
3369 _dbus_string_get_length (dir) - 1);
3371 file_starts_with_slash =
'/' == _dbus_string_get_byte (next_component, 0);
3373 if (dir_ends_in_slash && file_starts_with_slash)
3377 else if (!(dir_ends_in_slash || file_starts_with_slash))
3384 _dbus_string_get_length (dir));
3388 #define NANOSECONDS_PER_SECOND 1000000000
3390 #define MICROSECONDS_PER_SECOND 1000000
3392 #define MILLISECONDS_PER_SECOND 1000
3394 #define NANOSECONDS_PER_MILLISECOND 1000000
3396 #define MICROSECONDS_PER_MILLISECOND 1000
3405 #ifdef HAVE_NANOSLEEP
3406 struct timespec req;
3407 struct timespec rem;
3409 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
3410 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
3414 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
3416 #elif defined (HAVE_USLEEP)
3417 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
3419 sleep (MAX (milliseconds / 1000, 1));
3437 int old_len = _dbus_string_get_length (str);
3440 #ifdef HAVE_GETRANDOM
3445 _DBUS_SET_OOM (error);
3450 result = getrandom (buffer, n_bytes, GRND_NONBLOCK);
3452 if (result == n_bytes)
3459 fd = open (
"/dev/urandom", O_RDONLY);
3464 "Could not open /dev/urandom: %s",
3465 _dbus_strerror (errno));
3469 _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
3473 if (result != n_bytes)
3477 "Could not read /dev/urandom: %s",
3478 _dbus_strerror (errno));
3481 "Short read from /dev/urandom");
3488 _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
3516 _dbus_strerror (
int error_number)
3520 msg = strerror (error_number);
3533 signal (SIGPIPE, SIG_IGN);
3548 val = fcntl (fd, F_GETFD, 0);
3555 fcntl (fd, F_SETFD, val);
3570 val = fcntl (fd, F_GETFD, 0);
3577 fcntl (fd, F_SETFD, val);
3591 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3600 "Could not close fd %d", fd);
3621 #ifdef F_DUPFD_CLOEXEC
3624 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
3625 cloexec_done = new_fd >= 0;
3627 if (new_fd < 0 && errno == EINVAL)
3630 new_fd = fcntl(fd, F_DUPFD, 3);
3636 "Could not duplicate fd %d", fd);
3640 #ifdef F_DUPFD_CLOEXEC
3661 return _dbus_set_fd_nonblocking (fd.fd, error);
3665 _dbus_set_fd_nonblocking (
int fd,
3670 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3672 val = fcntl (fd, F_GETFL, 0);
3676 "Failed to get flags from file descriptor %d: %s",
3677 fd, _dbus_strerror (errno));
3678 _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
3679 _dbus_strerror (errno));
3683 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
3686 "Failed to set nonblocking flag of file descriptor %d: %s",
3687 fd, _dbus_strerror (errno));
3688 _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
3689 fd, _dbus_strerror (errno));
3705 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
3711 bt_size = backtrace (bt, 500);
3713 syms = backtrace_symbols (bt, bt_size);
3719 fprintf (stderr,
" %s\n", syms[i]);
3725 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
3726 fprintf (stderr,
" D-Bus not built with -rdynamic so unable to print a backtrace\n");
3728 fprintf (stderr,
" D-Bus not compiled with backtrace support so unable to print a backtrace\n");
3750 #ifdef HAVE_SOCKETPAIR
3757 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
3758 cloexec_done = retval >= 0;
3760 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
3763 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
3769 "Could not create full-duplex pipe");
3773 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3784 (!_dbus_set_fd_nonblocking (fds[0],
NULL) ||
3785 !_dbus_set_fd_nonblocking (fds[1],
NULL)))
3788 "Could not set full-duplex pipe nonblocking");
3799 _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
3804 _dbus_warn (
"_dbus_socketpair() not implemented on this OS");
3806 "_dbus_socketpair() not implemented on this OS");
3823 char static_buf[1024];
3824 int bufsize =
sizeof (static_buf);
3828 DBUS_VA_COPY (args_copy, args);
3829 len = vsnprintf (static_buf, bufsize, format, args_copy);
3846 DBUS_VA_COPY (args_copy, args);
3848 if (vsnprintf (static_buf, 1, format, args_copy) == 1)
3867 DBUS_VA_COPY (args_copy, args);
3868 len = vsnprintf (buf, bufsize, format, args_copy);
3893 static const char* tmpdir =
NULL;
3905 tmpdir = getenv(
"TMPDIR");
3911 tmpdir = getenv(
"TMP");
3913 tmpdir = getenv(
"TEMP");
3927 #if defined(DBUS_ENABLE_X11_AUTOLAUNCH) || defined(DBUS_ENABLE_LAUNCHD)
3948 _read_subprocess_line_argv (
const char *progpath,
3950 const char *
const *argv,
3954 int result_pipe[2] = { -1, -1 };
3955 int errors_pipe[2] = { -1, -1 };
3962 sigset_t new_set, old_set;
3964 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3971 sigemptyset (&new_set);
3972 sigaddset (&new_set, SIGCHLD);
3973 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3975 orig_len = _dbus_string_get_length (result);
3979 if (pipe (result_pipe) < 0)
3982 "Failed to create a pipe to call %s: %s",
3983 progpath, _dbus_strerror (errno));
3984 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3985 progpath, _dbus_strerror (errno));
3988 if (pipe (errors_pipe) < 0)
3991 "Failed to create a pipe to call %s: %s",
3992 progpath, _dbus_strerror (errno));
3993 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3994 progpath, _dbus_strerror (errno));
4007 "Failed to fork() to call %s: %s",
4008 progpath, _dbus_strerror (errno));
4009 _dbus_verbose (
"Failed to fork() to call %s: %s\n",
4010 progpath, _dbus_strerror (errno));
4017 const char *error_str;
4021 int saved_errno = errno;
4026 if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0 ||
4027 write (errors_pipe[
WRITE_END],
": ", 2) < 0)
4032 error_str = _dbus_strerror (saved_errno);
4034 if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0)
4046 if (dup2 (result_pipe[
WRITE_END], 1) == -1)
4048 if (dup2 (errors_pipe[
WRITE_END], 2) == -1)
4053 sigprocmask (SIG_SETMASK, &old_set,
NULL);
4056 if (progpath[0] ==
'/')
4058 execv (progpath, (
char *
const *) argv);
4067 execvp (strrchr (progpath,
'/')+1, (
char *
const *) argv);
4070 execvp (progpath, (
char *
const *) argv);
4092 ret = waitpid (pid, &status, 0);
4094 while (ret == -1 && errno == EINTR);
4098 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
4104 _DBUS_SET_OOM (error);
4116 if (_dbus_string_get_length (&error_message) > 0)
4118 "%s terminated abnormally with the following error: %s",
4119 progpath, _dbus_string_get_data (&error_message));
4122 "%s terminated abnormally without any error message",
4130 sigprocmask (SIG_SETMASK, &old_set,
NULL);
4132 _DBUS_ASSERT_ERROR_XOR_BOOL (error, retval);
4134 if (result_pipe[0] != -1)
4135 close (result_pipe[0]);
4136 if (result_pipe[1] != -1)
4137 close (result_pipe[1]);
4138 if (errors_pipe[0] != -1)
4139 close (errors_pipe[0]);
4140 if (errors_pipe[1] != -1)
4141 close (errors_pipe[1]);
4164 #ifdef DBUS_ENABLE_X11_AUTOLAUNCH
4165 static const char arg_dbus_launch[] =
"dbus-launch";
4166 static const char arg_autolaunch[] =
"--autolaunch";
4167 static const char arg_binary_syntax[] =
"--binary-syntax";
4168 static const char arg_close_stderr[] =
"--close-stderr";
4173 const char *display;
4174 const char *progpath;
4175 const char *argv[6];
4183 "Unable to autolaunch when setuid");
4187 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4200 if (display ==
NULL || display[0] ==
'\0')
4203 "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
4209 _DBUS_SET_OOM (error);
4218 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
4221 if (progpath ==
NULL)
4223 progpath = DBUS_BINDIR
"/dbus-launch";
4230 argv[i] = arg_dbus_launch;
4232 argv[i] = arg_autolaunch;
4234 argv[i] = _dbus_string_get_data (&uuid);
4236 argv[i] = arg_binary_syntax;
4238 argv[i] = arg_close_stderr;
4245 retval = _read_subprocess_line_argv (progpath,
4247 argv, address, error);
4254 "Using X11 for dbus-daemon autolaunch was disabled at compile time, "
4255 "set your DBUS_SESSION_BUS_ADDRESS instead");
4300 if (create_if_not_found)
4312 if (!create_if_not_found)
4315 "D-Bus library appears to be incorrectly set up: "
4316 "see the manual page for dbus-uuidgen to correct "
4317 "this issue. (%s; %s)",
4345 const char *launchd_env_var,
4348 #ifdef DBUS_ENABLE_LAUNCHD
4352 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4357 "Unable to find launchd socket when setuid");
4362 argv[i] =
"launchctl";
4366 argv[i] = (
char*)launchd_env_var;
4373 if (!_read_subprocess_line_argv(argv[0],
TRUE, argv, socket_path, error))
4379 if (_dbus_string_get_length(socket_path) == 0)
4389 "can't lookup socket from launchd; launchd support not compiled in");
4394 #ifdef DBUS_ENABLE_LAUNCHD
4404 "Unable to find launchd socket when setuid");
4410 _DBUS_SET_OOM (error);
4425 "launchd did not provide a socket path, "
4426 "verify that org.freedesktop.dbus-session.plist is loaded!");
4432 _DBUS_SET_OOM (error);
4437 _dbus_string_get_length (address)))
4439 _DBUS_SET_OOM (error);
4454 const char *runtime_dir =
_dbus_getenv (
"XDG_RUNTIME_DIR");
4459 if (runtime_dir ==
NULL)
4461 _dbus_verbose (
"XDG_RUNTIME_DIR not found in environment");
4468 _DBUS_SET_OOM (error);
4474 _DBUS_SET_OOM (error);
4478 if (lstat (_dbus_string_get_const_data (&user_bus_path), &stbuf) == -1)
4480 _dbus_verbose (
"XDG_RUNTIME_DIR/bus not available: %s",
4481 _dbus_strerror (errno));
4487 if (stbuf.st_uid != getuid ())
4489 _dbus_verbose (
"XDG_RUNTIME_DIR/bus owned by uid %ld, not our uid %ld",
4490 (
long) stbuf.st_uid, (
long) getuid ());
4496 if ((stbuf.st_mode & S_IFMT) != S_IFSOCK)
4498 _dbus_verbose (
"XDG_RUNTIME_DIR/bus is not a socket: st_mode = 0o%lo",
4499 (
long) stbuf.st_mode);
4508 _DBUS_SET_OOM (error);
4544 #ifdef DBUS_ENABLE_LAUNCHD
4546 return _dbus_lookup_session_address_launchd (address, error);
4550 if (!_dbus_lookup_user_bus (supported, address, error))
4552 else if (*supported)
4610 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
4612 const char *
override;
4615 if (
override !=
NULL && *
override !=
'\0')
4621 _dbus_verbose (
"Using fake homedir for testing: %s\n",
4622 _dbus_string_get_const_data (&homedir));
4629 if (!already_warned)
4631 _dbus_warn (
"Using %s for testing, set DBUS_TEST_HOMEDIR to avoid",
4632 _dbus_string_get_const_data (&homedir));
4633 already_warned =
TRUE;
4645 directory, _dbus_string_get_length (directory))) {
4659 _dbus_daemon_unpublish_session_bus_address (
void)
4677 #if EAGAIN == EWOULDBLOCK
4680 return e == EAGAIN || e == EWOULDBLOCK;
4695 const char *filename_c;
4697 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4699 filename_c = _dbus_string_get_const_data (filename);
4701 if (rmdir (filename_c) != 0)
4704 "Failed to remove directory %s: %s\n",
4705 filename_c, _dbus_strerror (errno));
4725 struct sockaddr_storage storage;
4726 struct sockaddr_un un;
4729 socklen_t sa_len =
sizeof(sa_buf);
4733 if (getsockname(fd.fd, &sa_buf.sa, &sa_len) < 0)
4736 return sa_buf.sa.sa_family == AF_UNIX;
4745 close_ignore_error (
int fd)
4755 act_on_fds_3_and_up (
void (*func) (
int fd))
4759 #if defined(__linux__) && defined(__GLIBC__)
4765 d = opendir (
"/proc/self/fd");
4779 if (de->d_name[0] ==
'.')
4783 l = strtol (de->d_name, &e, 10);
4784 if (errno != 0 || e ==
NULL || *e !=
'\0')
4791 if (fd == dirfd (d))
4802 maxfds = sysconf (_SC_OPEN_MAX);
4811 for (i = 3; i < maxfds; i++)
4822 #ifdef HAVE_CLOSE_RANGE
4823 if (close_range (3, INT_MAX, 0) == 0)
4830 #if defined(HAVE_CLOSEFROM) && ( \
4831 defined(__FreeBSD__) || \
4832 defined(__NetBSD__) || \
4833 defined(__OpenBSD__) || \
4834 defined(__sun__) && defined(F_CLOSEFROM) \
4838 act_on_fds_3_and_up (close_ignore_error);
4849 #if defined(HAVE_CLOSE_RANGE) && defined(CLOSE_RANGE_CLOEXEC)
4850 if (close_range (3, INT_MAX, CLOSE_RANGE_CLOEXEC) == 0)
4872 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE)
4875 extern int __libc_enable_secure;
4876 return __libc_enable_secure;
4878 #elif defined(HAVE_ISSETUGID)
4880 return issetugid ();
4882 uid_t ruid, euid, suid;
4883 gid_t rgid, egid, sgid;
4890 if (_DBUS_UNLIKELY (!check_setuid_initialised))
4892 #ifdef HAVE_GETRESUID
4893 if (getresuid (&ruid, &euid, &suid) != 0 ||
4894 getresgid (&rgid, &egid, &sgid) != 0)
4897 suid = ruid = getuid ();
4898 sgid = rgid = getgid ();
4903 check_setuid_initialised =
TRUE;
4904 is_setuid = (ruid != euid || ruid != suid ||
4905 rgid != egid || rgid != sgid);
4926 struct sockaddr_storage storage;
4927 struct sockaddr_un un;
4928 struct sockaddr_in ipv4;
4929 struct sockaddr_in6 ipv6;
4931 char hostip[INET6_ADDRSTRLEN];
4932 socklen_t size =
sizeof (socket);
4934 const char *family_name =
NULL;
4937 if (getsockname (fd.fd, &socket.sa, &size))
4940 switch (socket.sa.sa_family)
4943 if (socket.un.sun_path[0]==
'\0')
4953 _DBUS_SET_OOM (error);
4967 _DBUS_SET_OOM (error);
4980 if (_dbus_inet_sockaddr_to_string (&socket, size, hostip,
sizeof (hostip),
4981 &family_name, &port, error))
4984 family_name, port) &&
4991 _DBUS_SET_OOM (error);
5005 "Failed to read address from socket: Unknown socket type.");
5011 "Failed to read address from socket: %s",
5012 _dbus_strerror (errno));
5017 _dbus_save_socket_errno (
void)
5023 _dbus_restore_socket_errno (
int saved_errno)
5025 errno = saved_errno;
5028 static const char *syslog_tag =
"dbus";
5029 #ifdef HAVE_SYSLOG_H
5030 static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
5053 (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
5057 #ifdef HAVE_SYSLOG_H
5060 if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
5061 openlog (tag, LOG_PID, LOG_DAEMON);
5078 #ifdef HAVE_SYSLOG_H
5079 if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
5084 case DBUS_SYSTEM_LOG_INFO:
5085 flags = LOG_DAEMON | LOG_INFO;
5087 case DBUS_SYSTEM_LOG_WARNING:
5088 flags = LOG_DAEMON | LOG_WARNING;
5090 case DBUS_SYSTEM_LOG_SECURITY:
5091 flags = LOG_AUTH | LOG_NOTICE;
5093 case DBUS_SYSTEM_LOG_ERROR:
5094 flags = LOG_DAEMON|LOG_CRIT;
5100 DBUS_VA_COPY (tmp, args);
5101 vsyslog (flags, msg, tmp);
5107 if (log_flags & DBUS_LOG_FLAGS_STDERR)
5110 DBUS_VA_COPY (tmp, args);
5112 vfprintf (stderr, msg, tmp);
5113 fputc (
'\n', stderr);
5127 _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.
const char * _dbus_error_from_errno(int error_number)
Converts a UNIX errno, or Windows errno or WinSock error value into a DBusError name.
#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.
dbus_bool_t _dbus_generate_uuid(DBusGUID *uuid, DBusError *error)
Generates a new UUID.
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.
char * _dbus_strdup(const char *str)
Duplicates a string.
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.
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...
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
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.
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.
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.
const char * _dbus_get_tmpdir(void)
Gets the temporary files directory by inspecting the environment variables TMPDIR,...
#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.
#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...