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>
77 #ifdef HAVE_GETPEERUCRED
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
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
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 if (m.msg_flags & MSG_CTRUNC)
450 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
451 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
454 int *payload = (
int *) CMSG_DATA (cm);
455 size_t payload_len_bytes = (cm->cmsg_len - CMSG_LEN (0));
456 size_t payload_len_fds = payload_len_bytes /
sizeof (int);
461 _DBUS_STATIC_ASSERT (
sizeof (
size_t) >=
sizeof (
unsigned int));
463 if (_DBUS_LIKELY (payload_len_fds <= (
size_t) *n_fds))
466 fds_to_use = payload_len_fds;
474 fds_to_use = (size_t) *n_fds;
479 for (i = fds_to_use; i < payload_len_fds; i++)
485 memcpy (fds, payload, fds_to_use *
sizeof (
int));
490 *n_fds = (
unsigned int) fds_to_use;
495 for (i = 0; i < fds_to_use; i++)
518 _dbus_write_socket_with_unix_fds(
DBusSocket fd,
525 #ifndef HAVE_UNIX_FD_PASSING
534 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len,
NULL, 0, 0, fds, n_fds);
539 _dbus_write_socket_with_unix_fds_two(
DBusSocket fd,
549 #ifndef HAVE_UNIX_FD_PASSING
557 buffer1, start1, len1,
558 buffer2, start2, len2);
572 iov[0].iov_len = len1;
577 iov[1].iov_len = len2;
582 m.msg_iovlen = buffer2 ? 2 : 1;
586 m.msg_controllen = CMSG_SPACE(n_fds *
sizeof(
int));
587 m.msg_control = alloca(m.msg_controllen);
588 memset(m.msg_control, 0, m.msg_controllen);
590 cm = CMSG_FIRSTHDR(&m);
591 cm->cmsg_level = SOL_SOCKET;
592 cm->cmsg_type = SCM_RIGHTS;
593 cm->cmsg_len = CMSG_LEN(n_fds *
sizeof(
int));
594 memcpy(CMSG_DATA(cm), fds, n_fds *
sizeof(
int));
599 bytes_written = sendmsg (fd.fd, &m, 0
600 #
if HAVE_DECL_MSG_NOSIGNAL
605 if (bytes_written < 0 && errno == EINTR)
609 if (bytes_written > 0)
613 return bytes_written;
639 #if HAVE_DECL_MSG_NOSIGNAL
640 struct iovec vectors[2];
663 vectors[0].iov_base = (
char*) data1;
664 vectors[0].iov_len = len1;
665 vectors[1].iov_base = (
char*) data2;
666 vectors[1].iov_len = len2;
670 m.msg_iovlen = data2 ? 2 : 1;
674 bytes_written = sendmsg (fd.fd, &m, MSG_NOSIGNAL);
676 if (bytes_written < 0 && errno == EINTR)
679 return bytes_written;
683 buffer2, start2, len2);
726 bytes_read = read (fd, data, count);
776 bytes_written = write (fd, data, len);
778 if (bytes_written < 0 && errno == EINTR)
782 if (bytes_written > 0)
786 return bytes_written;
826 struct iovec vectors[2];
842 vectors[0].iov_base = (
char*) data1;
843 vectors[0].iov_len = len1;
844 vectors[1].iov_base = (
char*) data2;
845 vectors[1].iov_len = len2;
849 bytes_written = writev (fd,
853 if (bytes_written < 0 && errno == EINTR)
856 return bytes_written;
863 if (ret1 == len1 && buffer2 !=
NULL)
877 #define _DBUS_MAX_SUN_PATH_LENGTH 99
915 struct sockaddr_un addr;
916 _DBUS_STATIC_ASSERT (
sizeof (addr.sun_path) > _DBUS_MAX_SUN_PATH_LENGTH);
918 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
920 _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
924 if (!_dbus_open_unix_socket (&fd, error))
926 _DBUS_ASSERT_ERROR_IS_SET(error);
929 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
932 addr.sun_family = AF_UNIX;
933 path_len = strlen (path);
938 addr.sun_path[0] =
'\0';
941 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
944 "Abstract socket name too long\n");
949 strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
953 "Operating system does not support abstract socket namespace\n");
960 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
963 "Socket name too long\n");
968 strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
971 if (connect (fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
975 "Failed to connect to socket %s: %s",
976 path, _dbus_strerror (errno));
982 if (!_dbus_set_fd_nonblocking (fd, error))
984 _DBUS_ASSERT_ERROR_IS_SET (error);
1015 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1017 _dbus_verbose (
"connecting to process %s\n", path);
1020 retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
1021 cloexec_done = (retval >= 0);
1023 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
1026 retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
1033 "Failed to create socket pair: %s",
1034 _dbus_strerror (errno));
1049 "Failed to fork() to call %s: %s",
1050 path, _dbus_strerror (errno));
1061 dup2 (fds[1], STDIN_FILENO);
1062 dup2 (fds[1], STDOUT_FILENO);
1064 if (fds[1] != STDIN_FILENO &&
1065 fds[1] != STDOUT_FILENO)
1073 execvp (path, (
char *
const *) argv);
1075 fprintf (stderr,
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
1083 if (!_dbus_set_fd_nonblocking (fds[0], error))
1085 _DBUS_ASSERT_ERROR_IS_SET (error);
1117 struct sockaddr_un addr;
1119 _DBUS_STATIC_ASSERT (
sizeof (addr.sun_path) > _DBUS_MAX_SUN_PATH_LENGTH);
1121 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1123 _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
1126 if (!_dbus_open_unix_socket (&listen_fd, error))
1128 _DBUS_ASSERT_ERROR_IS_SET(error);
1131 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1134 addr.sun_family = AF_UNIX;
1135 path_len = strlen (path);
1143 addr.sun_path[0] =
'\0';
1146 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1149 "Abstract socket name too long\n");
1154 strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
1158 "Operating system does not support abstract socket namespace\n");
1178 if (stat (path, &sb) == 0 &&
1179 S_ISSOCK (sb.st_mode))
1183 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1186 "Socket name too long\n");
1191 strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
1194 if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1197 "Failed to bind socket \"%s\": %s",
1198 path, _dbus_strerror (errno));
1203 if (listen (listen_fd, SOMAXCONN ) < 0)
1206 "Failed to listen on socket \"%s\": %s",
1207 path, _dbus_strerror (errno));
1212 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1214 _DBUS_ASSERT_ERROR_IS_SET (error);
1222 if (!
abstract && chmod (path, 0777) < 0)
1223 _dbus_warn (
"Could not set mode 0777 on socket %s", path);
1247 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1249 n = sd_listen_fds (
TRUE);
1253 "Failed to acquire systemd socket: %s",
1254 _dbus_strerror (-n));
1261 "No socket received.");
1265 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1267 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1271 "Failed to verify systemd socket type: %s",
1272 _dbus_strerror (-r));
1279 "Passed socket has wrong type.");
1291 "Failed to allocate file handle array.");
1295 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1297 if (!_dbus_set_fd_nonblocking (fd, error))
1299 _DBUS_ASSERT_ERROR_IS_SET (error);
1303 new_fds[fd - SD_LISTEN_FDS_START].fd = fd;
1311 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1320 "dbus was compiled without systemd support");
1328 _dbus_error_from_gai (
int gai_res,
1394 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
1398 _dbus_connect_tcp_socket_with_nonce (
const char *host,
1401 const char *noncefile,
1404 int saved_errno = 0;
1407 struct addrinfo hints;
1408 struct addrinfo *ai, *tmp;
1410 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1415 hints.ai_family = AF_UNSPEC;
1416 else if (!strcmp(family,
"ipv4"))
1417 hints.ai_family = AF_INET;
1418 else if (!strcmp(family,
"ipv6"))
1419 hints.ai_family = AF_INET6;
1424 "Unknown address family %s", family);
1425 return _dbus_socket_get_invalid ();
1427 hints.ai_protocol = IPPROTO_TCP;
1428 hints.ai_socktype = SOCK_STREAM;
1429 hints.ai_flags = AI_ADDRCONFIG;
1431 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1434 _dbus_error_from_gai (res, errno),
1435 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1436 host, port, gai_strerror(res), res);
1437 return _dbus_socket_get_invalid ();
1443 if (!_dbus_open_socket (&fd.fd, tmp->ai_family, SOCK_STREAM, 0, error))
1446 _DBUS_ASSERT_ERROR_IS_SET(error);
1447 return _dbus_socket_get_invalid ();
1449 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1451 if (connect (fd.fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1453 saved_errno = errno;
1468 "Failed to connect to socket \"%s:%s\" %s",
1469 host, port, _dbus_strerror(saved_errno));
1470 return _dbus_socket_get_invalid ();
1473 if (noncefile !=
NULL)
1478 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1484 return _dbus_socket_get_invalid ();
1488 if (!_dbus_set_fd_nonblocking (fd.fd, error))
1491 return _dbus_socket_get_invalid ();
1522 int nlisten_fd = 0, res, i;
1524 struct addrinfo hints;
1525 struct addrinfo *ai, *tmp;
1526 unsigned int reuseaddr;
1529 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1534 hints.ai_family = AF_UNSPEC;
1535 else if (!strcmp(family,
"ipv4"))
1536 hints.ai_family = AF_INET;
1537 else if (!strcmp(family,
"ipv6"))
1538 hints.ai_family = AF_INET6;
1543 "Unknown address family %s", family);
1547 hints.ai_protocol = IPPROTO_TCP;
1548 hints.ai_socktype = SOCK_STREAM;
1549 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1551 redo_lookup_with_port:
1553 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1556 _dbus_error_from_gai (res, errno),
1557 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1558 host ? host :
"*", port, gai_strerror(res), res);
1565 int fd = -1, tcp_nodelay_on;
1568 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1570 _DBUS_ASSERT_ERROR_IS_SET(error);
1573 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1576 if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1578 _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
1579 host ? host :
"*", port, _dbus_strerror (errno));
1585 if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay_on,
sizeof (tcp_nodelay_on)) == -1)
1587 _dbus_warn (
"Failed to set TCP_NODELAY socket option \"%s:%s\": %s",
1588 host ? host :
"*", port, _dbus_strerror (errno));
1591 if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1593 saved_errno = errno;
1595 if (saved_errno == EADDRINUSE)
1613 "Failed to bind socket \"%s:%s\": %s",
1614 host ? host :
"*", port, _dbus_strerror (saved_errno));
1618 if (listen (fd, 30 ) < 0)
1620 saved_errno = errno;
1623 "Failed to listen on socket \"%s:%s\": %s",
1624 host ? host :
"*", port, _dbus_strerror (saved_errno));
1633 "Failed to allocate file handle array");
1636 listen_fd = newlisten_fd;
1637 listen_fd[nlisten_fd].fd = fd;
1646 if (!port || !strcmp(port,
"0"))
1649 struct sockaddr_storage addr;
1653 addrlen =
sizeof(addr);
1654 result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
1658 saved_errno = errno;
1660 "Failed to retrieve socket name for \"%s:%s\": %s",
1661 host ? host :
"*", port, _dbus_strerror (saved_errno));
1665 if ((res = getnameinfo ((
struct sockaddr*)&addr, addrlen,
NULL, 0,
1666 portbuf,
sizeof(portbuf),
1667 NI_NUMERICHOST | NI_NUMERICSERV)) != 0)
1669 saved_errno = errno;
1671 "Failed to resolve port \"%s:%s\": %s (%d)",
1672 host ? host :
"*", port, gai_strerror(res), res);
1685 goto redo_lookup_with_port;
1706 "Failed to bind socket \"%s:%s\": %s",
1707 host ? host :
"*", port, _dbus_strerror (errno));
1711 for (i = 0 ; i < nlisten_fd ; i++)
1713 if (!_dbus_set_fd_nonblocking (listen_fd[i].fd, error))
1726 for (i = 0 ; i < nlisten_fd ; i++)
1733 write_credentials_byte (
int server_fd,
1737 char buf[1] = {
'\0' };
1738 #if defined(HAVE_CMSGCRED)
1741 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1752 msg.msg_control = (caddr_t) &cmsg;
1753 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1755 cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
1756 cmsg.hdr.cmsg_level = SOL_SOCKET;
1757 cmsg.hdr.cmsg_type = SCM_CREDS;
1760 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1764 #if defined(HAVE_CMSGCRED)
1765 bytes_written = sendmsg (server_fd, &msg, 0
1766 #
if HAVE_DECL_MSG_NOSIGNAL
1774 if (bytes_written < 0 && errno == EINVAL)
1777 bytes_written = send (server_fd, buf, 1, 0
1778 #
if HAVE_DECL_MSG_NOSIGNAL
1784 if (bytes_written < 0 && errno == EINTR)
1787 if (bytes_written < 0)
1790 "Failed to write credentials byte: %s",
1791 _dbus_strerror (errno));
1794 else if (bytes_written == 0)
1797 "wrote zero bytes writing credentials byte");
1803 _dbus_verbose (
"wrote credentials byte\n");
1810 add_linux_security_label_to_credentials (
int client_fd,
1813 #if defined(__linux__) && defined(SO_PEERSEC)
1815 socklen_t len = 1024;
1822 while (getsockopt (client_fd, SOL_SOCKET, SO_PEERSEC,
1827 _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
1828 _dbus_strerror (e), (
unsigned long) len);
1830 if (e != ERANGE || len <= _dbus_string_get_length_uint (&buf))
1832 _dbus_verbose (
"Failed to getsockopt(SO_PEERSEC): %s\n",
1833 _dbus_strerror (e));
1845 _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
1850 _dbus_verbose (
"getsockopt(SO_PEERSEC) yielded <= 0 bytes: %lu\n",
1851 (
unsigned long) len);
1855 if (len > _dbus_string_get_length_uint (&buf))
1857 _dbus_verbose (
"%lu > %u", (
unsigned long) len,
1858 _dbus_string_get_length_uint (&buf));
1866 _dbus_verbose (
"subtracting trailing \\0\n");
1882 _dbus_verbose (
"security label from kernel had an embedded \\0, "
1887 _dbus_verbose (
"getsockopt(SO_PEERSEC): %lu bytes excluding \\0: %s\n",
1888 (
unsigned long) len,
1959 #ifdef HAVE_CMSGCRED
1962 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1970 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
1971 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
1972 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
1977 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1981 iov.iov_base = &buf;
1988 #if defined(HAVE_CMSGCRED)
1990 msg.msg_control = (caddr_t) &cmsg;
1991 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1995 bytes_read = recvmsg (client_fd.fd, &msg, 0);
2008 "Failed to read credentials byte: %s",
2009 _dbus_strerror (errno));
2012 else if (bytes_read == 0)
2018 "Failed to read credentials byte (zero-length read)");
2021 else if (buf !=
'\0')
2024 "Credentials byte was not nul");
2028 _dbus_verbose (
"read credentials byte\n");
2041 struct sockpeercred cr;
2045 socklen_t cr_len =
sizeof (cr);
2047 if (getsockopt (client_fd.fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) != 0)
2049 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED): %s\n",
2050 _dbus_strerror (errno));
2052 else if (cr_len !=
sizeof (cr))
2054 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED), returned %d bytes, expected %d\n",
2055 cr_len, (
int)
sizeof (cr));
2062 #elif defined(HAVE_UNPCBID) && defined(LOCAL_PEEREID)
2066 socklen_t cr_len =
sizeof (cr);
2068 if (getsockopt (client_fd.fd, 0, LOCAL_PEEREID, &cr, &cr_len) != 0)
2070 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID): %s\n",
2071 _dbus_strerror (errno));
2073 else if (cr_len !=
sizeof (cr))
2075 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID), returned %d bytes, expected %d\n",
2076 cr_len, (
int)
sizeof (cr));
2080 pid_read = cr.unp_pid;
2081 uid_read = cr.unp_euid;
2083 #elif defined(HAVE_CMSGCRED)
2092 struct cmsgcred *cred;
2093 struct cmsghdr *cmsgp;
2095 for (cmsgp = CMSG_FIRSTHDR (&msg);
2097 cmsgp = CMSG_NXTHDR (&msg, cmsgp))
2099 if (cmsgp->cmsg_type == SCM_CREDS &&
2100 cmsgp->cmsg_level == SOL_SOCKET &&
2101 cmsgp->cmsg_len >= CMSG_LEN (
sizeof (
struct cmsgcred)))
2103 cred = (
struct cmsgcred *) CMSG_DATA (cmsgp);
2104 pid_read = cred->cmcred_pid;
2105 uid_read = cred->cmcred_euid;
2110 #elif defined(HAVE_GETPEERUCRED)
2114 ucred_t * ucred =
NULL;
2115 if (getpeerucred (client_fd.fd, &ucred) == 0)
2118 adt_session_data_t *adth =
NULL;
2120 pid_read = ucred_getpid (ucred);
2121 uid_read = ucred_geteuid (ucred);
2124 if (adt_start_session (&adth,
NULL, 0) || (adth ==
NULL))
2126 _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
2130 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
2132 _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
2136 adt_export_data_t *data =
NULL;
2137 size_t size = adt_export_session_data (adth, &data);
2140 _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
2148 (void) adt_end_session (adth);
2154 _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
2164 #elif defined(HAVE_GETPEEREID)
2182 if (getpeereid (client_fd.fd, &euid, &egid) == 0)
2188 _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
2192 #warning Socket credentials not supported on this Unix OS
2193 #warning Please tell https://bugs.freedesktop.org/enter_bug.cgi?product=DBus
2199 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
2200 defined(__linux__) || \
2201 defined(__OpenBSD__) || \
2203 # error Credentials passing not working on this OS is a regression!
2206 _dbus_verbose (
"Socket credentials not supported on this OS\n");
2210 _dbus_verbose (
"Credentials:"
2221 _DBUS_SET_OOM (error);
2230 _DBUS_SET_OOM (error);
2235 if (!add_linux_security_label_to_credentials (client_fd.fd, credentials))
2237 _DBUS_SET_OOM (error);
2265 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2267 if (write_credentials_byte (server_fd.fd, error))
2286 struct sockaddr addr;
2292 addrlen =
sizeof (addr);
2302 client_fd.fd = accept4 (listen_fd.fd, &addr, &addrlen, SOCK_CLOEXEC);
2303 cloexec_done = client_fd.fd >= 0;
2305 if (client_fd.fd < 0 && (errno == ENOSYS || errno == EINVAL))
2308 client_fd.fd = accept (listen_fd.fd, &addr, &addrlen);
2311 if (client_fd.fd < 0)
2317 _dbus_verbose (
"client fd %d accepted\n", client_fd.fd);
2340 const char *directory;
2343 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2347 if (stat (directory, &sb) < 0)
2350 "%s", _dbus_strerror (errno));
2355 if (sb.st_uid != geteuid ())
2358 "%s directory is owned by user %lu, not %lu",
2360 (
unsigned long) sb.st_uid,
2361 (
unsigned long) geteuid ());
2365 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
2366 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
2369 "%s directory is not private to the user", directory);
2377 fill_user_info_from_passwd (
struct passwd *p,
2384 info->
uid = p->pw_uid;
2405 const char *username_c;
2418 if (username !=
NULL)
2428 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
2434 struct passwd p_str;
2437 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
2443 if ((
long) buflen <= 0)
2457 #ifdef HAVE_POSIX_GETPWNAM_R
2459 result = getpwuid_r (uid, &p_str, buf, buflen,
2462 result = getpwnam_r (username_c, &p_str, buf, buflen,
2466 p = getpwuid_r (uid, &p_str, buf, buflen);
2468 p = getpwnam_r (username_c, &p_str, buf, buflen);
2472 if (result == ERANGE && buflen < 512 * 1024)
2482 if (result == 0 && p == &p_str)
2484 if (!fill_user_info_from_passwd (p, info, error))
2494 "User \"%s\" unknown or no memory to allocate password entry\n",
2495 username_c ? username_c :
"???");
2496 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2509 p = getpwnam (username_c);
2513 if (!fill_user_info_from_passwd (p, info, error))
2521 "User \"%s\" unknown or no memory to allocate password entry\n",
2522 username_c ? username_c :
"???");
2523 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2532 #ifdef HAVE_GETGROUPLIST
2537 int initial_buf_count;
2539 initial_buf_count = 17;
2540 buf_count = initial_buf_count;
2548 if (getgrouplist (username_c,
2550 buf, &buf_count) < 0)
2566 if (buf_count == initial_buf_count)
2581 if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
2585 _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2586 username_c, buf_count, buf_count);
2592 "Failed to get groups for username \"%s\" primary GID "
2595 _dbus_strerror (errno));
2610 for (i = 0; i < buf_count; ++i)
2633 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2638 _DBUS_ASSERT_ERROR_IS_SET (error);
2672 return fill_user_info (info, uid,
2690 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
2691 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
2692 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
2776 _dbus_verbose (
"UID string was zero length\n");
2785 _dbus_verbose (
"could not parse string as a UID\n");
2791 _dbus_verbose (
"string contained trailing stuff after UID\n");
2806 static pthread_mutex_t atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
2819 return __sync_add_and_fetch(&atomic->
value, 1)-1;
2823 pthread_mutex_lock (&atomic_mutex);
2824 res = atomic->
value;
2826 pthread_mutex_unlock (&atomic_mutex);
2842 return __sync_sub_and_fetch(&atomic->
value, 1)+1;
2846 pthread_mutex_lock (&atomic_mutex);
2847 res = atomic->
value;
2849 pthread_mutex_unlock (&atomic_mutex);
2866 __sync_synchronize ();
2867 return atomic->
value;
2871 pthread_mutex_lock (&atomic_mutex);
2872 res = atomic->
value;
2873 pthread_mutex_unlock (&atomic_mutex);
2890 int timeout_milliseconds)
2892 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
2894 if (timeout_milliseconds < -1)
2896 timeout_milliseconds = -1;
2901 timeout_milliseconds);
2904 fd_set read_set, write_set, err_set;
2910 FD_ZERO (&read_set);
2911 FD_ZERO (&write_set);
2914 for (i = 0; i < n_fds; i++)
2919 FD_SET (fdp->
fd, &read_set);
2922 FD_SET (fdp->
fd, &write_set);
2924 FD_SET (fdp->
fd, &err_set);
2926 max_fd = MAX (max_fd, fdp->
fd);
2929 tv.tv_sec = timeout_milliseconds / 1000;
2930 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
2932 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
2933 timeout_milliseconds < 0 ?
NULL : &tv);
2937 for (i = 0; i < n_fds; i++)
2943 if (FD_ISSET (fdp->
fd, &read_set))
2946 if (FD_ISSET (fdp->
fd, &write_set))
2949 if (FD_ISSET (fdp->
fd, &err_set))
2969 #ifdef HAVE_MONOTONIC_CLOCK
2971 clock_gettime (CLOCK_MONOTONIC, &ts);
2974 *tv_sec = ts.tv_sec;
2976 *tv_usec = ts.tv_nsec / 1000;
2980 gettimeofday (&t,
NULL);
2985 *tv_usec = t.tv_usec;
3002 gettimeofday (&t,
NULL);
3007 *tv_usec = t.tv_usec;
3022 const char *filename_c;
3024 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3028 if (mkdir (filename_c, 0700) < 0)
3030 if (errno == EEXIST)
3034 "Failed to create directory %s: %s\n",
3035 filename_c, _dbus_strerror (errno));
3054 const char *filename_c;
3056 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3060 if (mkdir (filename_c, 0700) < 0)
3063 "Failed to create directory %s: %s\n",
3064 filename_c, _dbus_strerror (errno));
3097 if (dir_ends_in_slash && file_starts_with_slash)
3101 else if (!(dir_ends_in_slash || file_starts_with_slash))
3112 #define NANOSECONDS_PER_SECOND 1000000000
3114 #define MICROSECONDS_PER_SECOND 1000000
3116 #define MILLISECONDS_PER_SECOND 1000
3118 #define NANOSECONDS_PER_MILLISECOND 1000000
3120 #define MICROSECONDS_PER_MILLISECOND 1000
3129 #ifdef HAVE_NANOSLEEP
3130 struct timespec req;
3131 struct timespec rem;
3133 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
3134 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
3138 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
3140 #elif defined (HAVE_USLEEP)
3141 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
3143 sleep (MAX (milliseconds / 1000, 1));
3169 fd = open (
"/dev/urandom", O_RDONLY);
3174 "Could not open /dev/urandom: %s",
3175 _dbus_strerror (errno));
3179 _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
3183 if (result != n_bytes)
3187 "Could not read /dev/urandom: %s",
3188 _dbus_strerror (errno));
3191 "Short read from /dev/urandom");
3198 _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
3226 _dbus_strerror (
int error_number)
3230 msg = strerror (error_number);
3243 signal (SIGPIPE, SIG_IGN);
3258 val = fcntl (fd, F_GETFD, 0);
3265 fcntl (fd, F_SETFD, val);
3279 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3288 "Could not close fd %d", fd);
3309 #ifdef F_DUPFD_CLOEXEC
3312 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
3313 cloexec_done = new_fd >= 0;
3315 if (new_fd < 0 && errno == EINVAL)
3318 new_fd = fcntl(fd, F_DUPFD, 3);
3324 "Could not duplicate fd %d", fd);
3328 #ifdef F_DUPFD_CLOEXEC
3349 return _dbus_set_fd_nonblocking (fd.fd, error);
3353 _dbus_set_fd_nonblocking (
int fd,
3358 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3360 val = fcntl (fd, F_GETFL, 0);
3364 "Failed to get flags from file descriptor %d: %s",
3365 fd, _dbus_strerror (errno));
3366 _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
3367 _dbus_strerror (errno));
3371 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
3374 "Failed to set nonblocking flag of file descriptor %d: %s",
3375 fd, _dbus_strerror (errno));
3376 _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
3377 fd, _dbus_strerror (errno));
3393 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
3399 bt_size = backtrace (bt, 500);
3401 syms = backtrace_symbols (bt, bt_size);
3407 fprintf (stderr,
" %s\n", syms[i]);
3413 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
3414 fprintf (stderr,
" D-Bus not built with -rdynamic so unable to print a backtrace\n");
3416 fprintf (stderr,
" D-Bus not compiled with backtrace support so unable to print a backtrace\n");
3438 #ifdef HAVE_SOCKETPAIR
3445 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
3446 cloexec_done = retval >= 0;
3448 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
3451 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
3457 "Could not create full-duplex pipe");
3461 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3472 (!_dbus_set_fd_nonblocking (fds[0],
NULL) ||
3473 !_dbus_set_fd_nonblocking (fds[1],
NULL)))
3476 "Could not set full-duplex pipe nonblocking");
3487 _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
3492 _dbus_warn (
"_dbus_socketpair() not implemented on this OS");
3494 "_dbus_socketpair() not implemented on this OS");
3511 char static_buf[1024];
3512 int bufsize =
sizeof (static_buf);
3516 DBUS_VA_COPY (args_copy, args);
3517 len = vsnprintf (static_buf, bufsize, format, args_copy);
3534 DBUS_VA_COPY (args_copy, args);
3536 if (vsnprintf (static_buf, 1, format, args_copy) == 1)
3555 DBUS_VA_COPY (args_copy, args);
3556 len = vsnprintf (buf, bufsize, format, args_copy);
3581 static const char* tmpdir =
NULL;
3593 tmpdir = getenv(
"TMPDIR");
3599 tmpdir = getenv(
"TMP");
3601 tmpdir = getenv(
"TEMP");
3615 #if defined(DBUS_ENABLE_X11_AUTOLAUNCH) || defined(DBUS_ENABLE_LAUNCHD)
3636 _read_subprocess_line_argv (
const char *progpath,
3638 const char *
const *argv,
3642 int result_pipe[2] = { -1, -1 };
3643 int errors_pipe[2] = { -1, -1 };
3650 sigset_t new_set, old_set;
3652 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3659 sigemptyset (&new_set);
3660 sigaddset (&new_set, SIGCHLD);
3661 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3667 if (pipe (result_pipe) < 0)
3670 "Failed to create a pipe to call %s: %s",
3671 progpath, _dbus_strerror (errno));
3672 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3673 progpath, _dbus_strerror (errno));
3676 if (pipe (errors_pipe) < 0)
3679 "Failed to create a pipe to call %s: %s",
3680 progpath, _dbus_strerror (errno));
3681 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3682 progpath, _dbus_strerror (errno));
3690 "Failed to fork() to call %s: %s",
3691 progpath, _dbus_strerror (errno));
3692 _dbus_verbose (
"Failed to fork() to call %s: %s\n",
3693 progpath, _dbus_strerror (errno));
3700 const char *error_str;
3704 int saved_errno = errno;
3709 if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0 ||
3710 write (errors_pipe[WRITE_END],
": ", 2) < 0)
3715 error_str = _dbus_strerror (saved_errno);
3717 if (write (errors_pipe[WRITE_END], error_str, strlen (error_str)) < 0)
3729 if (dup2 (result_pipe[WRITE_END], 1) == -1)
3731 if (dup2 (errors_pipe[WRITE_END], 2) == -1)
3736 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3739 if (progpath[0] ==
'/')
3741 execv (progpath, (
char *
const *) argv);
3750 execvp (strrchr (progpath,
'/')+1, (
char *
const *) argv);
3753 execvp (progpath, (
char *
const *) argv);
3760 close (result_pipe[WRITE_END]);
3761 close (errors_pipe[WRITE_END]);
3775 ret = waitpid (pid, &status, 0);
3777 while (ret == -1 && errno == EINTR);
3781 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
3787 _DBUS_SET_OOM (error);
3801 "%s terminated abnormally with the following error: %s",
3805 "%s terminated abnormally without any error message",
3813 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3816 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3818 _DBUS_ASSERT_ERROR_IS_SET (error);
3820 if (result_pipe[0] != -1)
3821 close (result_pipe[0]);
3822 if (result_pipe[1] != -1)
3823 close (result_pipe[1]);
3824 if (errors_pipe[0] != -1)
3825 close (errors_pipe[0]);
3826 if (errors_pipe[1] != -1)
3827 close (errors_pipe[1]);
3850 #ifdef DBUS_ENABLE_X11_AUTOLAUNCH
3851 static const char arg_dbus_launch[] =
"dbus-launch";
3852 static const char arg_autolaunch[] =
"--autolaunch";
3853 static const char arg_binary_syntax[] =
"--binary-syntax";
3854 static const char arg_close_stderr[] =
"--close-stderr";
3859 const char *display;
3860 const char *progpath;
3861 const char *argv[6];
3869 "Unable to autolaunch when setuid");
3873 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3886 if (display ==
NULL || display[0] ==
'\0')
3889 "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
3895 _DBUS_SET_OOM (error);
3904 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
3907 if (progpath ==
NULL)
3909 progpath = DBUS_BINDIR
"/dbus-launch";
3916 argv[i] = arg_dbus_launch;
3918 argv[i] = arg_autolaunch;
3922 argv[i] = arg_binary_syntax;
3924 argv[i] = arg_close_stderr;
3931 retval = _read_subprocess_line_argv (progpath,
3933 argv, address, error);
3940 "Using X11 for dbus-daemon autolaunch was disabled at compile time, "
3941 "set your DBUS_SESSION_BUS_ADDRESS instead");
3986 if (create_if_not_found)
3998 if (!create_if_not_found)
4001 "D-Bus library appears to be incorrectly set up: "
4002 "see the manual page for dbus-uuidgen to correct "
4003 "this issue. (%s; %s)",
4031 const char *launchd_env_var,
4034 #ifdef DBUS_ENABLE_LAUNCHD
4038 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4043 "Unable to find launchd socket when setuid");
4048 argv[i] =
"launchctl";
4052 argv[i] = (
char*)launchd_env_var;
4059 if (!_read_subprocess_line_argv(argv[0],
TRUE, argv, socket_path, error))
4075 "can't lookup socket from launchd; launchd support not compiled in");
4080 #ifdef DBUS_ENABLE_LAUNCHD
4090 "Unable to find launchd socket when setuid");
4096 _DBUS_SET_OOM (error);
4111 "launchd did not provide a socket path, "
4112 "verify that org.freedesktop.dbus-session.plist is loaded!");
4118 _DBUS_SET_OOM (error);
4125 _DBUS_SET_OOM (error);
4140 const char *runtime_dir =
_dbus_getenv (
"XDG_RUNTIME_DIR");
4145 if (runtime_dir ==
NULL)
4147 _dbus_verbose (
"XDG_RUNTIME_DIR not found in environment");
4154 _DBUS_SET_OOM (error);
4160 _DBUS_SET_OOM (error);
4166 _dbus_verbose (
"XDG_RUNTIME_DIR/bus not available: %s",
4167 _dbus_strerror (errno));
4173 if (stbuf.st_uid != getuid ())
4175 _dbus_verbose (
"XDG_RUNTIME_DIR/bus owned by uid %ld, not our uid %ld",
4176 (
long) stbuf.st_uid, (
long) getuid ());
4182 if ((stbuf.st_mode & S_IFMT) != S_IFSOCK)
4184 _dbus_verbose (
"XDG_RUNTIME_DIR/bus is not a socket: st_mode = 0o%lo",
4185 (
long) stbuf.st_mode);
4194 _DBUS_SET_OOM (error);
4230 #ifdef DBUS_ENABLE_LAUNCHD
4232 return _dbus_lookup_session_address_launchd (address, error);
4236 if (!_dbus_lookup_user_bus (supported, address, error))
4238 else if (*supported)
4296 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
4298 const char *
override;
4301 if (
override !=
NULL && *
override !=
'\0')
4307 _dbus_verbose (
"Using fake homedir for testing: %s\n",
4315 if (!already_warned)
4317 _dbus_warn (
"Using %s for testing, set DBUS_TEST_HOMEDIR to avoid",
4319 already_warned =
TRUE;
4345 _dbus_daemon_publish_session_bus_address (
const char* addr,
4353 _dbus_daemon_unpublish_session_bus_address (
void)
4371 #if EAGAIN == EWOULDBLOCK
4374 return e == EAGAIN || e == EWOULDBLOCK;
4389 const char *filename_c;
4391 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4395 if (rmdir (filename_c) != 0)
4398 "Failed to remove directory %s: %s\n",
4399 filename_c, _dbus_strerror (errno));
4419 struct sockaddr_storage storage;
4420 struct sockaddr_un un;
4423 socklen_t sa_len =
sizeof(sa_buf);
4427 if (getsockname(fd.fd, &sa_buf.sa, &sa_len) < 0)
4430 return sa_buf.sa.sa_family == AF_UNIX;
4453 d = opendir (
"/proc/self/fd");
4467 if (de->d_name[0] ==
'.')
4471 l = strtol (de->d_name, &e, 10);
4472 if (errno != 0 || e ==
NULL || *e !=
'\0')
4479 if (fd == dirfd (d))
4490 maxfds = sysconf (_SC_OPEN_MAX);
4499 for (i = 3; i < maxfds; i++)
4518 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE)
4521 extern int __libc_enable_secure;
4522 return __libc_enable_secure;
4524 #elif defined(HAVE_ISSETUGID)
4526 return issetugid ();
4528 uid_t ruid, euid, suid;
4529 gid_t rgid, egid, sgid;
4536 if (_DBUS_UNLIKELY (!check_setuid_initialised))
4538 #ifdef HAVE_GETRESUID
4539 if (getresuid (&ruid, &euid, &suid) != 0 ||
4540 getresgid (&rgid, &egid, &sgid) != 0)
4543 suid = ruid = getuid ();
4544 sgid = rgid = getgid ();
4549 check_setuid_initialised =
TRUE;
4550 is_setuid = (ruid != euid || ruid != suid ||
4551 rgid != egid || rgid != sgid);
4572 struct sockaddr_storage storage;
4573 struct sockaddr_un un;
4574 struct sockaddr_in ipv4;
4575 struct sockaddr_in6 ipv6;
4577 char hostip[INET6_ADDRSTRLEN];
4578 socklen_t size =
sizeof (socket);
4581 if (getsockname (fd.fd, &socket.sa, &size))
4584 switch (socket.sa.sa_family)
4587 if (socket.un.sun_path[0]==
'\0')
4603 if (inet_ntop (AF_INET, &socket.ipv4.sin_addr, hostip, sizeof (hostip)))
4605 hostip, ntohs (socket.ipv4.sin_port)))
4611 if (inet_ntop (AF_INET6, &socket.ipv6.sin6_addr, hostip, sizeof (hostip)))
4613 ntohs (socket.ipv6.sin6_port)) &&
4621 "Failed to read address from socket: Unknown socket type.");
4627 "Failed to open socket: %s",
4628 _dbus_strerror (errno));
4633 _dbus_save_socket_errno (
void)
4639 _dbus_restore_socket_errno (
int saved_errno)
4641 errno = saved_errno;
4644 static const char *syslog_tag =
"dbus";
4645 #ifdef HAVE_SYSLOG_H
4646 static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
4669 (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
4673 #ifdef HAVE_SYSLOG_H
4676 if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
4677 openlog (tag, LOG_PID, LOG_DAEMON);
4694 #ifdef HAVE_SYSLOG_H
4695 if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
4700 case DBUS_SYSTEM_LOG_INFO:
4701 flags = LOG_DAEMON | LOG_INFO;
4703 case DBUS_SYSTEM_LOG_WARNING:
4704 flags = LOG_DAEMON | LOG_WARNING;
4706 case DBUS_SYSTEM_LOG_SECURITY:
4707 flags = LOG_AUTH | LOG_NOTICE;
4709 case DBUS_SYSTEM_LOG_ERROR:
4710 flags = LOG_DAEMON|LOG_CRIT;
4716 DBUS_VA_COPY (tmp, args);
4717 vsyslog (flags, msg, tmp);
4723 if (log_flags & DBUS_LOG_FLAGS_STDERR)
4726 DBUS_VA_COPY (tmp, args);
4728 vfprintf (stderr, msg, tmp);
4729 fputc (
'\n', stderr);