27 #include "dbus-internals.h"
28 #include "dbus-sysdeps.h"
29 #include "dbus-sysdeps-unix.h"
30 #include "dbus-threads.h"
31 #include "dbus-protocol.h"
32 #include "dbus-transport.h"
33 #include "dbus-string.h"
34 #include "dbus-userdb.h"
35 #include "dbus-list.h"
36 #include "dbus-credentials.h"
37 #include "dbus-nonce.h"
39 #include <sys/types.h>
46 #include <sys/socket.h>
55 #include <netinet/in.h>
71 #ifdef HAVE_GETPEERUCRED
82 #include "sd-daemon.h"
89 #define AI_ADDRCONFIG 0
92 #ifndef HAVE_SOCKLEN_T
96 #if defined (__sun) || defined (__sun__)
109 # define CMSG_ALIGN(len) _CMSG_DATA_ALIGN (len)
112 # define CMSG_ALIGN(len) (((len) + sizeof (long) - 1) & \
113 ~(sizeof (long) - 1))
118 # define CMSG_SPACE(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + \
123 # define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
129 _dbus_open_socket (
int *fd_p,
138 *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
139 cloexec_done = *fd_p >= 0;
142 if (*fd_p < 0 && (errno == EINVAL || errno == EPROTOTYPE))
145 *fd_p = socket (domain, type, protocol);
157 _dbus_verbose (
"socket fd %d opened\n", *fd_p);
164 "Failed to open socket: %s",
165 _dbus_strerror (errno));
181 _dbus_open_unix_socket (
int *fd,
184 return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);
235 #if HAVE_DECL_MSG_NOSIGNAL
243 bytes_written = send (fd, data, len, MSG_NOSIGNAL);
245 if (bytes_written < 0 && errno == EINTR)
248 return bytes_written;
273 #ifndef HAVE_UNIX_FD_PASSING
311 m.msg_controllen = CMSG_SPACE(*n_fds *
sizeof(
int));
315 m.msg_control = alloca(m.msg_controllen);
316 memset(m.msg_control, 0, m.msg_controllen);
322 m.msg_controllen = CMSG_LEN (*n_fds *
sizeof(
int));
326 bytes_read = recvmsg(fd, &m, 0
327 #ifdef MSG_CMSG_CLOEXEC
348 if (m.msg_flags & MSG_CTRUNC)
360 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
361 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
364 int *payload = (
int *) CMSG_DATA (cm);
365 size_t payload_len_bytes = (cm->cmsg_len - CMSG_LEN (0));
366 size_t payload_len_fds = payload_len_bytes /
sizeof (int);
372 _DBUS_STATIC_ASSERT (
sizeof (
size_t) >=
sizeof (
int));
374 if (_DBUS_LIKELY (payload_len_fds <= (
size_t) *n_fds))
377 fds_to_use = payload_len_fds;
385 fds_to_use = (size_t) *n_fds;
390 for (i = fds_to_use; i < payload_len_fds; i++)
396 memcpy (fds, payload, fds_to_use *
sizeof (
int));
400 *n_fds = (int) fds_to_use;
405 for (i = 0; i < fds_to_use; i++)
428 _dbus_write_socket_with_unix_fds(
int fd,
435 #ifndef HAVE_UNIX_FD_PASSING
444 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len,
NULL, 0, 0, fds, n_fds);
449 _dbus_write_socket_with_unix_fds_two(
int fd,
459 #ifndef HAVE_UNIX_FD_PASSING
467 buffer1, start1, len1,
468 buffer2, start2, len2);
482 iov[0].iov_len = len1;
487 iov[1].iov_len = len2;
492 m.msg_iovlen = buffer2 ? 2 : 1;
496 m.msg_controllen = CMSG_SPACE(n_fds *
sizeof(
int));
497 m.msg_control = alloca(m.msg_controllen);
498 memset(m.msg_control, 0, m.msg_controllen);
500 cm = CMSG_FIRSTHDR(&m);
501 cm->cmsg_level = SOL_SOCKET;
502 cm->cmsg_type = SCM_RIGHTS;
503 cm->cmsg_len = CMSG_LEN(n_fds *
sizeof(
int));
504 memcpy(CMSG_DATA(cm), fds, n_fds *
sizeof(
int));
509 bytes_written = sendmsg (fd, &m, 0
510 #
if HAVE_DECL_MSG_NOSIGNAL
515 if (bytes_written < 0 && errno == EINTR)
519 if (bytes_written > 0)
523 return bytes_written;
549 #if HAVE_DECL_MSG_NOSIGNAL
550 struct iovec vectors[2];
573 vectors[0].iov_base = (
char*) data1;
574 vectors[0].iov_len = len1;
575 vectors[1].iov_base = (
char*) data2;
576 vectors[1].iov_len = len2;
580 m.msg_iovlen = data2 ? 2 : 1;
584 bytes_written = sendmsg (fd, &m, MSG_NOSIGNAL);
586 if (bytes_written < 0 && errno == EINTR)
589 return bytes_written;
593 buffer2, start2, len2);
598 _dbus_socket_is_invalid (
int fd)
642 bytes_read = read (fd, data, count);
692 bytes_written = write (fd, data, len);
694 if (bytes_written < 0 && errno == EINTR)
698 if (bytes_written > 0)
702 return bytes_written;
742 struct iovec vectors[2];
758 vectors[0].iov_base = (
char*) data1;
759 vectors[0].iov_len = len1;
760 vectors[1].iov_base = (
char*) data2;
761 vectors[1].iov_len = len2;
765 bytes_written = writev (fd,
769 if (bytes_written < 0 && errno == EINTR)
772 return bytes_written;
779 if (ret1 == len1 && buffer2 !=
NULL)
793 #define _DBUS_MAX_SUN_PATH_LENGTH 99
831 struct sockaddr_un addr;
833 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
835 _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
839 if (!_dbus_open_unix_socket (&fd, error))
841 _DBUS_ASSERT_ERROR_IS_SET(error);
844 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
847 addr.sun_family = AF_UNIX;
848 path_len = strlen (path);
852 #ifdef HAVE_ABSTRACT_SOCKETS
853 addr.sun_path[0] =
'\0';
856 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
859 "Abstract socket name too long\n");
864 strncpy (&addr.sun_path[1], path, path_len);
868 "Operating system does not support abstract socket namespace\n");
875 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
878 "Socket name too long\n");
883 strncpy (addr.sun_path, path, path_len);
886 if (connect (fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
890 "Failed to connect to socket %s: %s",
891 path, _dbus_strerror (errno));
897 if (!_dbus_set_fd_nonblocking (fd, error))
899 _DBUS_ASSERT_ERROR_IS_SET (error);
930 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
932 _dbus_verbose (
"connecting to process %s\n", path);
935 retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
936 cloexec_done = (retval >= 0);
938 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
941 retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
948 "Failed to create socket pair: %s",
949 _dbus_strerror (errno));
964 "Failed to fork() to call %s: %s",
965 path, _dbus_strerror (errno));
976 dup2 (fds[1], STDIN_FILENO);
977 dup2 (fds[1], STDOUT_FILENO);
979 if (fds[1] != STDIN_FILENO &&
980 fds[1] != STDOUT_FILENO)
990 fprintf (stderr,
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
998 if (!_dbus_set_fd_nonblocking (fds[0], error))
1000 _DBUS_ASSERT_ERROR_IS_SET (error);
1023 #if defined(HAVE_CMSGCRED)
1027 #elif defined(LOCAL_CREDS)
1028 int val = on ? 1 : 0;
1029 if (setsockopt (fd, 0, LOCAL_CREDS, &val,
sizeof (val)) < 0)
1031 _dbus_verbose (
"Unable to set LOCAL_CREDS socket option on fd %d\n", fd);
1035 _dbus_verbose (
"LOCAL_CREDS %s for further messages on fd %d\n",
1036 on ?
"enabled" :
"disabled", fd);
1065 struct sockaddr_un addr;
1067 unsigned int reuseaddr;
1069 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1071 _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
1074 if (!_dbus_open_unix_socket (&listen_fd, error))
1076 _DBUS_ASSERT_ERROR_IS_SET(error);
1079 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1082 addr.sun_family = AF_UNIX;
1083 path_len = strlen (path);
1087 #ifdef HAVE_ABSTRACT_SOCKETS
1091 addr.sun_path[0] =
'\0';
1094 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1097 "Abstract socket name too long\n");
1102 strncpy (&addr.sun_path[1], path, path_len);
1106 "Operating system does not support abstract socket namespace\n");
1126 if (stat (path, &sb) == 0 &&
1127 S_ISSOCK (sb.st_mode))
1131 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1134 "Abstract socket name too long\n");
1139 strncpy (addr.sun_path, path, path_len);
1143 if (setsockopt (listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1145 _dbus_warn (
"Failed to set socket option\"%s\": %s",
1146 path, _dbus_strerror (errno));
1149 if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1152 "Failed to bind socket \"%s\": %s",
1153 path, _dbus_strerror (errno));
1158 if (listen (listen_fd, 30 ) < 0)
1161 "Failed to listen on socket \"%s\": %s",
1162 path, _dbus_strerror (errno));
1167 if (!_dbus_set_local_creds (listen_fd,
TRUE))
1170 "Failed to enable LOCAL_CREDS on socket \"%s\": %s",
1171 path, _dbus_strerror (errno));
1176 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1178 _DBUS_ASSERT_ERROR_IS_SET (error);
1186 if (!
abstract && chmod (path, 0777) < 0)
1187 _dbus_warn (
"Could not set mode 0777 on socket %s\n",
1211 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1213 n = sd_listen_fds (
TRUE);
1217 "Failed to acquire systemd socket: %s",
1218 _dbus_strerror (-n));
1225 "No socket received.");
1229 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1231 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1235 "Failed to verify systemd socket type: %s",
1236 _dbus_strerror (-r));
1243 "Passed socket has wrong type.");
1255 "Failed to allocate file handle array.");
1259 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1261 if (!_dbus_set_local_creds (fd,
TRUE))
1264 "Failed to enable LOCAL_CREDS on systemd socket: %s",
1265 _dbus_strerror (errno));
1269 if (!_dbus_set_fd_nonblocking (fd, error))
1271 _DBUS_ASSERT_ERROR_IS_SET (error);
1275 new_fds[fd - SD_LISTEN_FDS_START] = fd;
1283 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1311 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
1315 _dbus_connect_tcp_socket_with_nonce (
const char *host,
1318 const char *noncefile,
1321 int saved_errno = 0;
1323 struct addrinfo hints;
1324 struct addrinfo *ai, *tmp;
1326 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1331 hints.ai_family = AF_UNSPEC;
1332 else if (!strcmp(family,
"ipv4"))
1333 hints.ai_family = AF_INET;
1334 else if (!strcmp(family,
"ipv6"))
1335 hints.ai_family = AF_INET6;
1340 "Unknown address family %s", family);
1343 hints.ai_protocol = IPPROTO_TCP;
1344 hints.ai_socktype = SOCK_STREAM;
1345 hints.ai_flags = AI_ADDRCONFIG;
1347 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1351 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1352 host, port, gai_strerror(res), res);
1359 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1362 _DBUS_ASSERT_ERROR_IS_SET(error);
1365 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1367 if (connect (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1369 saved_errno = errno;
1384 "Failed to connect to socket \"%s:%s\" %s",
1385 host, port, _dbus_strerror(saved_errno));
1389 if (noncefile !=
NULL)
1394 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1404 if (!_dbus_set_fd_nonblocking (fd, error))
1438 int nlisten_fd = 0, *listen_fd =
NULL, res, i;
1439 struct addrinfo hints;
1440 struct addrinfo *ai, *tmp;
1441 unsigned int reuseaddr;
1444 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1449 hints.ai_family = AF_UNSPEC;
1450 else if (!strcmp(family,
"ipv4"))
1451 hints.ai_family = AF_INET;
1452 else if (!strcmp(family,
"ipv6"))
1453 hints.ai_family = AF_INET6;
1458 "Unknown address family %s", family);
1462 hints.ai_protocol = IPPROTO_TCP;
1463 hints.ai_socktype = SOCK_STREAM;
1464 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1466 redo_lookup_with_port:
1468 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1472 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1473 host ? host :
"*", port, gai_strerror(res), res);
1480 int fd = -1, *newlisten_fd;
1481 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1483 _DBUS_ASSERT_ERROR_IS_SET(error);
1486 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1489 if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1491 _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
1492 host ? host :
"*", port, _dbus_strerror (errno));
1495 if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1497 saved_errno = errno;
1499 if (saved_errno == EADDRINUSE)
1508 "Failed to bind socket \"%s:%s\": %s",
1509 host ? host :
"*", port, _dbus_strerror (saved_errno));
1513 if (listen (fd, 30 ) < 0)
1515 saved_errno = errno;
1518 "Failed to listen on socket \"%s:%s\": %s",
1519 host ? host :
"*", port, _dbus_strerror (saved_errno));
1523 newlisten_fd =
dbus_realloc(listen_fd,
sizeof(
int)*(nlisten_fd+1));
1526 saved_errno = errno;
1529 "Failed to allocate file handle array: %s",
1530 _dbus_strerror (saved_errno));
1533 listen_fd = newlisten_fd;
1534 listen_fd[nlisten_fd] = fd;
1543 if (!port || !strcmp(port,
"0"))
1546 struct sockaddr_storage addr;
1550 addrlen =
sizeof(addr);
1551 result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
1554 (res = getnameinfo ((
struct sockaddr*)&addr, addrlen,
NULL, 0,
1555 portbuf,
sizeof(portbuf),
1556 NI_NUMERICHOST)) != 0)
1559 "Failed to resolve port \"%s:%s\": %s (%s)",
1560 host ? host :
"*", port, gai_strerror(res), res);
1572 goto redo_lookup_with_port;
1593 "Failed to bind socket \"%s:%s\": %s",
1594 host ? host :
"*", port, _dbus_strerror (errno));
1598 for (i = 0 ; i < nlisten_fd ; i++)
1600 if (!_dbus_set_fd_nonblocking (listen_fd[i], error))
1613 for (i = 0 ; i < nlisten_fd ; i++)
1620 write_credentials_byte (
int server_fd,
1624 char buf[1] = {
'\0' };
1625 #if defined(HAVE_CMSGCRED)
1628 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1639 msg.msg_control = (caddr_t) &cmsg;
1640 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1642 cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
1643 cmsg.hdr.cmsg_level = SOL_SOCKET;
1644 cmsg.hdr.cmsg_type = SCM_CREDS;
1647 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1651 #if defined(HAVE_CMSGCRED)
1652 bytes_written = sendmsg (server_fd, &msg, 0
1653 #
if HAVE_DECL_MSG_NOSIGNAL
1658 bytes_written = send (server_fd, buf, 1, 0
1659 #
if HAVE_DECL_MSG_NOSIGNAL
1665 if (bytes_written < 0 && errno == EINTR)
1668 if (bytes_written < 0)
1671 "Failed to write credentials byte: %s",
1672 _dbus_strerror (errno));
1675 else if (bytes_written == 0)
1678 "wrote zero bytes writing credentials byte");
1684 _dbus_verbose (
"wrote credentials byte\n");
1722 #ifdef HAVE_CMSGCRED
1725 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1728 #elif defined(LOCAL_CREDS)
1731 struct sockcred cred;
1738 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1756 iov.iov_base = &buf;
1763 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
1765 msg.msg_control = (caddr_t) &cmsg;
1766 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1770 bytes_read = recvmsg (client_fd, &msg, 0);
1783 "Failed to read credentials byte: %s",
1784 _dbus_strerror (errno));
1787 else if (bytes_read == 0)
1793 "Failed to read credentials byte (zero-length read)");
1796 else if (buf !=
'\0')
1799 "Credentials byte was not nul");
1803 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
1804 if (cmsg.hdr.cmsg_len < CMSG_LEN (
sizeof (
struct cmsgcred))
1805 || cmsg.hdr.cmsg_type != SCM_CREDS)
1808 "Message from recvmsg() was not SCM_CREDS");
1813 _dbus_verbose (
"read credentials byte\n");
1818 struct sockpeercred cr;
1822 int cr_len =
sizeof (cr);
1824 if (getsockopt (client_fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) == 0 &&
1825 cr_len ==
sizeof (cr))
1832 _dbus_verbose (
"Failed to getsockopt() credentials, returned len %d/%d: %s\n",
1833 cr_len, (
int)
sizeof (cr), _dbus_strerror (errno));
1835 #elif defined(HAVE_CMSGCRED)
1836 struct cmsgcred *cred;
1838 cred = (
struct cmsgcred *) CMSG_DATA (&cmsg.hdr);
1839 pid_read = cred->cmcred_pid;
1840 uid_read = cred->cmcred_euid;
1841 #elif defined(LOCAL_CREDS)
1843 uid_read = cmsg.cred.sc_uid;
1846 _dbus_set_local_creds (client_fd,
FALSE);
1847 #elif defined(HAVE_GETPEEREID)
1850 if (getpeereid (client_fd, &euid, &egid) == 0)
1856 _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
1858 #elif defined(HAVE_GETPEERUCRED)
1859 ucred_t * ucred =
NULL;
1860 if (getpeerucred (client_fd, &ucred) == 0)
1862 pid_read = ucred_getpid (ucred);
1863 uid_read = ucred_geteuid (ucred);
1866 adt_session_data_t *adth =
NULL;
1867 adt_export_data_t *data =
NULL;
1869 if (adt_start_session (&adth,
NULL, 0) || (adth ==
NULL))
1871 _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
1875 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
1877 _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
1881 size = adt_export_session_data (adth, &data);
1884 _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
1892 (void) adt_end_session (adth);
1898 _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
1903 _dbus_verbose (
"Socket credentials not supported on this OS\n");
1907 _dbus_verbose (
"Credentials:"
1918 _DBUS_SET_OOM (error);
1927 _DBUS_SET_OOM (error);
1956 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1958 if (write_credentials_byte (server_fd, error))
1977 struct sockaddr addr;
1983 addrlen =
sizeof (addr);
1993 client_fd = accept4 (listen_fd, &addr, &addrlen, SOCK_CLOEXEC);
1994 cloexec_done = client_fd >= 0;
1996 if (client_fd < 0 && (errno == ENOSYS || errno == EINVAL))
1999 client_fd = accept (listen_fd, &addr, &addrlen);
2008 _dbus_verbose (
"client fd %d accepted\n", client_fd);
2031 const char *directory;
2034 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2038 if (stat (directory, &sb) < 0)
2041 "%s", _dbus_strerror (errno));
2046 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
2047 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
2050 "%s directory is not private to the user", directory);
2058 fill_user_info_from_passwd (
struct passwd *p,
2065 info->
uid = p->pw_uid;
2086 const char *username_c;
2099 if (username !=
NULL)
2109 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
2115 struct passwd p_str;
2118 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
2124 if ((
long) buflen <= 0)
2138 #ifdef HAVE_POSIX_GETPWNAM_R
2140 result = getpwuid_r (uid, &p_str, buf, buflen,
2143 result = getpwnam_r (username_c, &p_str, buf, buflen,
2147 p = getpwuid_r (uid, &p_str, buf, buflen);
2149 p = getpwnam_r (username_c, &p_str, buf, buflen);
2153 if (result == ERANGE && buflen < 512 * 1024)
2163 if (result == 0 && p == &p_str)
2165 if (!fill_user_info_from_passwd (p, info, error))
2175 "User \"%s\" unknown or no memory to allocate password entry\n",
2176 username_c ? username_c :
"???");
2177 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2190 p = getpwnam (username_c);
2194 if (!fill_user_info_from_passwd (p, info, error))
2202 "User \"%s\" unknown or no memory to allocate password entry\n",
2203 username_c ? username_c :
"???");
2204 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2213 #ifdef HAVE_GETGROUPLIST
2218 int initial_buf_count;
2220 initial_buf_count = 17;
2221 buf_count = initial_buf_count;
2229 if (getgrouplist (username_c,
2231 buf, &buf_count) < 0)
2247 if (buf_count == initial_buf_count)
2262 if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
2266 _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2267 username_c, buf_count, buf_count);
2273 "Failed to get groups for username \"%s\" primary GID "
2276 _dbus_strerror (errno));
2291 for (i = 0; i < buf_count; ++i)
2314 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2319 _DBUS_ASSERT_ERROR_IS_SET (error);
2353 return fill_user_info (info, uid,
2457 _dbus_verbose (
"UID string was zero length\n");
2466 _dbus_verbose (
"could not parse string as a UID\n");
2472 _dbus_verbose (
"string contained trailing stuff after UID\n");
2495 return __sync_add_and_fetch(&atomic->
value, 1)-1;
2499 res = atomic->
value;
2516 return __sync_sub_and_fetch(&atomic->
value, 1)+1;
2521 res = atomic->
value;
2539 __sync_synchronize ();
2540 return atomic->
value;
2545 res = atomic->
value;
2562 int timeout_milliseconds)
2564 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
2575 sizeof (
DBusPollFD) ==
sizeof (
struct pollfd) &&
2577 _DBUS_STRUCT_OFFSET (
struct pollfd, fd) &&
2579 _DBUS_STRUCT_OFFSET (
struct pollfd, events) &&
2581 _DBUS_STRUCT_OFFSET (
struct pollfd, revents))
2583 return poll ((
struct pollfd*) fds,
2585 timeout_milliseconds);
2592 _dbus_warn (
"didn't implement poll() properly for this system yet\n");
2597 fd_set read_set, write_set, err_set;
2603 FD_ZERO (&read_set);
2604 FD_ZERO (&write_set);
2607 for (i = 0; i < n_fds; i++)
2612 FD_SET (fdp->
fd, &read_set);
2615 FD_SET (fdp->
fd, &write_set);
2617 FD_SET (fdp->
fd, &err_set);
2619 max_fd = MAX (max_fd, fdp->
fd);
2622 tv.tv_sec = timeout_milliseconds / 1000;
2623 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
2625 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
2626 timeout_milliseconds < 0 ?
NULL : &tv);
2630 for (i = 0; i < n_fds; i++)
2636 if (FD_ISSET (fdp->
fd, &read_set))
2639 if (FD_ISSET (fdp->
fd, &write_set))
2642 if (FD_ISSET (fdp->
fd, &err_set))
2662 #ifdef HAVE_MONOTONIC_CLOCK
2664 clock_gettime (CLOCK_MONOTONIC, &ts);
2667 *tv_sec = ts.tv_sec;
2669 *tv_usec = ts.tv_nsec / 1000;
2673 gettimeofday (&t,
NULL);
2678 *tv_usec = t.tv_usec;
2695 gettimeofday (&t,
NULL);
2700 *tv_usec = t.tv_usec;
2715 const char *filename_c;
2717 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2721 if (mkdir (filename_c, 0700) < 0)
2723 if (errno == EEXIST)
2727 "Failed to create directory %s: %s\n",
2728 filename_c, _dbus_strerror (errno));
2761 if (dir_ends_in_slash && file_starts_with_slash)
2765 else if (!(dir_ends_in_slash || file_starts_with_slash))
2776 #define NANOSECONDS_PER_SECOND 1000000000
2778 #define MICROSECONDS_PER_SECOND 1000000
2780 #define MILLISECONDS_PER_SECOND 1000
2782 #define NANOSECONDS_PER_MILLISECOND 1000000
2784 #define MICROSECONDS_PER_MILLISECOND 1000
2793 #ifdef HAVE_NANOSLEEP
2794 struct timespec req;
2795 struct timespec rem;
2797 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
2798 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
2802 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
2804 #elif defined (HAVE_USLEEP)
2805 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
2807 sleep (MAX (milliseconds / 1000, 1));
2812 _dbus_generate_pseudorandom_bytes (
DBusString *str,
2855 fd = open (
"/dev/urandom", O_RDONLY);
2857 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2859 _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
2861 if (
_dbus_read (fd, str, n_bytes) != n_bytes)
2865 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2868 _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
2896 _dbus_strerror (
int error_number)
2900 msg = strerror (error_number);
2913 signal (SIGPIPE, SIG_IGN);
2928 val = fcntl (fd, F_GETFD, 0);
2935 fcntl (fd, F_SETFD, val);
2949 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2958 "Could not close fd %d", fd);
2978 #ifdef F_DUPFD_CLOEXEC
2981 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2982 cloexec_done = new_fd >= 0;
2984 if (new_fd < 0 && errno == EINVAL)
2987 new_fd = fcntl(fd, F_DUPFD, 3);
2993 "Could not duplicate fd %d", fd);
2997 #ifdef F_DUPFD_CLOEXEC
3015 _dbus_set_fd_nonblocking (
int fd,
3020 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3022 val = fcntl (fd, F_GETFL, 0);
3026 "Failed to get flags from file descriptor %d: %s",
3027 fd, _dbus_strerror (errno));
3028 _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
3029 _dbus_strerror (errno));
3033 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
3036 "Failed to set nonblocking flag of file descriptor %d: %s",
3037 fd, _dbus_strerror (errno));
3038 _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
3039 fd, _dbus_strerror (errno));
3055 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
3061 bt_size = backtrace (bt, 500);
3063 syms = backtrace_symbols (bt, bt_size);
3069 fprintf (stderr,
" %s\n", syms[i]);
3075 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
3076 fprintf (stderr,
" D-Bus not built with -rdynamic so unable to print a backtrace\n");
3078 fprintf (stderr,
" D-Bus not compiled with backtrace support so unable to print a backtrace\n");
3100 #ifdef HAVE_SOCKETPAIR
3107 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
3108 cloexec_done = retval >= 0;
3110 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
3113 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
3119 "Could not create full-duplex pipe");
3123 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3134 (!_dbus_set_fd_nonblocking (fds[0],
NULL) ||
3135 !_dbus_set_fd_nonblocking (fds[1],
NULL)))
3138 "Could not set full-duplex pipe nonblocking");
3149 _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
3154 _dbus_warn (
"_dbus_full_duplex_pipe() not implemented on this OS\n");
3156 "_dbus_full_duplex_pipe() not implemented on this OS");
3173 char static_buf[1024];
3174 int bufsize =
sizeof (static_buf);
3178 DBUS_VA_COPY (args_copy, args);
3179 len = vsnprintf (static_buf, bufsize, format, args_copy);
3196 DBUS_VA_COPY (args_copy, args);
3198 if (vsnprintf (static_buf, 1, format, args_copy) == 1)
3217 DBUS_VA_COPY (args_copy, args);
3218 len = vsnprintf (buf, bufsize, format, args_copy);
3242 static const char* tmpdir =
NULL;
3251 tmpdir = getenv(
"TMPDIR");
3257 tmpdir = getenv(
"TMP");
3259 tmpdir = getenv(
"TEMP");
3291 _read_subprocess_line_argv (
const char *progpath,
3297 int result_pipe[2] = { -1, -1 };
3298 int errors_pipe[2] = { -1, -1 };
3305 sigset_t new_set, old_set;
3307 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3314 sigemptyset (&new_set);
3315 sigaddset (&new_set, SIGCHLD);
3316 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3322 if (pipe (result_pipe) < 0)
3325 "Failed to create a pipe to call %s: %s",
3326 progpath, _dbus_strerror (errno));
3327 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3328 progpath, _dbus_strerror (errno));
3331 if (pipe (errors_pipe) < 0)
3334 "Failed to create a pipe to call %s: %s",
3335 progpath, _dbus_strerror (errno));
3336 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3337 progpath, _dbus_strerror (errno));
3345 "Failed to fork() to call %s: %s",
3346 progpath, _dbus_strerror (errno));
3347 _dbus_verbose (
"Failed to fork() to call %s: %s\n",
3348 progpath, _dbus_strerror (errno));
3357 fd = open (
"/dev/null", O_RDWR);
3362 _dbus_verbose (
"/dev/null fd %d opened\n", fd);
3371 if (dup2 (fd, 0) == -1)
3373 if (dup2 (result_pipe[
WRITE_END], 1) == -1)
3375 if (dup2 (errors_pipe[WRITE_END], 2) == -1)
3380 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3383 if (progpath[0] ==
'/')
3385 execv (progpath, argv);
3394 execvp (strrchr (progpath,
'/')+1, argv);
3397 execvp (progpath, argv);
3404 close (result_pipe[WRITE_END]);
3405 close (errors_pipe[WRITE_END]);
3419 ret = waitpid (pid, &status, 0);
3421 while (ret == -1 && errno == EINTR);
3425 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
3431 _DBUS_SET_OOM (error);
3445 "%s terminated abnormally with the following error: %s",
3449 "%s terminated abnormally without any error message",
3457 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3460 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3462 _DBUS_ASSERT_ERROR_IS_SET (error);
3464 if (result_pipe[0] != -1)
3465 close (result_pipe[0]);
3466 if (result_pipe[1] != -1)
3467 close (result_pipe[1]);
3468 if (errors_pipe[0] != -1)
3469 close (errors_pipe[0]);
3470 if (errors_pipe[1] != -1)
3471 close (errors_pipe[1]);
3496 const char *display;
3497 static char *argv[6];
3505 "Unable to autolaunch when setuid");
3509 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3517 if (display ==
NULL || display[0] ==
'\0')
3520 "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
3526 _DBUS_SET_OOM (error);
3532 _DBUS_SET_OOM (error);
3537 argv[i] =
"dbus-launch";
3539 argv[i] =
"--autolaunch";
3543 argv[i] =
"--binary-syntax";
3545 argv[i] =
"--close-stderr";
3552 retval = _read_subprocess_line_argv (DBUS_BINDIR
"/dbus-launch",
3554 argv, address, error);
3561 "Using X11 for dbus-daemon autolaunch was disabled at compile time, "
3562 "set your DBUS_SESSION_BUS_ADDRESS instead");
3606 #define DBUS_UNIX_STANDARD_SESSION_SERVICEDIR "/dbus-1/services"
3607 #define DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR "/dbus-1/system-services"
3617 const char *launchd_env_var,
3620 #ifdef DBUS_ENABLE_LAUNCHD
3624 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3629 "Unable to find launchd socket when setuid");
3634 argv[i] =
"launchctl";
3638 argv[i] = (
char*)launchd_env_var;
3645 if (!_read_subprocess_line_argv(argv[0],
TRUE, argv, socket_path, error))
3661 "can't lookup socket from launchd; launchd support not compiled in");
3666 #ifdef DBUS_ENABLE_LAUNCHD
3676 "Unable to find launchd socket when setuid");
3682 _DBUS_SET_OOM (error);
3697 "launchd did not provide a socket path, "
3698 "verify that org.freedesktop.dbus-session.plist is loaded!");
3704 _DBUS_SET_OOM (error);
3711 _DBUS_SET_OOM (error);
3745 #ifdef DBUS_ENABLE_LAUNCHD
3747 return _dbus_lookup_session_address_launchd (address, error);
3778 const char *xdg_data_home;
3779 const char *xdg_data_dirs;
3788 if (xdg_data_home !=
NULL)
3812 if (xdg_data_dirs !=
NULL)
3836 DBUS_UNIX_STANDARD_SESSION_SERVICEDIR,
3879 static const char standard_search_path[] =
3889 DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR,
3965 #ifdef DBUS_BUILD_TESTS
3967 const char *
override;
3970 if (
override !=
NULL && *
override !=
'\0')
3976 _dbus_verbose (
"Using fake homedir for testing: %s\n",
3982 if (!already_warned)
3984 _dbus_warn (
"Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid\n");
3985 already_warned =
TRUE;
4011 _dbus_daemon_publish_session_bus_address (
const char* addr,
4019 _dbus_daemon_unpublish_session_bus_address (
void)
4033 return errno == EAGAIN || errno == EWOULDBLOCK;
4047 const char *filename_c;
4049 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4053 if (rmdir (filename_c) != 0)
4056 "Failed to remove directory %s: %s\n",
4057 filename_c, _dbus_strerror (errno));
4077 struct sockaddr_storage storage;
4078 struct sockaddr_un un;
4081 socklen_t sa_len =
sizeof(sa_buf);
4085 if (getsockname(fd, &sa_buf.sa, &sa_len) < 0)
4088 return sa_buf.sa.sa_family == AF_UNIX;
4105 _dbus_replace_install_prefix (
const char *configure_time_path)
4107 return configure_time_path;
4125 d = opendir (
"/proc/self/fd");
4135 k = readdir_r (d, &buf, &de);
4139 if (de->d_name[0] ==
'.')
4143 l = strtol (de->d_name, &e, 10);
4144 if (errno != 0 || e ==
NULL || *e !=
'\0')
4151 if (fd == dirfd (d))
4162 maxfds = sysconf (_SC_OPEN_MAX);
4171 for (i = 3; i < maxfds; i++)
4190 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE)
4193 extern int __libc_enable_secure;
4194 return __libc_enable_secure;
4196 #elif defined(HAVE_ISSETUGID)
4198 return issetugid ();
4200 uid_t ruid, euid, suid;
4201 gid_t rgid, egid, sgid;
4206 if (_DBUS_UNLIKELY (!check_setuid_initialised))
4208 #ifdef HAVE_GETRESUID
4209 if (getresuid (&ruid, &euid, &suid) != 0 ||
4210 getresgid (&rgid, &egid, &sgid) != 0)
4213 suid = ruid = getuid ();
4214 sgid = rgid = getgid ();
4219 check_setuid_initialised =
TRUE;
4220 is_setuid = (ruid != euid || ruid != suid ||
4221 rgid != egid || rgid != sgid);