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>
58 #include <arpa/inet.h>
72 #ifdef HAVE_GETPEERUCRED
83 #include "sd-daemon.h"
94 #define AI_ADDRCONFIG 0
97 #ifndef HAVE_SOCKLEN_T
101 #if defined (__sun) || defined (__sun__)
114 # define CMSG_ALIGN(len) _CMSG_DATA_ALIGN (len)
117 # define CMSG_ALIGN(len) (((len) + sizeof (long) - 1) & \
118 ~(sizeof (long) - 1))
123 # define CMSG_SPACE(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + \
128 # define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
134 _dbus_open_socket (
int *fd_p,
143 *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
144 cloexec_done = *fd_p >= 0;
147 if (*fd_p < 0 && (errno == EINVAL || errno == EPROTOTYPE))
150 *fd_p = socket (domain, type, protocol);
162 _dbus_verbose (
"socket fd %d opened\n", *fd_p);
169 "Failed to open socket: %s",
170 _dbus_strerror (errno));
186 _dbus_open_unix_socket (
int *fd,
189 return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);
240 #if HAVE_DECL_MSG_NOSIGNAL
244 data = _dbus_string_get_const_data_len (buffer, start, len);
248 bytes_written = send (fd, data, len, MSG_NOSIGNAL);
250 if (bytes_written < 0 && errno == EINTR)
253 return bytes_written;
278 #ifndef HAVE_UNIX_FD_PASSING
296 start = _dbus_string_get_length (buffer);
316 m.msg_controllen = CMSG_SPACE(*n_fds *
sizeof(
int));
320 m.msg_control = alloca(m.msg_controllen);
321 memset(m.msg_control, 0, m.msg_controllen);
325 bytes_read = recvmsg(fd, &m, 0
326 #ifdef MSG_CMSG_CLOEXEC
347 if (m.msg_flags & MSG_CTRUNC)
359 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
360 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
364 _dbus_assert(cm->cmsg_len <= CMSG_LEN(*n_fds *
sizeof(
int)));
365 *n_fds = (cm->cmsg_len - CMSG_LEN(0)) /
sizeof(
int);
367 memcpy(fds, CMSG_DATA(cm), *n_fds *
sizeof(
int));
373 for (i = 0; i < *n_fds; i++)
396 _dbus_write_socket_with_unix_fds(
int fd,
403 #ifndef HAVE_UNIX_FD_PASSING
412 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len,
NULL, 0, 0, fds, n_fds);
417 _dbus_write_socket_with_unix_fds_two(
int fd,
427 #ifndef HAVE_UNIX_FD_PASSING
435 buffer1, start1, len1,
436 buffer2, start2, len2);
449 iov[0].iov_base = (
char*) _dbus_string_get_const_data_len (buffer1, start1, len1);
450 iov[0].iov_len = len1;
454 iov[1].iov_base = (
char*) _dbus_string_get_const_data_len (buffer2, start2, len2);
455 iov[1].iov_len = len2;
460 m.msg_iovlen = buffer2 ? 2 : 1;
464 m.msg_controllen = CMSG_SPACE(n_fds *
sizeof(
int));
465 m.msg_control = alloca(m.msg_controllen);
466 memset(m.msg_control, 0, m.msg_controllen);
468 cm = CMSG_FIRSTHDR(&m);
469 cm->cmsg_level = SOL_SOCKET;
470 cm->cmsg_type = SCM_RIGHTS;
471 cm->cmsg_len = CMSG_LEN(n_fds *
sizeof(
int));
472 memcpy(CMSG_DATA(cm), fds, n_fds *
sizeof(
int));
477 bytes_written = sendmsg (fd, &m, 0
478 #
if HAVE_DECL_MSG_NOSIGNAL
483 if (bytes_written < 0 && errno == EINTR)
487 if (bytes_written > 0)
491 return bytes_written;
517 #if HAVE_DECL_MSG_NOSIGNAL
518 struct iovec vectors[2];
530 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
533 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
541 vectors[0].iov_base = (
char*) data1;
542 vectors[0].iov_len = len1;
543 vectors[1].iov_base = (
char*) data2;
544 vectors[1].iov_len = len2;
548 m.msg_iovlen = data2 ? 2 : 1;
552 bytes_written = sendmsg (fd, &m, MSG_NOSIGNAL);
554 if (bytes_written < 0 && errno == EINTR)
557 return bytes_written;
561 buffer2, start2, len2);
566 _dbus_socket_is_invalid (
int fd)
598 start = _dbus_string_get_length (buffer);
610 bytes_read = read (fd, data, count);
656 data = _dbus_string_get_const_data_len (buffer, start, len);
660 bytes_written = write (fd, data, len);
662 if (bytes_written < 0 && errno == EINTR)
666 if (bytes_written > 0)
670 return bytes_written;
710 struct iovec vectors[2];
715 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
718 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
726 vectors[0].iov_base = (
char*) data1;
727 vectors[0].iov_len = len1;
728 vectors[1].iov_base = (
char*) data2;
729 vectors[1].iov_len = len2;
733 bytes_written = writev (fd,
737 if (bytes_written < 0 && errno == EINTR)
740 return bytes_written;
747 if (ret1 == len1 && buffer2 !=
NULL)
761 #define _DBUS_MAX_SUN_PATH_LENGTH 99
799 struct sockaddr_un addr;
801 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
803 _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
807 if (!_dbus_open_unix_socket (&fd, error))
809 _DBUS_ASSERT_ERROR_IS_SET(error);
812 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
815 addr.sun_family = AF_UNIX;
816 path_len = strlen (path);
820 #ifdef HAVE_ABSTRACT_SOCKETS
821 addr.sun_path[0] =
'\0';
824 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
827 "Abstract socket name too long\n");
832 strncpy (&addr.sun_path[1], path, path_len);
836 "Operating system does not support abstract socket namespace\n");
843 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
846 "Socket name too long\n");
851 strncpy (addr.sun_path, path, path_len);
854 if (connect (fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
858 "Failed to connect to socket %s: %s",
859 path, _dbus_strerror (errno));
865 if (!_dbus_set_fd_nonblocking (fd, error))
867 _DBUS_ASSERT_ERROR_IS_SET (error);
898 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
900 _dbus_verbose (
"connecting to process %s\n", path);
903 retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
904 cloexec_done = (retval >= 0);
906 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
909 retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
916 "Failed to create socket pair: %s",
917 _dbus_strerror (errno));
932 "Failed to fork() to call %s: %s",
933 path, _dbus_strerror (errno));
944 dup2 (fds[1], STDIN_FILENO);
945 dup2 (fds[1], STDOUT_FILENO);
947 if (fds[1] != STDIN_FILENO &&
948 fds[1] != STDOUT_FILENO)
958 fprintf (stderr,
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
966 if (!_dbus_set_fd_nonblocking (fds[0], error))
968 _DBUS_ASSERT_ERROR_IS_SET (error);
1000 struct sockaddr_un addr;
1002 unsigned int reuseaddr;
1004 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1006 _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
1009 if (!_dbus_open_unix_socket (&listen_fd, error))
1011 _DBUS_ASSERT_ERROR_IS_SET(error);
1014 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1017 addr.sun_family = AF_UNIX;
1018 path_len = strlen (path);
1022 #ifdef HAVE_ABSTRACT_SOCKETS
1026 addr.sun_path[0] =
'\0';
1029 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1032 "Abstract socket name too long\n");
1037 strncpy (&addr.sun_path[1], path, path_len);
1041 "Operating system does not support abstract socket namespace\n");
1061 if (stat (path, &sb) == 0 &&
1062 S_ISSOCK (sb.st_mode))
1066 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1069 "Abstract socket name too long\n");
1074 strncpy (addr.sun_path, path, path_len);
1078 if (setsockopt (listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1080 _dbus_warn (
"Failed to set socket option\"%s\": %s",
1081 path, _dbus_strerror (errno));
1084 if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1087 "Failed to bind socket \"%s\": %s",
1088 path, _dbus_strerror (errno));
1093 if (listen (listen_fd, 30 ) < 0)
1096 "Failed to listen on socket \"%s\": %s",
1097 path, _dbus_strerror (errno));
1102 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1104 _DBUS_ASSERT_ERROR_IS_SET (error);
1112 if (!
abstract && chmod (path, 0777) < 0)
1113 _dbus_warn (
"Could not set mode 0777 on socket %s\n",
1137 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1139 n = sd_listen_fds (
TRUE);
1143 "Failed to acquire systemd socket: %s",
1144 _dbus_strerror (-n));
1151 "No socket received.");
1155 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1157 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1161 "Failed to verify systemd socket type: %s",
1162 _dbus_strerror (-r));
1169 "Passed socket has wrong type.");
1181 "Failed to allocate file handle array.");
1185 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1187 if (!_dbus_set_fd_nonblocking (fd, error))
1189 _DBUS_ASSERT_ERROR_IS_SET (error);
1193 new_fds[fd - SD_LISTEN_FDS_START] = fd;
1201 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1229 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
1233 _dbus_connect_tcp_socket_with_nonce (
const char *host,
1236 const char *noncefile,
1239 int saved_errno = 0;
1241 struct addrinfo hints;
1242 struct addrinfo *ai, *tmp;
1244 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1249 hints.ai_family = AF_UNSPEC;
1250 else if (!strcmp(family,
"ipv4"))
1251 hints.ai_family = AF_INET;
1252 else if (!strcmp(family,
"ipv6"))
1253 hints.ai_family = AF_INET6;
1258 "Unknown address family %s", family);
1261 hints.ai_protocol = IPPROTO_TCP;
1262 hints.ai_socktype = SOCK_STREAM;
1263 hints.ai_flags = AI_ADDRCONFIG;
1265 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1269 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1270 host, port, gai_strerror(res), res);
1277 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1280 _DBUS_ASSERT_ERROR_IS_SET(error);
1283 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1285 if (connect (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1287 saved_errno = errno;
1302 "Failed to connect to socket \"%s:%s\" %s",
1303 host, port, _dbus_strerror(saved_errno));
1307 if (noncefile !=
NULL)
1312 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1322 if (!_dbus_set_fd_nonblocking (fd, error))
1356 int nlisten_fd = 0, *listen_fd =
NULL, res, i;
1357 struct addrinfo hints;
1358 struct addrinfo *ai, *tmp;
1359 unsigned int reuseaddr;
1362 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1367 hints.ai_family = AF_UNSPEC;
1368 else if (!strcmp(family,
"ipv4"))
1369 hints.ai_family = AF_INET;
1370 else if (!strcmp(family,
"ipv6"))
1371 hints.ai_family = AF_INET6;
1376 "Unknown address family %s", family);
1380 hints.ai_protocol = IPPROTO_TCP;
1381 hints.ai_socktype = SOCK_STREAM;
1382 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1384 redo_lookup_with_port:
1386 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1390 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1391 host ? host :
"*", port, gai_strerror(res), res);
1398 int fd = -1, *newlisten_fd;
1399 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1401 _DBUS_ASSERT_ERROR_IS_SET(error);
1404 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1407 if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1409 _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
1410 host ? host :
"*", port, _dbus_strerror (errno));
1413 if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1415 saved_errno = errno;
1417 if (saved_errno == EADDRINUSE)
1426 "Failed to bind socket \"%s:%s\": %s",
1427 host ? host :
"*", port, _dbus_strerror (saved_errno));
1431 if (listen (fd, 30 ) < 0)
1433 saved_errno = errno;
1436 "Failed to listen on socket \"%s:%s\": %s",
1437 host ? host :
"*", port, _dbus_strerror (saved_errno));
1441 newlisten_fd =
dbus_realloc(listen_fd,
sizeof(
int)*(nlisten_fd+1));
1444 saved_errno = errno;
1447 "Failed to allocate file handle array: %s",
1448 _dbus_strerror (saved_errno));
1451 listen_fd = newlisten_fd;
1452 listen_fd[nlisten_fd] = fd;
1455 if (!_dbus_string_get_length(retport))
1461 if (!port || !strcmp(port,
"0"))
1464 struct sockaddr_storage addr;
1468 addrlen =
sizeof(addr);
1469 result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
1472 (res = getnameinfo ((
struct sockaddr*)&addr, addrlen,
NULL, 0,
1473 portbuf,
sizeof(portbuf),
1474 NI_NUMERICHOST)) != 0)
1477 "Failed to resolve port \"%s:%s\": %s (%s)",
1478 host ? host :
"*", port, gai_strerror(res), res);
1488 port = _dbus_string_get_const_data(retport);
1490 goto redo_lookup_with_port;
1511 "Failed to bind socket \"%s:%s\": %s",
1512 host ? host :
"*", port, _dbus_strerror (errno));
1516 for (i = 0 ; i < nlisten_fd ; i++)
1518 if (!_dbus_set_fd_nonblocking (listen_fd[i], error))
1531 for (i = 0 ; i < nlisten_fd ; i++)
1538 write_credentials_byte (
int server_fd,
1542 char buf[1] = {
'\0' };
1543 #if defined(HAVE_CMSGCRED)
1546 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1557 msg.msg_control = (caddr_t) &cmsg;
1558 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1560 cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
1561 cmsg.hdr.cmsg_level = SOL_SOCKET;
1562 cmsg.hdr.cmsg_type = SCM_CREDS;
1565 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1569 #if defined(HAVE_CMSGCRED)
1570 bytes_written = sendmsg (server_fd, &msg, 0
1571 #
if HAVE_DECL_MSG_NOSIGNAL
1576 bytes_written = send (server_fd, buf, 1, 0
1577 #
if HAVE_DECL_MSG_NOSIGNAL
1583 if (bytes_written < 0 && errno == EINTR)
1586 if (bytes_written < 0)
1589 "Failed to write credentials byte: %s",
1590 _dbus_strerror (errno));
1593 else if (bytes_written == 0)
1596 "wrote zero bytes writing credentials byte");
1602 _dbus_verbose (
"wrote credentials byte\n");
1640 #ifdef HAVE_CMSGCRED
1643 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1650 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1662 iov.iov_base = &buf;
1669 #if defined(HAVE_CMSGCRED)
1671 msg.msg_control = (caddr_t) &cmsg;
1672 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1676 bytes_read = recvmsg (client_fd, &msg, 0);
1689 "Failed to read credentials byte: %s",
1690 _dbus_strerror (errno));
1693 else if (bytes_read == 0)
1699 "Failed to read credentials byte (zero-length read)");
1702 else if (buf !=
'\0')
1705 "Credentials byte was not nul");
1709 #if defined(HAVE_CMSGCRED)
1710 if (cmsg.hdr.cmsg_len < CMSG_LEN (
sizeof (
struct cmsgcred))
1711 || cmsg.hdr.cmsg_type != SCM_CREDS)
1714 "Message from recvmsg() was not SCM_CREDS");
1719 _dbus_verbose (
"read credentials byte\n");
1732 struct sockpeercred cr;
1736 int cr_len =
sizeof (cr);
1738 if (getsockopt (client_fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) == 0 &&
1739 cr_len ==
sizeof (cr))
1746 _dbus_verbose (
"Failed to getsockopt() credentials, returned len %d/%d: %s\n",
1747 cr_len, (
int)
sizeof (cr), _dbus_strerror (errno));
1749 #elif defined(HAVE_CMSGCRED)
1758 struct cmsgcred *cred;
1760 cred = (
struct cmsgcred *) CMSG_DATA (&cmsg.hdr);
1761 pid_read = cred->cmcred_pid;
1762 uid_read = cred->cmcred_euid;
1764 #elif defined(HAVE_GETPEERUCRED)
1768 ucred_t * ucred =
NULL;
1769 if (getpeerucred (client_fd, &ucred) == 0)
1771 pid_read = ucred_getpid (ucred);
1772 uid_read = ucred_geteuid (ucred);
1775 adt_session_data_t *adth =
NULL;
1776 adt_export_data_t *data =
NULL;
1778 if (adt_start_session (&adth,
NULL, 0) || (adth ==
NULL))
1780 _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
1784 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
1786 _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
1790 size = adt_export_session_data (adth, &data);
1793 _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
1801 (void) adt_end_session (adth);
1807 _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
1817 #elif defined(HAVE_GETPEEREID)
1835 if (getpeereid (client_fd, &euid, &egid) == 0)
1841 _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
1845 #warning Socket credentials not supported on this Unix OS
1846 #warning Please tell https://bugs.freedesktop.org/enter_bug.cgi?product=DBus
1852 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
1853 defined(__linux__) || \
1854 defined(__OpenBSD__) || \
1856 # error Credentials passing not working on this OS is a regression!
1859 _dbus_verbose (
"Socket credentials not supported on this OS\n");
1863 _dbus_verbose (
"Credentials:"
1874 _DBUS_SET_OOM (error);
1883 _DBUS_SET_OOM (error);
1912 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1914 if (write_credentials_byte (server_fd, error))
1933 struct sockaddr addr;
1939 addrlen =
sizeof (addr);
1949 client_fd = accept4 (listen_fd, &addr, &addrlen, SOCK_CLOEXEC);
1950 cloexec_done = client_fd >= 0;
1952 if (client_fd < 0 && (errno == ENOSYS || errno == EINVAL))
1955 client_fd = accept (listen_fd, &addr, &addrlen);
1964 _dbus_verbose (
"client fd %d accepted\n", client_fd);
1987 const char *directory;
1990 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1992 directory = _dbus_string_get_const_data (dir);
1994 if (stat (directory, &sb) < 0)
1997 "%s", _dbus_strerror (errno));
2002 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
2003 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
2006 "%s directory is not private to the user", directory);
2014 fill_user_info_from_passwd (
struct passwd *p,
2021 info->
uid = p->pw_uid;
2042 const char *username_c;
2055 if (username !=
NULL)
2056 username_c = _dbus_string_get_const_data (username);
2065 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
2071 struct passwd p_str;
2074 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
2080 if ((
long) buflen <= 0)
2094 #ifdef HAVE_POSIX_GETPWNAM_R
2096 result = getpwuid_r (uid, &p_str, buf, buflen,
2099 result = getpwnam_r (username_c, &p_str, buf, buflen,
2103 p = getpwuid_r (uid, &p_str, buf, buflen);
2105 p = getpwnam_r (username_c, &p_str, buf, buflen);
2109 if (result == ERANGE && buflen < 512 * 1024)
2119 if (result == 0 && p == &p_str)
2121 if (!fill_user_info_from_passwd (p, info, error))
2131 "User \"%s\" unknown or no memory to allocate password entry\n",
2132 username_c ? username_c :
"???");
2133 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2146 p = getpwnam (username_c);
2150 if (!fill_user_info_from_passwd (p, info, error))
2158 "User \"%s\" unknown or no memory to allocate password entry\n",
2159 username_c ? username_c :
"???");
2160 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2169 #ifdef HAVE_GETGROUPLIST
2174 int initial_buf_count;
2176 initial_buf_count = 17;
2177 buf_count = initial_buf_count;
2185 if (getgrouplist (username_c,
2187 buf, &buf_count) < 0)
2203 if (buf_count == initial_buf_count)
2218 if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
2222 _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2223 username_c, buf_count, buf_count);
2229 "Failed to get groups for username \"%s\" primary GID "
2232 _dbus_strerror (errno));
2247 for (i = 0; i < buf_count; ++i)
2270 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2275 _DBUS_ASSERT_ERROR_IS_SET (error);
2309 return fill_user_info (info, uid,
2411 if (_dbus_string_get_length (uid_str) == 0)
2413 _dbus_verbose (
"UID string was zero length\n");
2422 _dbus_verbose (
"could not parse string as a UID\n");
2426 if (end != _dbus_string_get_length (uid_str))
2428 _dbus_verbose (
"string contained trailing stuff after UID\n");
2443 static pthread_mutex_t atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
2456 return __sync_add_and_fetch(&atomic->
value, 1)-1;
2460 pthread_mutex_lock (&atomic_mutex);
2461 res = atomic->
value;
2463 pthread_mutex_unlock (&atomic_mutex);
2479 return __sync_sub_and_fetch(&atomic->
value, 1)+1;
2483 pthread_mutex_lock (&atomic_mutex);
2484 res = atomic->
value;
2486 pthread_mutex_unlock (&atomic_mutex);
2503 __sync_synchronize ();
2504 return atomic->
value;
2508 pthread_mutex_lock (&atomic_mutex);
2509 res = atomic->
value;
2510 pthread_mutex_unlock (&atomic_mutex);
2527 int timeout_milliseconds)
2529 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
2540 sizeof (
DBusPollFD) ==
sizeof (
struct pollfd) &&
2542 _DBUS_STRUCT_OFFSET (
struct pollfd, fd) &&
2544 _DBUS_STRUCT_OFFSET (
struct pollfd, events) &&
2546 _DBUS_STRUCT_OFFSET (
struct pollfd, revents))
2548 return poll ((
struct pollfd*) fds,
2550 timeout_milliseconds);
2557 _dbus_warn (
"didn't implement poll() properly for this system yet\n");
2562 fd_set read_set, write_set, err_set;
2568 FD_ZERO (&read_set);
2569 FD_ZERO (&write_set);
2572 for (i = 0; i < n_fds; i++)
2577 FD_SET (fdp->
fd, &read_set);
2580 FD_SET (fdp->
fd, &write_set);
2582 FD_SET (fdp->
fd, &err_set);
2584 max_fd = MAX (max_fd, fdp->
fd);
2587 tv.tv_sec = timeout_milliseconds / 1000;
2588 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
2590 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
2591 timeout_milliseconds < 0 ?
NULL : &tv);
2595 for (i = 0; i < n_fds; i++)
2601 if (FD_ISSET (fdp->
fd, &read_set))
2604 if (FD_ISSET (fdp->
fd, &write_set))
2607 if (FD_ISSET (fdp->
fd, &err_set))
2627 #ifdef HAVE_MONOTONIC_CLOCK
2629 clock_gettime (CLOCK_MONOTONIC, &ts);
2632 *tv_sec = ts.tv_sec;
2634 *tv_usec = ts.tv_nsec / 1000;
2638 gettimeofday (&t,
NULL);
2643 *tv_usec = t.tv_usec;
2660 gettimeofday (&t,
NULL);
2665 *tv_usec = t.tv_usec;
2680 const char *filename_c;
2682 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2684 filename_c = _dbus_string_get_const_data (filename);
2686 if (mkdir (filename_c, 0700) < 0)
2688 if (errno == EEXIST)
2692 "Failed to create directory %s: %s\n",
2693 filename_c, _dbus_strerror (errno));
2717 if (_dbus_string_get_length (dir) == 0 ||
2718 _dbus_string_get_length (next_component) == 0)
2721 dir_ends_in_slash =
'/' == _dbus_string_get_byte (dir,
2722 _dbus_string_get_length (dir) - 1);
2724 file_starts_with_slash =
'/' == _dbus_string_get_byte (next_component, 0);
2726 if (dir_ends_in_slash && file_starts_with_slash)
2730 else if (!(dir_ends_in_slash || file_starts_with_slash))
2737 _dbus_string_get_length (dir));
2741 #define NANOSECONDS_PER_SECOND 1000000000
2743 #define MICROSECONDS_PER_SECOND 1000000
2745 #define MILLISECONDS_PER_SECOND 1000
2747 #define NANOSECONDS_PER_MILLISECOND 1000000
2749 #define MICROSECONDS_PER_MILLISECOND 1000
2758 #ifdef HAVE_NANOSLEEP
2759 struct timespec req;
2760 struct timespec rem;
2762 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
2763 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
2767 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
2769 #elif defined (HAVE_USLEEP)
2770 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
2772 sleep (MAX (milliseconds / 1000, 1));
2777 _dbus_generate_pseudorandom_bytes (
DBusString *str,
2783 old_len = _dbus_string_get_length (str);
2816 old_len = _dbus_string_get_length (str);
2820 fd = open (
"/dev/urandom", O_RDONLY);
2822 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2824 _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
2826 if (
_dbus_read (fd, str, n_bytes) != n_bytes)
2830 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2833 _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
2861 _dbus_strerror (
int error_number)
2865 msg = strerror (error_number);
2878 signal (SIGPIPE, SIG_IGN);
2893 val = fcntl (fd, F_GETFD, 0);
2900 fcntl (fd, F_SETFD, val);
2914 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2923 "Could not close fd %d", fd);
2944 #ifdef F_DUPFD_CLOEXEC
2947 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2948 cloexec_done = new_fd >= 0;
2950 if (new_fd < 0 && errno == EINVAL)
2953 new_fd = fcntl(fd, F_DUPFD, 3);
2959 "Could not duplicate fd %d", fd);
2963 #ifdef F_DUPFD_CLOEXEC
2981 _dbus_set_fd_nonblocking (
int fd,
2986 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2988 val = fcntl (fd, F_GETFL, 0);
2992 "Failed to get flags from file descriptor %d: %s",
2993 fd, _dbus_strerror (errno));
2994 _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
2995 _dbus_strerror (errno));
2999 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
3002 "Failed to set nonblocking flag of file descriptor %d: %s",
3003 fd, _dbus_strerror (errno));
3004 _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
3005 fd, _dbus_strerror (errno));
3021 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
3027 bt_size = backtrace (bt, 500);
3029 syms = backtrace_symbols (bt, bt_size);
3035 fprintf (stderr,
" %s\n", syms[i]);
3041 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
3042 fprintf (stderr,
" D-Bus not built with -rdynamic so unable to print a backtrace\n");
3044 fprintf (stderr,
" D-Bus not compiled with backtrace support so unable to print a backtrace\n");
3066 #ifdef HAVE_SOCKETPAIR
3073 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
3074 cloexec_done = retval >= 0;
3076 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
3079 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
3085 "Could not create full-duplex pipe");
3089 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3100 (!_dbus_set_fd_nonblocking (fds[0],
NULL) ||
3101 !_dbus_set_fd_nonblocking (fds[1],
NULL)))
3104 "Could not set full-duplex pipe nonblocking");
3115 _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
3120 _dbus_warn (
"_dbus_full_duplex_pipe() not implemented on this OS\n");
3122 "_dbus_full_duplex_pipe() not implemented on this OS");
3139 char static_buf[1024];
3140 int bufsize =
sizeof (static_buf);
3144 DBUS_VA_COPY (args_copy, args);
3145 len = vsnprintf (static_buf, bufsize, format, args_copy);
3162 DBUS_VA_COPY (args_copy, args);
3164 if (vsnprintf (static_buf, 1, format, args_copy) == 1)
3183 DBUS_VA_COPY (args_copy, args);
3184 len = vsnprintf (buf, bufsize, format, args_copy);
3209 static const char* tmpdir =
NULL;
3221 tmpdir = getenv(
"TMPDIR");
3227 tmpdir = getenv(
"TMP");
3229 tmpdir = getenv(
"TEMP");
3243 #if defined(DBUS_ENABLE_X11_AUTOLAUNCH) || defined(DBUS_ENABLE_LAUNCHD)
3264 _read_subprocess_line_argv (
const char *progpath,
3270 int result_pipe[2] = { -1, -1 };
3271 int errors_pipe[2] = { -1, -1 };
3278 sigset_t new_set, old_set;
3280 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3287 sigemptyset (&new_set);
3288 sigaddset (&new_set, SIGCHLD);
3289 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3291 orig_len = _dbus_string_get_length (result);
3295 if (pipe (result_pipe) < 0)
3298 "Failed to create a pipe to call %s: %s",
3299 progpath, _dbus_strerror (errno));
3300 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3301 progpath, _dbus_strerror (errno));
3304 if (pipe (errors_pipe) < 0)
3307 "Failed to create a pipe to call %s: %s",
3308 progpath, _dbus_strerror (errno));
3309 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3310 progpath, _dbus_strerror (errno));
3318 "Failed to fork() to call %s: %s",
3319 progpath, _dbus_strerror (errno));
3320 _dbus_verbose (
"Failed to fork() to call %s: %s\n",
3321 progpath, _dbus_strerror (errno));
3330 fd = open (
"/dev/null", O_RDWR);
3335 _dbus_verbose (
"/dev/null fd %d opened\n", fd);
3341 if (dup2 (fd, 0) == -1)
3343 if (dup2 (result_pipe[
WRITE_END], 1) == -1)
3345 if (dup2 (errors_pipe[WRITE_END], 2) == -1)
3350 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3353 if (progpath[0] ==
'/')
3355 execv (progpath, argv);
3364 execvp (strrchr (progpath,
'/')+1, argv);
3367 execvp (progpath, argv);
3374 close (result_pipe[WRITE_END]);
3375 close (errors_pipe[WRITE_END]);
3389 ret = waitpid (pid, &status, 0);
3391 while (ret == -1 && errno == EINTR);
3395 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
3401 _DBUS_SET_OOM (error);
3413 if (_dbus_string_get_length (&error_message) > 0)
3415 "%s terminated abnormally with the following error: %s",
3416 progpath, _dbus_string_get_data (&error_message));
3419 "%s terminated abnormally without any error message",
3427 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3430 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3432 _DBUS_ASSERT_ERROR_IS_SET (error);
3434 if (result_pipe[0] != -1)
3435 close (result_pipe[0]);
3436 if (result_pipe[1] != -1)
3437 close (result_pipe[1]);
3438 if (errors_pipe[0] != -1)
3439 close (errors_pipe[0]);
3440 if (errors_pipe[1] != -1)
3441 close (errors_pipe[1]);
3464 #ifdef DBUS_ENABLE_X11_AUTOLAUNCH
3468 const char *display;
3477 "Unable to autolaunch when setuid");
3481 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3489 if (display ==
NULL || display[0] ==
'\0')
3492 "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
3498 _DBUS_SET_OOM (error);
3504 _DBUS_SET_OOM (error);
3509 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
3511 argv[i] = TEST_BUS_LAUNCH_BINARY;
3514 argv[i] = DBUS_BINDIR
"/dbus-launch";
3516 argv[i] =
"--autolaunch";
3518 argv[i] = _dbus_string_get_data (&uuid);
3520 argv[i] =
"--binary-syntax";
3522 argv[i] =
"--close-stderr";
3529 retval = _read_subprocess_line_argv (argv[0],
3531 argv, address, error);
3538 "Using X11 for dbus-daemon autolaunch was disabled at compile time, "
3539 "set your DBUS_SESSION_BUS_ADDRESS instead");
3592 const char *launchd_env_var,
3595 #ifdef DBUS_ENABLE_LAUNCHD
3599 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3604 "Unable to find launchd socket when setuid");
3609 argv[i] =
"launchctl";
3613 argv[i] = (
char*)launchd_env_var;
3620 if (!_read_subprocess_line_argv(argv[0],
TRUE, argv, socket_path, error))
3626 if (_dbus_string_get_length(socket_path) == 0)
3636 "can't lookup socket from launchd; launchd support not compiled in");
3641 #ifdef DBUS_ENABLE_LAUNCHD
3651 "Unable to find launchd socket when setuid");
3657 _DBUS_SET_OOM (error);
3672 "launchd did not provide a socket path, "
3673 "verify that org.freedesktop.dbus-session.plist is loaded!");
3679 _DBUS_SET_OOM (error);
3684 _dbus_string_get_length (address)))
3686 _DBUS_SET_OOM (error);
3720 #ifdef DBUS_ENABLE_LAUNCHD
3722 return _dbus_lookup_session_address_launchd (address, error);
3779 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
3781 const char *
override;
3784 if (
override !=
NULL && *
override !=
'\0')
3790 _dbus_verbose (
"Using fake homedir for testing: %s\n",
3791 _dbus_string_get_const_data (&homedir));
3798 if (!already_warned)
3800 _dbus_warn (
"Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid\n");
3801 already_warned =
TRUE;
3813 directory, _dbus_string_get_length (directory))) {
3827 _dbus_daemon_publish_session_bus_address (
const char* addr,
3835 _dbus_daemon_unpublish_session_bus_address (
void)
3849 return errno == EAGAIN || errno == EWOULDBLOCK;
3863 const char *filename_c;
3865 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3867 filename_c = _dbus_string_get_const_data (filename);
3869 if (rmdir (filename_c) != 0)
3872 "Failed to remove directory %s: %s\n",
3873 filename_c, _dbus_strerror (errno));
3893 struct sockaddr_storage storage;
3894 struct sockaddr_un un;
3897 socklen_t sa_len =
sizeof(sa_buf);
3901 if (getsockname(fd, &sa_buf.sa, &sa_len) < 0)
3904 return sa_buf.sa.sa_family == AF_UNIX;
3927 d = opendir (
"/proc/self/fd");
3937 k = readdir_r (d, &buf, &de);
3941 if (de->d_name[0] ==
'.')
3945 l = strtol (de->d_name, &e, 10);
3946 if (errno != 0 || e ==
NULL || *e !=
'\0')
3953 if (fd == dirfd (d))
3964 maxfds = sysconf (_SC_OPEN_MAX);
3973 for (i = 3; i < maxfds; i++)
3992 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE)
3995 extern int __libc_enable_secure;
3996 return __libc_enable_secure;
3998 #elif defined(HAVE_ISSETUGID)
4000 return issetugid ();
4002 uid_t ruid, euid, suid;
4003 gid_t rgid, egid, sgid;
4010 if (_DBUS_UNLIKELY (!check_setuid_initialised))
4012 #ifdef HAVE_GETRESUID
4013 if (getresuid (&ruid, &euid, &suid) != 0 ||
4014 getresgid (&rgid, &egid, &sgid) != 0)
4017 suid = ruid = getuid ();
4018 sgid = rgid = getgid ();
4023 check_setuid_initialised =
TRUE;
4024 is_setuid = (ruid != euid || ruid != suid ||
4025 rgid != egid || rgid != sgid);
4046 struct sockaddr_storage storage;
4047 struct sockaddr_un un;
4048 struct sockaddr_in ipv4;
4049 struct sockaddr_in6 ipv6;
4051 char hostip[INET6_ADDRSTRLEN];
4052 int size =
sizeof (socket);
4054 if (getsockname (fd, &socket.sa, &size))
4057 switch (socket.sa.sa_family)
4060 if (socket.un.sun_path[0]==
'\0')
4072 if (inet_ntop (AF_INET, &socket.ipv4.sin_addr, hostip, sizeof (hostip)))
4074 hostip, ntohs (socket.ipv4.sin_port)))
4079 if (inet_ntop (AF_INET6, &socket.ipv6.sin6_addr, hostip, sizeof (hostip)))
4081 hostip, ntohs (socket.ipv6.sin6_port)))
4088 "Failed to read address from socket: Unknown socket type.");
4094 "Failed to open socket: %s",
4095 _dbus_strerror (errno));