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"
40 #include <sys/types.h>
47 #include <sys/socket.h>
56 #include <netinet/in.h>
57 #include <netinet/tcp.h>
60 #include <arpa/inet.h>
74 #ifdef HAVE_GETPEERUCRED
80 #ifdef HAVE_SYS_RANDOM_H
81 #include <sys/random.h>
89 #include <systemd/sd-daemon.h>
100 #ifndef AI_ADDRCONFIG
101 #define AI_ADDRCONFIG 0
104 #ifndef HAVE_SOCKLEN_T
105 #define socklen_t int
108 #if defined (__sun) || defined (__sun__)
121 # define CMSG_ALIGN(len) _CMSG_DATA_ALIGN (len)
124 # define CMSG_ALIGN(len) (((len) + sizeof (long) - 1) & \
125 ~(sizeof (long) - 1))
130 # define CMSG_SPACE(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + \
135 # define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
156 const char **error_str_p)
158 static int const relevant_flag[] = { DBUS_FORCE_STDIN_NULL,
159 DBUS_FORCE_STDOUT_NULL,
160 DBUS_FORCE_STDERR_NULL };
162 const char *error_str =
"Failed mysteriously";
166 _DBUS_STATIC_ASSERT (STDIN_FILENO == 0);
167 _DBUS_STATIC_ASSERT (STDOUT_FILENO == 1);
168 _DBUS_STATIC_ASSERT (STDERR_FILENO == 2);
171 for (i = STDIN_FILENO; i <= STDERR_FILENO; i++)
177 devnull = open (
"/dev/null", O_RDWR);
181 error_str =
"Failed to open /dev/null";
190 if (devnull != i && (flags & relevant_flag[i]) != 0)
192 if (dup2 (devnull, i) < 0)
194 error_str =
"Failed to dup2 /dev/null onto a standard fd";
205 if (devnull > STDERR_FILENO)
208 if (error_str_p !=
NULL)
209 *error_str_p = error_str;
212 return (error_str ==
NULL);
215 static dbus_bool_t _dbus_set_fd_nonblocking (
int fd,
219 _dbus_open_socket (
int *fd_p,
228 *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
229 cloexec_done = *fd_p >= 0;
232 if (*fd_p < 0 && (errno == EINVAL || errno == EPROTOTYPE))
235 *fd_p = socket (domain, type, protocol);
247 _dbus_verbose (
"socket fd %d opened\n", *fd_p);
254 "Failed to open socket: %s",
255 _dbus_strerror (errno));
271 _dbus_open_unix_socket (
int *fd,
274 return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);
325 #if HAVE_DECL_MSG_NOSIGNAL
329 data = _dbus_string_get_const_data_len (buffer, start, len);
333 bytes_written = send (fd.fd, data, len, MSG_NOSIGNAL);
335 if (bytes_written < 0 && errno == EINTR)
338 return bytes_written;
362 unsigned int *n_fds) {
363 #ifndef HAVE_UNIX_FD_PASSING
381 start = _dbus_string_get_length (buffer);
401 m.msg_controllen = CMSG_SPACE(*n_fds *
sizeof(
int));
405 m.msg_control = alloca(m.msg_controllen);
406 memset(m.msg_control, 0, m.msg_controllen);
412 m.msg_controllen = CMSG_LEN (*n_fds *
sizeof(
int));
416 bytes_read = recvmsg (fd.fd, &m, 0
417 #ifdef MSG_CMSG_CLOEXEC
438 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
439 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
442 int *payload = (
int *) CMSG_DATA (cm);
443 size_t payload_len_bytes = (cm->cmsg_len - CMSG_LEN (0));
444 size_t payload_len_fds;
449 _DBUS_STATIC_ASSERT (
sizeof (
size_t) >=
sizeof (
unsigned int));
451 if ((m.msg_flags & MSG_CTRUNC) && CMSG_NXTHDR(&m, cm) ==
NULL &&
452 (
char *) payload + payload_len_bytes >
453 (
char *) m.msg_control + m.msg_controllen)
464 payload_len_bytes = m.msg_controllen -
465 ((
char *) payload - (
char *) m.msg_control);
468 payload_len_fds = payload_len_bytes /
sizeof (int);
470 if (_DBUS_LIKELY (payload_len_fds <= (
size_t) *n_fds))
473 fds_to_use = payload_len_fds;
481 fds_to_use = (size_t) *n_fds;
486 for (i = fds_to_use; i < payload_len_fds; i++)
492 memcpy (fds, payload, fds_to_use *
sizeof (
int));
497 *n_fds = (
unsigned int) fds_to_use;
502 for (i = 0; i < fds_to_use; i++)
511 if (m.msg_flags & MSG_CTRUNC)
522 for (i = 0; i < *n_fds; i++)
545 _dbus_write_socket_with_unix_fds(
DBusSocket fd,
552 #ifndef HAVE_UNIX_FD_PASSING
561 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len,
NULL, 0, 0, fds, n_fds);
566 _dbus_write_socket_with_unix_fds_two(
DBusSocket fd,
576 #ifndef HAVE_UNIX_FD_PASSING
584 buffer1, start1, len1,
585 buffer2, start2, len2);
598 iov[0].iov_base = (
char*) _dbus_string_get_const_data_len (buffer1, start1, len1);
599 iov[0].iov_len = len1;
603 iov[1].iov_base = (
char*) _dbus_string_get_const_data_len (buffer2, start2, len2);
604 iov[1].iov_len = len2;
609 m.msg_iovlen = buffer2 ? 2 : 1;
613 m.msg_controllen = CMSG_SPACE(n_fds *
sizeof(
int));
614 m.msg_control = alloca(m.msg_controllen);
615 memset(m.msg_control, 0, m.msg_controllen);
617 cm = CMSG_FIRSTHDR(&m);
618 cm->cmsg_level = SOL_SOCKET;
619 cm->cmsg_type = SCM_RIGHTS;
620 cm->cmsg_len = CMSG_LEN(n_fds *
sizeof(
int));
621 memcpy(CMSG_DATA(cm), fds, n_fds *
sizeof(
int));
626 bytes_written = sendmsg (fd.fd, &m, 0
627 #
if HAVE_DECL_MSG_NOSIGNAL
632 if (bytes_written < 0 && errno == EINTR)
636 if (bytes_written > 0)
640 return bytes_written;
666 #if HAVE_DECL_MSG_NOSIGNAL
667 struct iovec vectors[2];
679 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
682 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
690 vectors[0].iov_base = (
char*) data1;
691 vectors[0].iov_len = len1;
692 vectors[1].iov_base = (
char*) data2;
693 vectors[1].iov_len = len2;
697 m.msg_iovlen = data2 ? 2 : 1;
701 bytes_written = sendmsg (fd.fd, &m, MSG_NOSIGNAL);
703 if (bytes_written < 0 && errno == EINTR)
706 return bytes_written;
710 buffer2, start2, len2);
741 start = _dbus_string_get_length (buffer);
753 bytes_read = read (fd, data, count);
799 data = _dbus_string_get_const_data_len (buffer, start, len);
803 bytes_written = write (fd, data, len);
805 if (bytes_written < 0 && errno == EINTR)
809 if (bytes_written > 0)
813 return bytes_written;
853 struct iovec vectors[2];
858 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
861 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
869 vectors[0].iov_base = (
char*) data1;
870 vectors[0].iov_len = len1;
871 vectors[1].iov_base = (
char*) data2;
872 vectors[1].iov_len = len2;
876 bytes_written = writev (fd,
880 if (bytes_written < 0 && errno == EINTR)
883 return bytes_written;
890 if (ret1 == len1 && buffer2 !=
NULL)
904 #define _DBUS_MAX_SUN_PATH_LENGTH 99
942 struct sockaddr_un addr;
943 _DBUS_STATIC_ASSERT (
sizeof (addr.sun_path) > _DBUS_MAX_SUN_PATH_LENGTH);
945 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
947 _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
951 if (!_dbus_open_unix_socket (&fd, error))
953 _DBUS_ASSERT_ERROR_IS_SET(error);
956 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
959 addr.sun_family = AF_UNIX;
960 path_len = strlen (path);
965 addr.sun_path[0] =
'\0';
968 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
971 "Abstract socket name too long\n");
976 strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
980 "Operating system does not support abstract socket namespace\n");
987 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
990 "Socket name too long\n");
995 strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
998 if (connect (fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1002 "Failed to connect to socket %s: %s",
1003 path, _dbus_strerror (errno));
1009 if (!_dbus_set_fd_nonblocking (fd, error))
1011 _DBUS_ASSERT_ERROR_IS_SET (error);
1042 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1044 _dbus_verbose (
"connecting to process %s\n", path);
1047 retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
1048 cloexec_done = (retval >= 0);
1050 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
1053 retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
1060 "Failed to create socket pair: %s",
1061 _dbus_strerror (errno));
1081 "Failed to fork() to call %s: %s",
1082 path, _dbus_strerror (errno));
1093 dup2 (fds[1], STDIN_FILENO);
1094 dup2 (fds[1], STDOUT_FILENO);
1096 if (fds[1] != STDIN_FILENO &&
1097 fds[1] != STDOUT_FILENO)
1105 execvp (path, (
char *
const *) argv);
1107 fprintf (stderr,
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
1115 if (!_dbus_set_fd_nonblocking (fds[0], error))
1117 _DBUS_ASSERT_ERROR_IS_SET (error);
1149 struct sockaddr_un addr;
1151 _DBUS_STATIC_ASSERT (
sizeof (addr.sun_path) > _DBUS_MAX_SUN_PATH_LENGTH);
1153 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1155 _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
1158 if (!_dbus_open_unix_socket (&listen_fd, error))
1160 _DBUS_ASSERT_ERROR_IS_SET(error);
1163 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1166 addr.sun_family = AF_UNIX;
1167 path_len = strlen (path);
1175 addr.sun_path[0] =
'\0';
1178 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1181 "Abstract socket name too long\n");
1186 strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
1190 "Operating system does not support abstract socket namespace\n");
1210 if (stat (path, &sb) == 0 &&
1211 S_ISSOCK (sb.st_mode))
1215 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1218 "Socket name too long\n");
1223 strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
1226 if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1229 "Failed to bind socket \"%s\": %s",
1230 path, _dbus_strerror (errno));
1235 if (listen (listen_fd, SOMAXCONN ) < 0)
1238 "Failed to listen on socket \"%s\": %s",
1239 path, _dbus_strerror (errno));
1244 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1246 _DBUS_ASSERT_ERROR_IS_SET (error);
1254 if (!
abstract && chmod (path, 0777) < 0)
1255 _dbus_warn (
"Could not set mode 0777 on socket %s", path);
1279 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1281 n = sd_listen_fds (
TRUE);
1285 "Failed to acquire systemd socket: %s",
1286 _dbus_strerror (-n));
1293 "No socket received.");
1297 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1299 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1303 "Failed to verify systemd socket type: %s",
1304 _dbus_strerror (-r));
1311 "Passed socket has wrong type.");
1323 "Failed to allocate file handle array.");
1327 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1329 if (!_dbus_set_fd_nonblocking (fd, error))
1331 _DBUS_ASSERT_ERROR_IS_SET (error);
1335 new_fds[fd - SD_LISTEN_FDS_START].fd = fd;
1343 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1352 "dbus was compiled without systemd support");
1360 _dbus_error_from_gai (
int gai_res,
1426 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
1430 _dbus_connect_tcp_socket_with_nonce (
const char *host,
1433 const char *noncefile,
1436 int saved_errno = 0;
1440 struct addrinfo hints;
1441 struct addrinfo *ai =
NULL;
1442 const struct addrinfo *tmp;
1445 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1450 hints.ai_family = AF_UNSPEC;
1451 else if (!strcmp(family,
"ipv4"))
1452 hints.ai_family = AF_INET;
1453 else if (!strcmp(family,
"ipv6"))
1454 hints.ai_family = AF_INET6;
1459 "Unknown address family %s", family);
1460 return _dbus_socket_get_invalid ();
1462 hints.ai_protocol = IPPROTO_TCP;
1463 hints.ai_socktype = SOCK_STREAM;
1464 hints.ai_flags = AI_ADDRCONFIG;
1466 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1469 _dbus_error_from_gai (res, errno),
1470 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1471 host, port, gai_strerror(res), res);
1472 _dbus_socket_invalidate (&fd);
1479 if (!_dbus_open_socket (&fd.fd, tmp->ai_family, SOCK_STREAM, 0, error))
1481 _DBUS_ASSERT_ERROR_IS_SET(error);
1482 _dbus_socket_invalidate (&fd);
1485 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1487 if (connect (fd.fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1489 saved_errno = errno;
1491 _dbus_socket_invalidate (&fd);
1495 if (connect_error ==
NULL)
1497 _DBUS_SET_OOM (error);
1502 _dbus_set_error_with_inet_sockaddr (connect_error,
1503 tmp->ai_addr, tmp->ai_addrlen,
1504 "Failed to connect to socket",
1511 _DBUS_SET_OOM (error);
1522 if (!_dbus_socket_is_valid (fd))
1524 _dbus_combine_tcp_errors (&connect_errors,
"Failed to connect",
1529 if (noncefile !=
NULL)
1534 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1539 _dbus_socket_invalidate (&fd);
1544 if (!_dbus_set_fd_nonblocking (fd.fd, error))
1547 _dbus_socket_invalidate (&fd);
1586 const char **retfamily,
1591 int nlisten_fd = 0, res, i;
1595 struct addrinfo hints;
1596 struct addrinfo *ai, *tmp;
1597 unsigned int reuseaddr;
1602 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1607 hints.ai_family = AF_UNSPEC;
1608 else if (!strcmp(family,
"ipv4"))
1609 hints.ai_family = AF_INET;
1610 else if (!strcmp(family,
"ipv6"))
1611 hints.ai_family = AF_INET6;
1616 "Unknown address family %s", family);
1620 hints.ai_protocol = IPPROTO_TCP;
1621 hints.ai_socktype = SOCK_STREAM;
1622 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1624 redo_lookup_with_port:
1626 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1629 _dbus_error_from_gai (res, errno),
1630 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1631 host ? host :
"*", port, gai_strerror(res), res);
1638 int fd = -1, tcp_nodelay_on;
1641 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1643 _DBUS_ASSERT_ERROR_IS_SET(error);
1646 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1649 if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1651 _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
1652 host ? host :
"*", port, _dbus_strerror (errno));
1658 if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay_on,
sizeof (tcp_nodelay_on)) == -1)
1660 _dbus_warn (
"Failed to set TCP_NODELAY socket option \"%s:%s\": %s",
1661 host ? host :
"*", port, _dbus_strerror (errno));
1664 if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1666 saved_errno = errno;
1690 if (bind_error ==
NULL)
1692 _DBUS_SET_OOM (error);
1697 _dbus_set_error_with_inet_sockaddr (bind_error, tmp->ai_addr, tmp->ai_addrlen,
1698 "Failed to bind socket",
1705 _DBUS_SET_OOM (error);
1714 if (listen (fd, 30 ) < 0)
1716 saved_errno = errno;
1718 _dbus_set_error_with_inet_sockaddr (error, tmp->ai_addr, tmp->ai_addrlen,
1719 "Failed to listen on socket",
1729 "Failed to allocate file handle array");
1732 listen_fd = newlisten_fd;
1733 listen_fd[nlisten_fd].fd = fd;
1736 if (tmp->ai_addr->sa_family == AF_INET)
1738 else if (tmp->ai_addr->sa_family == AF_INET6)
1741 if (!_dbus_string_get_length(retport))
1747 if (!port || !strcmp(port,
"0"))
1750 struct sockaddr_storage addr;
1754 addrlen =
sizeof(addr);
1755 result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
1759 saved_errno = errno;
1761 "Failed to retrieve socket name for \"%s:%s\": %s",
1762 host ? host :
"*", port, _dbus_strerror (saved_errno));
1766 if ((res = getnameinfo ((
struct sockaddr*)&addr, addrlen,
NULL, 0,
1767 portbuf,
sizeof(portbuf),
1768 NI_NUMERICHOST | NI_NUMERICSERV)) != 0)
1770 saved_errno = errno;
1772 "Failed to resolve port \"%s:%s\": %s (%d)",
1773 host ? host :
"*", port, gai_strerror(res), res);
1784 port = _dbus_string_get_const_data(retport);
1786 goto redo_lookup_with_port;
1805 _dbus_combine_tcp_errors (&bind_errors,
"Failed to bind", host,
1810 if (have_ipv4 && !have_ipv6)
1811 *retfamily =
"ipv4";
1812 else if (!have_ipv4 && have_ipv6)
1813 *retfamily =
"ipv6";
1815 for (i = 0 ; i < nlisten_fd ; i++)
1817 if (!_dbus_set_fd_nonblocking (listen_fd[i].fd, error))
1838 for (i = 0 ; i < nlisten_fd ; i++)
1852 write_credentials_byte (
int server_fd,
1856 char buf[1] = {
'\0' };
1857 #if defined(HAVE_CMSGCRED)
1860 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1871 msg.msg_control = (caddr_t) &cmsg;
1872 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1874 cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
1875 cmsg.hdr.cmsg_level = SOL_SOCKET;
1876 cmsg.hdr.cmsg_type = SCM_CREDS;
1879 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1883 #if defined(HAVE_CMSGCRED)
1884 bytes_written = sendmsg (server_fd, &msg, 0
1885 #
if HAVE_DECL_MSG_NOSIGNAL
1893 if (bytes_written < 0 && errno == EINVAL)
1896 bytes_written = send (server_fd, buf, 1, 0
1897 #
if HAVE_DECL_MSG_NOSIGNAL
1903 if (bytes_written < 0 && errno == EINTR)
1906 if (bytes_written < 0)
1909 "Failed to write credentials byte: %s",
1910 _dbus_strerror (errno));
1913 else if (bytes_written == 0)
1916 "wrote zero bytes writing credentials byte");
1922 _dbus_verbose (
"wrote credentials byte\n");
1929 add_groups_to_credentials (
int client_fd,
1933 #if defined(__linux__) && defined(SO_PEERGROUPS)
1934 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
1936 socklen_t len = 1024;
1944 n_gids = ((size_t) len) /
sizeof (gid_t);
1950 while (getsockopt (client_fd, SOL_SOCKET, SO_PEERGROUPS, buf, &len) < 0)
1955 _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
1956 _dbus_strerror (e), (
unsigned long) len);
1958 if (e != ERANGE || (
size_t) len <= n_gids *
sizeof (gid_t))
1960 _dbus_verbose (
"Failed to getsockopt(SO_PEERGROUPS): %s\n",
1961 _dbus_strerror (e));
1967 n_gids = ((size_t) len) /
sizeof (gid_t);
1970 if (replacement ==
NULL)
1977 _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
1982 _dbus_verbose (
"getsockopt(SO_PEERGROUPS) yielded <= 0 bytes: %ld\n",
1987 if (len > n_gids *
sizeof (gid_t))
1989 _dbus_verbose (
"%lu > %zu", (
unsigned long) len, n_gids *
sizeof (gid_t));
1993 if (len %
sizeof (gid_t) != 0)
1995 _dbus_verbose (
"getsockopt(SO_PEERGROUPS) did not return an "
1996 "integer multiple of sizeof(gid_t): %lu should be "
1998 (
unsigned long) len,
sizeof (gid_t));
2003 n_gids = ((size_t) len) /
sizeof (gid_t);
2011 _dbus_verbose (
"getsockopt(SO_PEERGROUPS) returned a huge number "
2012 "of groups (%lu bytes), ignoring",
2013 (
unsigned long) len);
2019 if (converted_gids ==
NULL)
2025 for (i = 0; i < n_gids; i++)
2029 if (converted_gids[i] == primary)
2030 need_primary =
FALSE;
2035 converted_gids[n_gids] = primary;
2052 add_linux_security_label_to_credentials (
int client_fd,
2055 #if defined(__linux__) && defined(SO_PEERSEC)
2057 socklen_t len = 1024;
2064 while (getsockopt (client_fd, SOL_SOCKET, SO_PEERSEC,
2065 _dbus_string_get_data (&buf), &len) < 0)
2069 _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
2070 _dbus_strerror (e), (
unsigned long) len);
2072 if (e != ERANGE || len <= _dbus_string_get_length_uint (&buf))
2074 _dbus_verbose (
"Failed to getsockopt(SO_PEERSEC): %s\n",
2075 _dbus_strerror (e));
2087 _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
2092 _dbus_verbose (
"getsockopt(SO_PEERSEC) yielded <= 0 bytes: %lu\n",
2093 (
unsigned long) len);
2097 if (len > _dbus_string_get_length_uint (&buf))
2099 _dbus_verbose (
"%lu > %u", (
unsigned long) len,
2100 _dbus_string_get_length_uint (&buf));
2104 if (_dbus_string_get_byte (&buf, len - 1) == 0)
2108 _dbus_verbose (
"subtracting trailing \\0\n");
2119 if (strlen (_dbus_string_get_const_data (&buf)) != len)
2124 _dbus_verbose (
"security label from kernel had an embedded \\0, "
2129 _dbus_verbose (
"getsockopt(SO_PEERSEC): %lu bytes excluding \\0: %s\n",
2130 (
unsigned long) len,
2131 _dbus_string_get_const_data (&buf));
2134 _dbus_string_get_const_data (&buf)))
2202 #ifdef HAVE_CMSGCRED
2205 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
2213 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
2214 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
2215 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
2221 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2225 iov.iov_base = &buf;
2232 #if defined(HAVE_CMSGCRED)
2234 msg.msg_control = (caddr_t) &cmsg;
2235 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
2239 bytes_read = recvmsg (client_fd.fd, &msg, 0);
2252 "Failed to read credentials byte: %s",
2253 _dbus_strerror (errno));
2256 else if (bytes_read == 0)
2262 "Failed to read credentials byte (zero-length read)");
2265 else if (buf !=
'\0')
2268 "Credentials byte was not nul");
2272 _dbus_verbose (
"read credentials byte\n");
2285 struct sockpeercred cr;
2289 socklen_t cr_len =
sizeof (cr);
2291 if (getsockopt (client_fd.fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) != 0)
2293 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED): %s\n",
2294 _dbus_strerror (errno));
2296 else if (cr_len !=
sizeof (cr))
2298 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED), returned %d bytes, expected %d\n",
2299 cr_len, (
int)
sizeof (cr));
2309 primary_gid_read = cr.gid;
2312 #elif defined(HAVE_UNPCBID) && defined(LOCAL_PEEREID)
2316 socklen_t cr_len =
sizeof (cr);
2318 if (getsockopt (client_fd.fd, 0, LOCAL_PEEREID, &cr, &cr_len) != 0)
2320 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID): %s\n",
2321 _dbus_strerror (errno));
2323 else if (cr_len !=
sizeof (cr))
2325 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID), returned %d bytes, expected %d\n",
2326 cr_len, (
int)
sizeof (cr));
2330 pid_read = cr.unp_pid;
2331 uid_read = cr.unp_euid;
2333 #elif defined(HAVE_CMSGCRED)
2342 struct cmsgcred *cred;
2343 struct cmsghdr *cmsgp;
2345 for (cmsgp = CMSG_FIRSTHDR (&msg);
2347 cmsgp = CMSG_NXTHDR (&msg, cmsgp))
2349 if (cmsgp->cmsg_type == SCM_CREDS &&
2350 cmsgp->cmsg_level == SOL_SOCKET &&
2351 cmsgp->cmsg_len >= CMSG_LEN (
sizeof (
struct cmsgcred)))
2353 cred = (
struct cmsgcred *) CMSG_DATA (cmsgp);
2354 pid_read = cred->cmcred_pid;
2355 uid_read = cred->cmcred_euid;
2360 #elif defined(HAVE_GETPEERUCRED)
2364 ucred_t * ucred =
NULL;
2365 if (getpeerucred (client_fd.fd, &ucred) == 0)
2368 adt_session_data_t *adth =
NULL;
2370 pid_read = ucred_getpid (ucred);
2371 uid_read = ucred_geteuid (ucred);
2374 if (adt_start_session (&adth,
NULL, 0) || (adth ==
NULL))
2376 _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
2380 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
2382 _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
2386 adt_export_data_t *data =
NULL;
2387 size_t size = adt_export_session_data (adth, &data);
2390 _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
2398 (void) adt_end_session (adth);
2404 _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
2414 #elif defined(HAVE_GETPEEREID)
2432 if (getpeereid (client_fd.fd, &euid, &egid) == 0)
2438 _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
2442 #warning Socket credentials not supported on this Unix OS
2443 #warning Please tell https://gitlab.freedesktop.org/dbus/dbus/-/issues/new
2449 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
2450 defined(__linux__) || \
2451 defined(__OpenBSD__) || \
2453 # error Credentials passing not working on this OS is a regression!
2456 _dbus_verbose (
"Socket credentials not supported on this OS\n");
2460 _dbus_verbose (
"Credentials:"
2471 _DBUS_SET_OOM (error);
2480 _DBUS_SET_OOM (error);
2485 if (!add_linux_security_label_to_credentials (client_fd.fd, credentials))
2487 _DBUS_SET_OOM (error);
2493 if (!add_groups_to_credentials (client_fd.fd, credentials, primary_gid_read))
2495 _DBUS_SET_OOM (error);
2523 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2525 if (write_credentials_byte (server_fd.fd, error))
2544 struct sockaddr addr;
2550 addrlen =
sizeof (addr);
2560 client_fd.fd = accept4 (listen_fd.fd, &addr, &addrlen, SOCK_CLOEXEC);
2561 cloexec_done = client_fd.fd >= 0;
2563 if (client_fd.fd < 0 && (errno == ENOSYS || errno == EINVAL))
2566 client_fd.fd = accept (listen_fd.fd, &addr, &addrlen);
2569 if (client_fd.fd < 0)
2575 _dbus_verbose (
"client fd %d accepted\n", client_fd.fd);
2598 const char *directory;
2601 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2603 directory = _dbus_string_get_const_data (dir);
2605 if (stat (directory, &sb) < 0)
2608 "%s", _dbus_strerror (errno));
2613 if (sb.st_uid != geteuid ())
2616 "%s directory is owned by user %lu, not %lu",
2618 (
unsigned long) sb.st_uid,
2619 (
unsigned long) geteuid ());
2623 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
2624 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
2627 "%s directory is not private to the user", directory);
2635 fill_user_info_from_passwd (
struct passwd *p,
2642 info->
uid = p->pw_uid;
2663 const char *username_c;
2676 if (username !=
NULL)
2677 username_c = _dbus_string_get_const_data (username);
2686 #ifdef HAVE_GETPWNAM_R
2692 struct passwd p_str;
2695 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
2701 if ((
long) buflen <= 0)
2716 result = getpwuid_r (uid, &p_str, buf, buflen,
2719 result = getpwnam_r (username_c, &p_str, buf, buflen,
2722 if (result == ERANGE && buflen < 512 * 1024)
2732 if (result == 0 && p == &p_str)
2734 if (!fill_user_info_from_passwd (p, info, error))
2744 "User \"%s\" unknown or no memory to allocate password entry\n",
2745 username_c ? username_c :
"???");
2746 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2756 #warning getpwnam_r() not available, please report this to the dbus maintainers with details of your OS
2761 p = getpwnam (username_c);
2765 if (!fill_user_info_from_passwd (p, info, error))
2773 "User \"%s\" unknown or no memory to allocate password entry\n",
2774 username_c ? username_c :
"???");
2775 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2784 #ifdef HAVE_GETGROUPLIST
2789 int initial_buf_count;
2791 initial_buf_count = 17;
2792 buf_count = initial_buf_count;
2800 if (getgrouplist (username_c,
2802 buf, &buf_count) < 0)
2818 if (buf_count == initial_buf_count)
2833 if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
2837 _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2838 username_c, buf_count, buf_count);
2844 "Failed to get groups for username \"%s\" primary GID "
2847 _dbus_strerror (errno));
2862 for (i = 0; i < buf_count; ++i)
2885 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2890 _DBUS_ASSERT_ERROR_IS_SET (error);
2924 return fill_user_info (info, uid,
2948 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
2949 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
2950 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
3024 static pthread_mutex_t atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
3037 return __sync_add_and_fetch(&atomic->
value, 1)-1;
3041 pthread_mutex_lock (&atomic_mutex);
3042 res = atomic->
value;
3044 pthread_mutex_unlock (&atomic_mutex);
3060 return __sync_sub_and_fetch(&atomic->
value, 1)+1;
3064 pthread_mutex_lock (&atomic_mutex);
3065 res = atomic->
value;
3067 pthread_mutex_unlock (&atomic_mutex);
3084 __sync_synchronize ();
3085 return atomic->
value;
3089 pthread_mutex_lock (&atomic_mutex);
3090 res = atomic->
value;
3091 pthread_mutex_unlock (&atomic_mutex);
3107 __sync_and_and_fetch (&atomic->
value, 0);
3109 pthread_mutex_lock (&atomic_mutex);
3111 pthread_mutex_unlock (&atomic_mutex);
3125 __sync_or_and_fetch (&atomic->
value, 1);
3127 pthread_mutex_lock (&atomic_mutex);
3129 pthread_mutex_unlock (&atomic_mutex);
3144 int timeout_milliseconds)
3146 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
3148 if (timeout_milliseconds < -1)
3150 timeout_milliseconds = -1;
3155 timeout_milliseconds);
3158 fd_set read_set, write_set, err_set;
3164 FD_ZERO (&read_set);
3165 FD_ZERO (&write_set);
3168 for (i = 0; i < n_fds; i++)
3173 FD_SET (fdp->
fd, &read_set);
3176 FD_SET (fdp->
fd, &write_set);
3178 FD_SET (fdp->
fd, &err_set);
3180 max_fd = MAX (max_fd, fdp->
fd);
3183 tv.tv_sec = timeout_milliseconds / 1000;
3184 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
3186 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
3187 timeout_milliseconds < 0 ?
NULL : &tv);
3191 for (i = 0; i < n_fds; i++)
3197 if (FD_ISSET (fdp->
fd, &read_set))
3200 if (FD_ISSET (fdp->
fd, &write_set))
3203 if (FD_ISSET (fdp->
fd, &err_set))
3223 #ifdef HAVE_MONOTONIC_CLOCK
3225 clock_gettime (CLOCK_MONOTONIC, &ts);
3228 *tv_sec = ts.tv_sec;
3230 *tv_usec = ts.tv_nsec / 1000;
3234 gettimeofday (&t,
NULL);
3239 *tv_usec = t.tv_usec;
3256 gettimeofday (&t,
NULL);
3261 *tv_usec = t.tv_usec;
3276 const char *filename_c;
3278 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3280 filename_c = _dbus_string_get_const_data (filename);
3282 if (mkdir (filename_c, 0700) < 0)
3284 if (errno == EEXIST)
3288 "Failed to create directory %s: %s\n",
3289 filename_c, _dbus_strerror (errno));
3308 const char *filename_c;
3310 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3312 filename_c = _dbus_string_get_const_data (filename);
3314 if (mkdir (filename_c, 0700) < 0)
3317 "Failed to create directory %s: %s\n",
3318 filename_c, _dbus_strerror (errno));
3342 if (_dbus_string_get_length (dir) == 0 ||
3343 _dbus_string_get_length (next_component) == 0)
3346 dir_ends_in_slash =
'/' == _dbus_string_get_byte (dir,
3347 _dbus_string_get_length (dir) - 1);
3349 file_starts_with_slash =
'/' == _dbus_string_get_byte (next_component, 0);
3351 if (dir_ends_in_slash && file_starts_with_slash)
3355 else if (!(dir_ends_in_slash || file_starts_with_slash))
3362 _dbus_string_get_length (dir));
3366 #define NANOSECONDS_PER_SECOND 1000000000
3368 #define MICROSECONDS_PER_SECOND 1000000
3370 #define MILLISECONDS_PER_SECOND 1000
3372 #define NANOSECONDS_PER_MILLISECOND 1000000
3374 #define MICROSECONDS_PER_MILLISECOND 1000
3383 #ifdef HAVE_NANOSLEEP
3384 struct timespec req;
3385 struct timespec rem;
3387 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
3388 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
3392 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
3394 #elif defined (HAVE_USLEEP)
3395 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
3397 sleep (MAX (milliseconds / 1000, 1));
3415 int old_len = _dbus_string_get_length (str);
3418 #ifdef HAVE_GETRANDOM
3423 _DBUS_SET_OOM (error);
3428 result = getrandom (buffer, n_bytes, GRND_NONBLOCK);
3430 if (result == n_bytes)
3437 fd = open (
"/dev/urandom", O_RDONLY);
3442 "Could not open /dev/urandom: %s",
3443 _dbus_strerror (errno));
3447 _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
3451 if (result != n_bytes)
3455 "Could not read /dev/urandom: %s",
3456 _dbus_strerror (errno));
3459 "Short read from /dev/urandom");
3466 _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
3494 _dbus_strerror (
int error_number)
3498 msg = strerror (error_number);
3511 signal (SIGPIPE, SIG_IGN);
3526 val = fcntl (fd, F_GETFD, 0);
3533 fcntl (fd, F_SETFD, val);
3548 val = fcntl (fd, F_GETFD, 0);
3555 fcntl (fd, F_SETFD, val);
3569 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3578 "Could not close fd %d", fd);
3599 #ifdef F_DUPFD_CLOEXEC
3602 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
3603 cloexec_done = new_fd >= 0;
3605 if (new_fd < 0 && errno == EINVAL)
3608 new_fd = fcntl(fd, F_DUPFD, 3);
3614 "Could not duplicate fd %d", fd);
3618 #ifdef F_DUPFD_CLOEXEC
3639 return _dbus_set_fd_nonblocking (fd.fd, error);
3643 _dbus_set_fd_nonblocking (
int fd,
3648 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3650 val = fcntl (fd, F_GETFL, 0);
3654 "Failed to get flags from file descriptor %d: %s",
3655 fd, _dbus_strerror (errno));
3656 _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
3657 _dbus_strerror (errno));
3661 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
3664 "Failed to set nonblocking flag of file descriptor %d: %s",
3665 fd, _dbus_strerror (errno));
3666 _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
3667 fd, _dbus_strerror (errno));
3683 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
3689 bt_size = backtrace (bt, 500);
3691 syms = backtrace_symbols (bt, bt_size);
3697 fprintf (stderr,
" %s\n", syms[i]);
3703 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
3704 fprintf (stderr,
" D-Bus not built with -rdynamic so unable to print a backtrace\n");
3706 fprintf (stderr,
" D-Bus not compiled with backtrace support so unable to print a backtrace\n");
3728 #ifdef HAVE_SOCKETPAIR
3735 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
3736 cloexec_done = retval >= 0;
3738 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
3741 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
3747 "Could not create full-duplex pipe");
3751 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3762 (!_dbus_set_fd_nonblocking (fds[0],
NULL) ||
3763 !_dbus_set_fd_nonblocking (fds[1],
NULL)))
3766 "Could not set full-duplex pipe nonblocking");
3777 _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
3782 _dbus_warn (
"_dbus_socketpair() not implemented on this OS");
3784 "_dbus_socketpair() not implemented on this OS");
3801 char static_buf[1024];
3802 int bufsize =
sizeof (static_buf);
3806 DBUS_VA_COPY (args_copy, args);
3807 len = vsnprintf (static_buf, bufsize, format, args_copy);
3824 DBUS_VA_COPY (args_copy, args);
3826 if (vsnprintf (static_buf, 1, format, args_copy) == 1)
3845 DBUS_VA_COPY (args_copy, args);
3846 len = vsnprintf (buf, bufsize, format, args_copy);
3871 static const char* tmpdir =
NULL;
3883 tmpdir = getenv(
"TMPDIR");
3889 tmpdir = getenv(
"TMP");
3891 tmpdir = getenv(
"TEMP");
3905 #if defined(DBUS_ENABLE_X11_AUTOLAUNCH) || defined(DBUS_ENABLE_LAUNCHD)
3926 _read_subprocess_line_argv (
const char *progpath,
3928 const char *
const *argv,
3932 int result_pipe[2] = { -1, -1 };
3933 int errors_pipe[2] = { -1, -1 };
3940 sigset_t new_set, old_set;
3942 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3949 sigemptyset (&new_set);
3950 sigaddset (&new_set, SIGCHLD);
3951 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3953 orig_len = _dbus_string_get_length (result);
3957 if (pipe (result_pipe) < 0)
3960 "Failed to create a pipe to call %s: %s",
3961 progpath, _dbus_strerror (errno));
3962 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3963 progpath, _dbus_strerror (errno));
3966 if (pipe (errors_pipe) < 0)
3969 "Failed to create a pipe to call %s: %s",
3970 progpath, _dbus_strerror (errno));
3971 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3972 progpath, _dbus_strerror (errno));
3985 "Failed to fork() to call %s: %s",
3986 progpath, _dbus_strerror (errno));
3987 _dbus_verbose (
"Failed to fork() to call %s: %s\n",
3988 progpath, _dbus_strerror (errno));
3995 const char *error_str;
3999 int saved_errno = errno;
4004 if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0 ||
4005 write (errors_pipe[
WRITE_END],
": ", 2) < 0)
4010 error_str = _dbus_strerror (saved_errno);
4012 if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0)
4024 if (dup2 (result_pipe[
WRITE_END], 1) == -1)
4026 if (dup2 (errors_pipe[
WRITE_END], 2) == -1)
4031 sigprocmask (SIG_SETMASK, &old_set,
NULL);
4034 if (progpath[0] ==
'/')
4036 execv (progpath, (
char *
const *) argv);
4045 execvp (strrchr (progpath,
'/')+1, (
char *
const *) argv);
4048 execvp (progpath, (
char *
const *) argv);
4070 ret = waitpid (pid, &status, 0);
4072 while (ret == -1 && errno == EINTR);
4076 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
4082 _DBUS_SET_OOM (error);
4094 if (_dbus_string_get_length (&error_message) > 0)
4096 "%s terminated abnormally with the following error: %s",
4097 progpath, _dbus_string_get_data (&error_message));
4100 "%s terminated abnormally without any error message",
4108 sigprocmask (SIG_SETMASK, &old_set,
NULL);
4110 _DBUS_ASSERT_ERROR_XOR_BOOL (error, retval);
4112 if (result_pipe[0] != -1)
4113 close (result_pipe[0]);
4114 if (result_pipe[1] != -1)
4115 close (result_pipe[1]);
4116 if (errors_pipe[0] != -1)
4117 close (errors_pipe[0]);
4118 if (errors_pipe[1] != -1)
4119 close (errors_pipe[1]);
4142 #ifdef DBUS_ENABLE_X11_AUTOLAUNCH
4143 static const char arg_dbus_launch[] =
"dbus-launch";
4144 static const char arg_autolaunch[] =
"--autolaunch";
4145 static const char arg_binary_syntax[] =
"--binary-syntax";
4146 static const char arg_close_stderr[] =
"--close-stderr";
4151 const char *display;
4152 const char *progpath;
4153 const char *argv[6];
4161 "Unable to autolaunch when setuid");
4165 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4178 if (display ==
NULL || display[0] ==
'\0')
4181 "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
4187 _DBUS_SET_OOM (error);
4196 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
4199 if (progpath ==
NULL)
4201 progpath = DBUS_BINDIR
"/dbus-launch";
4208 argv[i] = arg_dbus_launch;
4210 argv[i] = arg_autolaunch;
4212 argv[i] = _dbus_string_get_data (&uuid);
4214 argv[i] = arg_binary_syntax;
4216 argv[i] = arg_close_stderr;
4223 retval = _read_subprocess_line_argv (progpath,
4225 argv, address, error);
4232 "Using X11 for dbus-daemon autolaunch was disabled at compile time, "
4233 "set your DBUS_SESSION_BUS_ADDRESS instead");
4278 if (create_if_not_found)
4290 if (!create_if_not_found)
4293 "D-Bus library appears to be incorrectly set up: "
4294 "see the manual page for dbus-uuidgen to correct "
4295 "this issue. (%s; %s)",
4323 const char *launchd_env_var,
4326 #ifdef DBUS_ENABLE_LAUNCHD
4330 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4335 "Unable to find launchd socket when setuid");
4340 argv[i] =
"launchctl";
4344 argv[i] = (
char*)launchd_env_var;
4351 if (!_read_subprocess_line_argv(argv[0],
TRUE, argv, socket_path, error))
4357 if (_dbus_string_get_length(socket_path) == 0)
4367 "can't lookup socket from launchd; launchd support not compiled in");
4372 #ifdef DBUS_ENABLE_LAUNCHD
4382 "Unable to find launchd socket when setuid");
4388 _DBUS_SET_OOM (error);
4403 "launchd did not provide a socket path, "
4404 "verify that org.freedesktop.dbus-session.plist is loaded!");
4410 _DBUS_SET_OOM (error);
4415 _dbus_string_get_length (address)))
4417 _DBUS_SET_OOM (error);
4432 const char *runtime_dir =
_dbus_getenv (
"XDG_RUNTIME_DIR");
4437 if (runtime_dir ==
NULL)
4439 _dbus_verbose (
"XDG_RUNTIME_DIR not found in environment");
4446 _DBUS_SET_OOM (error);
4452 _DBUS_SET_OOM (error);
4456 if (lstat (_dbus_string_get_const_data (&user_bus_path), &stbuf) == -1)
4458 _dbus_verbose (
"XDG_RUNTIME_DIR/bus not available: %s",
4459 _dbus_strerror (errno));
4465 if (stbuf.st_uid != getuid ())
4467 _dbus_verbose (
"XDG_RUNTIME_DIR/bus owned by uid %ld, not our uid %ld",
4468 (
long) stbuf.st_uid, (
long) getuid ());
4474 if ((stbuf.st_mode & S_IFMT) != S_IFSOCK)
4476 _dbus_verbose (
"XDG_RUNTIME_DIR/bus is not a socket: st_mode = 0o%lo",
4477 (
long) stbuf.st_mode);
4486 _DBUS_SET_OOM (error);
4522 #ifdef DBUS_ENABLE_LAUNCHD
4524 return _dbus_lookup_session_address_launchd (address, error);
4528 if (!_dbus_lookup_user_bus (supported, address, error))
4530 else if (*supported)
4588 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
4590 const char *
override;
4593 if (
override !=
NULL && *
override !=
'\0')
4599 _dbus_verbose (
"Using fake homedir for testing: %s\n",
4600 _dbus_string_get_const_data (&homedir));
4607 if (!already_warned)
4609 _dbus_warn (
"Using %s for testing, set DBUS_TEST_HOMEDIR to avoid",
4610 _dbus_string_get_const_data (&homedir));
4611 already_warned =
TRUE;
4623 directory, _dbus_string_get_length (directory))) {
4637 _dbus_daemon_unpublish_session_bus_address (
void)
4654 #if EAGAIN == EWOULDBLOCK
4657 return e == EAGAIN || e == EWOULDBLOCK;
4672 const char *filename_c;
4674 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4676 filename_c = _dbus_string_get_const_data (filename);
4678 if (rmdir (filename_c) != 0)
4681 "Failed to remove directory %s: %s\n",
4682 filename_c, _dbus_strerror (errno));
4702 struct sockaddr_storage storage;
4703 struct sockaddr_un un;
4706 socklen_t sa_len =
sizeof(sa_buf);
4710 if (getsockname(fd.fd, &sa_buf.sa, &sa_len) < 0)
4713 return sa_buf.sa.sa_family == AF_UNIX;
4722 close_ignore_error (
int fd)
4732 act_on_fds_3_and_up (
void (*func) (
int fd))
4736 #if defined(__linux__) && defined(__GLIBC__)
4742 d = opendir (
"/proc/self/fd");
4756 if (de->d_name[0] ==
'.')
4760 l = strtol (de->d_name, &e, 10);
4761 if (errno != 0 || e ==
NULL || *e !=
'\0')
4768 if (fd == dirfd (d))
4779 maxfds = sysconf (_SC_OPEN_MAX);
4788 for (i = 3; i < maxfds; i++)
4799 act_on_fds_3_and_up (close_ignore_error);
4827 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE)
4830 extern int __libc_enable_secure;
4831 return __libc_enable_secure;
4833 #elif defined(HAVE_ISSETUGID)
4835 return issetugid ();
4837 uid_t ruid, euid, suid;
4838 gid_t rgid, egid, sgid;
4845 if (_DBUS_UNLIKELY (!check_setuid_initialised))
4847 #ifdef HAVE_GETRESUID
4848 if (getresuid (&ruid, &euid, &suid) != 0 ||
4849 getresgid (&rgid, &egid, &sgid) != 0)
4852 suid = ruid = getuid ();
4853 sgid = rgid = getgid ();
4858 check_setuid_initialised =
TRUE;
4859 is_setuid = (ruid != euid || ruid != suid ||
4860 rgid != egid || rgid != sgid);
4881 struct sockaddr_storage storage;
4882 struct sockaddr_un un;
4883 struct sockaddr_in ipv4;
4884 struct sockaddr_in6 ipv6;
4886 char hostip[INET6_ADDRSTRLEN];
4887 socklen_t size =
sizeof (socket);
4889 const char *family_name =
NULL;
4892 if (getsockname (fd.fd, &socket.sa, &size))
4895 switch (socket.sa.sa_family)
4898 if (socket.un.sun_path[0]==
'\0')
4908 _DBUS_SET_OOM (error);
4922 _DBUS_SET_OOM (error);
4935 if (_dbus_inet_sockaddr_to_string (&socket, size, hostip,
sizeof (hostip),
4936 &family_name, &port, error))
4939 family_name, port) &&
4946 _DBUS_SET_OOM (error);
4960 "Failed to read address from socket: Unknown socket type.");
4966 "Failed to read address from socket: %s",
4967 _dbus_strerror (errno));
4972 _dbus_save_socket_errno (
void)
4978 _dbus_restore_socket_errno (
int saved_errno)
4980 errno = saved_errno;
4983 static const char *syslog_tag =
"dbus";
4984 #ifdef HAVE_SYSLOG_H
4985 static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
5008 (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
5012 #ifdef HAVE_SYSLOG_H
5015 if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
5016 openlog (tag, LOG_PID, LOG_DAEMON);
5033 #ifdef HAVE_SYSLOG_H
5034 if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
5039 case DBUS_SYSTEM_LOG_INFO:
5040 flags = LOG_DAEMON | LOG_INFO;
5042 case DBUS_SYSTEM_LOG_WARNING:
5043 flags = LOG_DAEMON | LOG_WARNING;
5045 case DBUS_SYSTEM_LOG_SECURITY:
5046 flags = LOG_AUTH | LOG_NOTICE;
5048 case DBUS_SYSTEM_LOG_ERROR:
5049 flags = LOG_DAEMON|LOG_CRIT;
5055 DBUS_VA_COPY (tmp, args);
5056 vsyslog (flags, msg, tmp);
5062 if (log_flags & DBUS_LOG_FLAGS_STDERR)
5065 DBUS_VA_COPY (tmp, args);
5067 vfprintf (stderr, msg, tmp);
5068 fputc (
'\n', stderr);
5082 _dbus_get_low_level_socket_errno (
void)