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)
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);
320 bytes_read = recvmsg(fd, &m, 0
321 #ifdef MSG_CMSG_CLOEXEC
342 if (m.msg_flags & MSG_CTRUNC)
354 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
355 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
359 _dbus_assert(cm->cmsg_len <= CMSG_LEN(*n_fds *
sizeof(
int)));
360 *n_fds = (cm->cmsg_len - CMSG_LEN(0)) /
sizeof(
int);
362 memcpy(fds, CMSG_DATA(cm), *n_fds *
sizeof(
int));
368 for (i = 0; i < *n_fds; i++)
391 _dbus_write_socket_with_unix_fds(
int fd,
398 #ifndef HAVE_UNIX_FD_PASSING
407 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len,
NULL, 0, 0, fds, n_fds);
412 _dbus_write_socket_with_unix_fds_two(
int fd,
422 #ifndef HAVE_UNIX_FD_PASSING
430 buffer1, start1, len1,
431 buffer2, start2, len2);
445 iov[0].iov_len = len1;
450 iov[1].iov_len = len2;
455 m.msg_iovlen = buffer2 ? 2 : 1;
459 m.msg_controllen = CMSG_SPACE(n_fds *
sizeof(
int));
460 m.msg_control = alloca(m.msg_controllen);
461 memset(m.msg_control, 0, m.msg_controllen);
463 cm = CMSG_FIRSTHDR(&m);
464 cm->cmsg_level = SOL_SOCKET;
465 cm->cmsg_type = SCM_RIGHTS;
466 cm->cmsg_len = CMSG_LEN(n_fds *
sizeof(
int));
467 memcpy(CMSG_DATA(cm), fds, n_fds *
sizeof(
int));
472 bytes_written = sendmsg (fd, &m, 0
473 #
if HAVE_DECL_MSG_NOSIGNAL
478 if (bytes_written < 0 && errno == EINTR)
482 if (bytes_written > 0)
486 return bytes_written;
512 #if HAVE_DECL_MSG_NOSIGNAL
513 struct iovec vectors[2];
536 vectors[0].iov_base = (
char*) data1;
537 vectors[0].iov_len = len1;
538 vectors[1].iov_base = (
char*) data2;
539 vectors[1].iov_len = len2;
543 m.msg_iovlen = data2 ? 2 : 1;
547 bytes_written = sendmsg (fd, &m, MSG_NOSIGNAL);
549 if (bytes_written < 0 && errno == EINTR)
552 return bytes_written;
556 buffer2, start2, len2);
561 _dbus_socket_is_invalid (
int fd)
605 bytes_read = read (fd, data, count);
655 bytes_written = write (fd, data, len);
657 if (bytes_written < 0 && errno == EINTR)
661 if (bytes_written > 0)
665 return bytes_written;
705 struct iovec vectors[2];
721 vectors[0].iov_base = (
char*) data1;
722 vectors[0].iov_len = len1;
723 vectors[1].iov_base = (
char*) data2;
724 vectors[1].iov_len = len2;
728 bytes_written = writev (fd,
732 if (bytes_written < 0 && errno == EINTR)
735 return bytes_written;
742 if (ret1 == len1 && buffer2 !=
NULL)
756 #define _DBUS_MAX_SUN_PATH_LENGTH 99
794 struct sockaddr_un addr;
796 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
798 _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
802 if (!_dbus_open_unix_socket (&fd, error))
804 _DBUS_ASSERT_ERROR_IS_SET(error);
807 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
810 addr.sun_family = AF_UNIX;
811 path_len = strlen (path);
815 #ifdef HAVE_ABSTRACT_SOCKETS
816 addr.sun_path[0] =
'\0';
819 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
822 "Abstract socket name too long\n");
827 strncpy (&addr.sun_path[1], path, path_len);
831 "Operating system does not support abstract socket namespace\n");
838 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
841 "Socket name too long\n");
846 strncpy (addr.sun_path, path, path_len);
849 if (connect (fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
853 "Failed to connect to socket %s: %s",
854 path, _dbus_strerror (errno));
860 if (!_dbus_set_fd_nonblocking (fd, error))
862 _DBUS_ASSERT_ERROR_IS_SET (error);
891 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
893 _dbus_verbose (
"connecting to process %s\n", path);
895 if (socketpair (AF_UNIX, SOCK_STREAM
903 "Failed to create socket pair: %s",
904 _dbus_strerror (errno));
916 "Failed to fork() to call %s: %s",
917 path, _dbus_strerror (errno));
928 dup2 (fds[1], STDIN_FILENO);
929 dup2 (fds[1], STDOUT_FILENO);
931 if (fds[1] != STDIN_FILENO &&
932 fds[1] != STDOUT_FILENO)
942 fprintf (stderr,
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
950 if (!_dbus_set_fd_nonblocking (fds[0], error))
952 _DBUS_ASSERT_ERROR_IS_SET (error);
975 #if defined(HAVE_CMSGCRED)
979 #elif defined(LOCAL_CREDS)
980 int val = on ? 1 : 0;
981 if (setsockopt (fd, 0, LOCAL_CREDS, &val,
sizeof (val)) < 0)
983 _dbus_verbose (
"Unable to set LOCAL_CREDS socket option on fd %d\n", fd);
987 _dbus_verbose (
"LOCAL_CREDS %s for further messages on fd %d\n",
988 on ?
"enabled" :
"disabled", fd);
1017 struct sockaddr_un addr;
1019 unsigned int reuseaddr;
1021 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1023 _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
1026 if (!_dbus_open_unix_socket (&listen_fd, error))
1028 _DBUS_ASSERT_ERROR_IS_SET(error);
1031 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1034 addr.sun_family = AF_UNIX;
1035 path_len = strlen (path);
1039 #ifdef HAVE_ABSTRACT_SOCKETS
1043 addr.sun_path[0] =
'\0';
1046 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1049 "Abstract socket name too long\n");
1054 strncpy (&addr.sun_path[1], path, path_len);
1058 "Operating system does not support abstract socket namespace\n");
1078 if (stat (path, &sb) == 0 &&
1079 S_ISSOCK (sb.st_mode))
1083 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1086 "Abstract socket name too long\n");
1091 strncpy (addr.sun_path, path, path_len);
1095 if (setsockopt (listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1097 _dbus_warn (
"Failed to set socket option\"%s\": %s",
1098 path, _dbus_strerror (errno));
1101 if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1104 "Failed to bind socket \"%s\": %s",
1105 path, _dbus_strerror (errno));
1110 if (listen (listen_fd, 30 ) < 0)
1113 "Failed to listen on socket \"%s\": %s",
1114 path, _dbus_strerror (errno));
1119 if (!_dbus_set_local_creds (listen_fd,
TRUE))
1122 "Failed to enable LOCAL_CREDS on socket \"%s\": %s",
1123 path, _dbus_strerror (errno));
1128 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1130 _DBUS_ASSERT_ERROR_IS_SET (error);
1138 if (!
abstract && chmod (path, 0777) < 0)
1139 _dbus_warn (
"Could not set mode 0777 on socket %s\n",
1163 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1165 n = sd_listen_fds (
TRUE);
1169 "Failed to acquire systemd socket: %s",
1170 _dbus_strerror (-n));
1177 "No socket received.");
1181 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1183 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1187 "Failed to verify systemd socket type: %s",
1188 _dbus_strerror (-r));
1195 "Passed socket has wrong type.");
1207 "Failed to allocate file handle array.");
1211 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1213 if (!_dbus_set_local_creds (fd,
TRUE))
1216 "Failed to enable LOCAL_CREDS on systemd socket: %s",
1217 _dbus_strerror (errno));
1221 if (!_dbus_set_fd_nonblocking (fd, error))
1223 _DBUS_ASSERT_ERROR_IS_SET (error);
1227 new_fds[fd - SD_LISTEN_FDS_START] = fd;
1235 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1263 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
1267 _dbus_connect_tcp_socket_with_nonce (
const char *host,
1270 const char *noncefile,
1273 int saved_errno = 0;
1275 struct addrinfo hints;
1276 struct addrinfo *ai, *tmp;
1278 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1283 hints.ai_family = AF_UNSPEC;
1284 else if (!strcmp(family,
"ipv4"))
1285 hints.ai_family = AF_INET;
1286 else if (!strcmp(family,
"ipv6"))
1287 hints.ai_family = AF_INET6;
1292 "Unknown address family %s", family);
1295 hints.ai_protocol = IPPROTO_TCP;
1296 hints.ai_socktype = SOCK_STREAM;
1297 hints.ai_flags = AI_ADDRCONFIG;
1299 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1303 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1304 host, port, gai_strerror(res), res);
1311 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1314 _DBUS_ASSERT_ERROR_IS_SET(error);
1317 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1319 if (connect (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1321 saved_errno = errno;
1336 "Failed to connect to socket \"%s:%s\" %s",
1337 host, port, _dbus_strerror(saved_errno));
1341 if (noncefile !=
NULL)
1346 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1356 if (!_dbus_set_fd_nonblocking (fd, error))
1390 int nlisten_fd = 0, *listen_fd =
NULL, res, i;
1391 struct addrinfo hints;
1392 struct addrinfo *ai, *tmp;
1393 unsigned int reuseaddr;
1396 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1401 hints.ai_family = AF_UNSPEC;
1402 else if (!strcmp(family,
"ipv4"))
1403 hints.ai_family = AF_INET;
1404 else if (!strcmp(family,
"ipv6"))
1405 hints.ai_family = AF_INET6;
1410 "Unknown address family %s", family);
1414 hints.ai_protocol = IPPROTO_TCP;
1415 hints.ai_socktype = SOCK_STREAM;
1416 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1418 redo_lookup_with_port:
1420 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1424 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1425 host ? host :
"*", port, gai_strerror(res), res);
1432 int fd = -1, *newlisten_fd;
1433 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1435 _DBUS_ASSERT_ERROR_IS_SET(error);
1438 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1441 if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1443 _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
1444 host ? host :
"*", port, _dbus_strerror (errno));
1447 if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1449 saved_errno = errno;
1451 if (saved_errno == EADDRINUSE)
1460 "Failed to bind socket \"%s:%s\": %s",
1461 host ? host :
"*", port, _dbus_strerror (saved_errno));
1465 if (listen (fd, 30 ) < 0)
1467 saved_errno = errno;
1470 "Failed to listen on socket \"%s:%s\": %s",
1471 host ? host :
"*", port, _dbus_strerror (saved_errno));
1475 newlisten_fd =
dbus_realloc(listen_fd,
sizeof(
int)*(nlisten_fd+1));
1478 saved_errno = errno;
1481 "Failed to allocate file handle array: %s",
1482 _dbus_strerror (saved_errno));
1485 listen_fd = newlisten_fd;
1486 listen_fd[nlisten_fd] = fd;
1495 if (!port || !strcmp(port,
"0"))
1498 struct sockaddr_storage addr;
1502 addrlen =
sizeof(addr);
1503 result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
1506 (res = getnameinfo ((
struct sockaddr*)&addr, addrlen,
NULL, 0,
1507 portbuf,
sizeof(portbuf),
1508 NI_NUMERICHOST)) != 0)
1511 "Failed to resolve port \"%s:%s\": %s (%s)",
1512 host ? host :
"*", port, gai_strerror(res), res);
1524 goto redo_lookup_with_port;
1545 "Failed to bind socket \"%s:%s\": %s",
1546 host ? host :
"*", port, _dbus_strerror (errno));
1550 for (i = 0 ; i < nlisten_fd ; i++)
1552 if (!_dbus_set_fd_nonblocking (listen_fd[i], error))
1565 for (i = 0 ; i < nlisten_fd ; i++)
1572 write_credentials_byte (
int server_fd,
1576 char buf[1] = {
'\0' };
1577 #if defined(HAVE_CMSGCRED)
1580 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1591 msg.msg_control = (caddr_t) &cmsg;
1592 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1594 cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
1595 cmsg.hdr.cmsg_level = SOL_SOCKET;
1596 cmsg.hdr.cmsg_type = SCM_CREDS;
1599 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1603 #if defined(HAVE_CMSGCRED)
1604 bytes_written = sendmsg (server_fd, &msg, 0
1605 #
if HAVE_DECL_MSG_NOSIGNAL
1610 bytes_written = send (server_fd, buf, 1, 0
1611 #
if HAVE_DECL_MSG_NOSIGNAL
1617 if (bytes_written < 0 && errno == EINTR)
1620 if (bytes_written < 0)
1623 "Failed to write credentials byte: %s",
1624 _dbus_strerror (errno));
1627 else if (bytes_written == 0)
1630 "wrote zero bytes writing credentials byte");
1636 _dbus_verbose (
"wrote credentials byte\n");
1674 #ifdef HAVE_CMSGCRED
1677 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1680 #elif defined(LOCAL_CREDS)
1683 struct sockcred cred;
1690 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1708 iov.iov_base = &buf;
1715 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
1717 msg.msg_control = (caddr_t) &cmsg;
1718 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1722 bytes_read = recvmsg (client_fd, &msg, 0);
1735 "Failed to read credentials byte: %s",
1736 _dbus_strerror (errno));
1739 else if (bytes_read == 0)
1745 "Failed to read credentials byte (zero-length read)");
1748 else if (buf !=
'\0')
1751 "Credentials byte was not nul");
1755 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
1756 if (cmsg.hdr.cmsg_len < CMSG_LEN (
sizeof (
struct cmsgcred))
1757 || cmsg.hdr.cmsg_type != SCM_CREDS)
1760 "Message from recvmsg() was not SCM_CREDS");
1765 _dbus_verbose (
"read credentials byte\n");
1770 struct sockpeercred cr;
1774 int cr_len =
sizeof (cr);
1776 if (getsockopt (client_fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) == 0 &&
1777 cr_len ==
sizeof (cr))
1784 _dbus_verbose (
"Failed to getsockopt() credentials, returned len %d/%d: %s\n",
1785 cr_len, (
int)
sizeof (cr), _dbus_strerror (errno));
1787 #elif defined(HAVE_CMSGCRED)
1788 struct cmsgcred *cred;
1790 cred = (
struct cmsgcred *) CMSG_DATA (&cmsg.hdr);
1791 pid_read = cred->cmcred_pid;
1792 uid_read = cred->cmcred_euid;
1793 #elif defined(LOCAL_CREDS)
1795 uid_read = cmsg.cred.sc_uid;
1798 _dbus_set_local_creds (client_fd,
FALSE);
1799 #elif defined(HAVE_GETPEEREID)
1802 if (getpeereid (client_fd, &euid, &egid) == 0)
1808 _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
1810 #elif defined(HAVE_GETPEERUCRED)
1811 ucred_t * ucred =
NULL;
1812 if (getpeerucred (client_fd, &ucred) == 0)
1814 pid_read = ucred_getpid (ucred);
1815 uid_read = ucred_geteuid (ucred);
1818 adt_session_data_t *adth =
NULL;
1819 adt_export_data_t *data =
NULL;
1821 if (adt_start_session (&adth,
NULL, 0) || (adth ==
NULL))
1823 _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
1827 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
1829 _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
1833 size = adt_export_session_data (adth, &data);
1836 _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
1844 (void) adt_end_session (adth);
1850 _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
1855 _dbus_verbose (
"Socket credentials not supported on this OS\n");
1859 _dbus_verbose (
"Credentials:"
1870 _DBUS_SET_OOM (error);
1879 _DBUS_SET_OOM (error);
1908 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1910 if (write_credentials_byte (server_fd, error))
1929 struct sockaddr addr;
1935 addrlen =
sizeof (addr);
1941 client_fd = accept4 (listen_fd, &addr, &addrlen, SOCK_CLOEXEC);
1942 cloexec_done = client_fd >= 0;
1944 if (client_fd < 0 && errno == ENOSYS)
1947 client_fd = accept (listen_fd, &addr, &addrlen);
1956 _dbus_verbose (
"client fd %d accepted\n", client_fd);
1979 const char *directory;
1982 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1986 if (stat (directory, &sb) < 0)
1989 "%s", _dbus_strerror (errno));
1994 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
1995 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
1998 "%s directory is not private to the user", directory);
2006 fill_user_info_from_passwd (
struct passwd *p,
2013 info->
uid = p->pw_uid;
2034 const char *username_c;
2047 if (username !=
NULL)
2057 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
2063 struct passwd p_str;
2066 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
2072 if ((
long) buflen <= 0)
2086 #ifdef HAVE_POSIX_GETPWNAM_R
2088 result = getpwuid_r (uid, &p_str, buf, buflen,
2091 result = getpwnam_r (username_c, &p_str, buf, buflen,
2095 p = getpwuid_r (uid, &p_str, buf, buflen);
2097 p = getpwnam_r (username_c, &p_str, buf, buflen);
2101 if (result == ERANGE && buflen < 512 * 1024)
2111 if (result == 0 && p == &p_str)
2113 if (!fill_user_info_from_passwd (p, info, error))
2123 "User \"%s\" unknown or no memory to allocate password entry\n",
2124 username_c ? username_c :
"???");
2125 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2138 p = getpwnam (username_c);
2142 if (!fill_user_info_from_passwd (p, info, error))
2150 "User \"%s\" unknown or no memory to allocate password entry\n",
2151 username_c ? username_c :
"???");
2152 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2161 #ifdef HAVE_GETGROUPLIST
2166 int initial_buf_count;
2168 initial_buf_count = 17;
2169 buf_count = initial_buf_count;
2177 if (getgrouplist (username_c,
2179 buf, &buf_count) < 0)
2195 if (buf_count == initial_buf_count)
2210 if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
2214 _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2215 username_c, buf_count, buf_count);
2221 "Failed to get groups for username \"%s\" primary GID "
2224 _dbus_strerror (errno));
2239 for (i = 0; i < buf_count; ++i)
2262 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2267 _DBUS_ASSERT_ERROR_IS_SET (error);
2301 return fill_user_info (info, uid,
2405 _dbus_verbose (
"UID string was zero length\n");
2414 _dbus_verbose (
"could not parse string as a UID\n");
2420 _dbus_verbose (
"string contained trailing stuff after UID\n");
2443 return __sync_add_and_fetch(&atomic->
value, 1)-1;
2447 res = atomic->
value;
2464 return __sync_sub_and_fetch(&atomic->
value, 1)+1;
2469 res = atomic->
value;
2487 __sync_synchronize ();
2488 return atomic->
value;
2493 res = atomic->
value;
2510 int timeout_milliseconds)
2512 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
2523 sizeof (
DBusPollFD) ==
sizeof (
struct pollfd) &&
2525 _DBUS_STRUCT_OFFSET (
struct pollfd, fd) &&
2527 _DBUS_STRUCT_OFFSET (
struct pollfd, events) &&
2529 _DBUS_STRUCT_OFFSET (
struct pollfd, revents))
2531 return poll ((
struct pollfd*) fds,
2533 timeout_milliseconds);
2540 _dbus_warn (
"didn't implement poll() properly for this system yet\n");
2545 fd_set read_set, write_set, err_set;
2551 FD_ZERO (&read_set);
2552 FD_ZERO (&write_set);
2555 for (i = 0; i < n_fds; i++)
2560 FD_SET (fdp->
fd, &read_set);
2563 FD_SET (fdp->
fd, &write_set);
2565 FD_SET (fdp->
fd, &err_set);
2567 max_fd = MAX (max_fd, fdp->
fd);
2570 tv.tv_sec = timeout_milliseconds / 1000;
2571 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
2573 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
2574 timeout_milliseconds < 0 ?
NULL : &tv);
2578 for (i = 0; i < n_fds; i++)
2584 if (FD_ISSET (fdp->
fd, &read_set))
2587 if (FD_ISSET (fdp->
fd, &write_set))
2590 if (FD_ISSET (fdp->
fd, &err_set))
2610 #ifdef HAVE_MONOTONIC_CLOCK
2612 clock_gettime (CLOCK_MONOTONIC, &ts);
2615 *tv_sec = ts.tv_sec;
2617 *tv_usec = ts.tv_nsec / 1000;
2621 gettimeofday (&t,
NULL);
2626 *tv_usec = t.tv_usec;
2643 gettimeofday (&t,
NULL);
2648 *tv_usec = t.tv_usec;
2663 const char *filename_c;
2665 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2669 if (mkdir (filename_c, 0700) < 0)
2671 if (errno == EEXIST)
2675 "Failed to create directory %s: %s\n",
2676 filename_c, _dbus_strerror (errno));
2709 if (dir_ends_in_slash && file_starts_with_slash)
2713 else if (!(dir_ends_in_slash || file_starts_with_slash))
2724 #define NANOSECONDS_PER_SECOND 1000000000
2726 #define MICROSECONDS_PER_SECOND 1000000
2728 #define MILLISECONDS_PER_SECOND 1000
2730 #define NANOSECONDS_PER_MILLISECOND 1000000
2732 #define MICROSECONDS_PER_MILLISECOND 1000
2741 #ifdef HAVE_NANOSLEEP
2742 struct timespec req;
2743 struct timespec rem;
2745 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
2746 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
2750 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
2752 #elif defined (HAVE_USLEEP)
2753 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
2755 sleep (MAX (milliseconds / 1000, 1));
2760 _dbus_generate_pseudorandom_bytes (
DBusString *str,
2803 fd = open (
"/dev/urandom", O_RDONLY);
2805 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2807 _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
2809 if (
_dbus_read (fd, str, n_bytes) != n_bytes)
2813 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
2816 _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
2844 _dbus_strerror (
int error_number)
2848 msg = strerror (error_number);
2861 signal (SIGPIPE, SIG_IGN);
2876 val = fcntl (fd, F_GETFD, 0);
2883 fcntl (fd, F_SETFD, val);
2897 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2906 "Could not close fd %d", fd);
2926 #ifdef F_DUPFD_CLOEXEC
2929 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2930 cloexec_done = new_fd >= 0;
2932 if (new_fd < 0 && errno == EINVAL)
2935 new_fd = fcntl(fd, F_DUPFD, 3);
2941 "Could not duplicate fd %d", fd);
2945 #ifdef F_DUPFD_CLOEXEC
2963 _dbus_set_fd_nonblocking (
int fd,
2968 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2970 val = fcntl (fd, F_GETFL, 0);
2974 "Failed to get flags from file descriptor %d: %s",
2975 fd, _dbus_strerror (errno));
2976 _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
2977 _dbus_strerror (errno));
2981 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
2984 "Failed to set nonblocking flag of file descriptor %d: %s",
2985 fd, _dbus_strerror (errno));
2986 _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
2987 fd, _dbus_strerror (errno));
3003 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
3009 bt_size = backtrace (bt, 500);
3011 syms = backtrace_symbols (bt, bt_size);
3017 fprintf (stderr,
" %s\n", syms[i]);
3023 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
3024 fprintf (stderr,
" D-Bus not built with -rdynamic so unable to print a backtrace\n");
3026 fprintf (stderr,
" D-Bus not compiled with backtrace support so unable to print a backtrace\n");
3048 #ifdef HAVE_SOCKETPAIR
3055 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
3056 cloexec_done = retval >= 0;
3058 if (retval < 0 && errno == EINVAL)
3061 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
3067 "Could not create full-duplex pipe");
3071 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3082 (!_dbus_set_fd_nonblocking (fds[0],
NULL) ||
3083 !_dbus_set_fd_nonblocking (fds[1],
NULL)))
3086 "Could not set full-duplex pipe nonblocking");
3097 _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
3102 _dbus_warn (
"_dbus_full_duplex_pipe() not implemented on this OS\n");
3104 "_dbus_full_duplex_pipe() not implemented on this OS");
3121 char static_buf[1024];
3122 int bufsize =
sizeof (static_buf);
3126 DBUS_VA_COPY (args_copy, args);
3127 len = vsnprintf (static_buf, bufsize, format, args_copy);
3144 DBUS_VA_COPY (args_copy, args);
3146 if (vsnprintf (static_buf, 1, format, args_copy) == 1)
3165 DBUS_VA_COPY (args_copy, args);
3166 len = vsnprintf (buf, bufsize, format, args_copy);
3190 static const char* tmpdir =
NULL;
3199 tmpdir = getenv(
"TMPDIR");
3205 tmpdir = getenv(
"TMP");
3207 tmpdir = getenv(
"TEMP");
3239 _read_subprocess_line_argv (
const char *progpath,
3245 int result_pipe[2] = { -1, -1 };
3246 int errors_pipe[2] = { -1, -1 };
3253 sigset_t new_set, old_set;
3255 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3262 sigemptyset (&new_set);
3263 sigaddset (&new_set, SIGCHLD);
3264 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3270 if (pipe (result_pipe) < 0)
3273 "Failed to create a pipe to call %s: %s",
3274 progpath, _dbus_strerror (errno));
3275 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3276 progpath, _dbus_strerror (errno));
3279 if (pipe (errors_pipe) < 0)
3282 "Failed to create a pipe to call %s: %s",
3283 progpath, _dbus_strerror (errno));
3284 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3285 progpath, _dbus_strerror (errno));
3293 "Failed to fork() to call %s: %s",
3294 progpath, _dbus_strerror (errno));
3295 _dbus_verbose (
"Failed to fork() to call %s: %s\n",
3296 progpath, _dbus_strerror (errno));
3305 fd = open (
"/dev/null", O_RDWR);
3310 _dbus_verbose (
"/dev/null fd %d opened\n", fd);
3319 if (dup2 (fd, 0) == -1)
3321 if (dup2 (result_pipe[
WRITE_END], 1) == -1)
3323 if (dup2 (errors_pipe[WRITE_END], 2) == -1)
3328 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3331 if (progpath[0] ==
'/')
3333 execv (progpath, argv);
3342 execvp (strrchr (progpath,
'/')+1, argv);
3345 execvp (progpath, argv);
3352 close (result_pipe[WRITE_END]);
3353 close (errors_pipe[WRITE_END]);
3367 ret = waitpid (pid, &status, 0);
3369 while (ret == -1 && errno == EINTR);
3373 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
3379 _DBUS_SET_OOM (error);
3393 "%s terminated abnormally with the following error: %s",
3397 "%s terminated abnormally without any error message",
3405 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3408 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3410 _DBUS_ASSERT_ERROR_IS_SET (error);
3412 if (result_pipe[0] != -1)
3413 close (result_pipe[0]);
3414 if (result_pipe[1] != -1)
3415 close (result_pipe[1]);
3416 if (errors_pipe[0] != -1)
3417 close (errors_pipe[0]);
3418 if (errors_pipe[1] != -1)
3419 close (errors_pipe[1]);
3440 #ifdef DBUS_ENABLE_X11_AUTOLAUNCH
3444 const char *display;
3445 static char *argv[6];
3453 "Unable to autolaunch when setuid");
3457 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3465 if (display ==
NULL || display[0] ==
'\0')
3468 "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
3474 _DBUS_SET_OOM (error);
3480 _DBUS_SET_OOM (error);
3485 argv[i] =
"dbus-launch";
3487 argv[i] =
"--autolaunch";
3491 argv[i] =
"--binary-syntax";
3493 argv[i] =
"--close-stderr";
3500 retval = _read_subprocess_line_argv (DBUS_BINDIR
"/dbus-launch",
3502 argv, address, error);
3509 "Using X11 for dbus-daemon autolaunch was disabled at compile time, "
3510 "set your DBUS_SESSION_BUS_ADDRESS instead");
3554 #define DBUS_UNIX_STANDARD_SESSION_SERVICEDIR "/dbus-1/services"
3555 #define DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR "/dbus-1/system-services"
3565 const char *launchd_env_var,
3568 #ifdef DBUS_ENABLE_LAUNCHD
3572 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3577 "Unable to find launchd socket when setuid");
3582 argv[i] =
"launchctl";
3586 argv[i] = (
char*)launchd_env_var;
3593 if (!_read_subprocess_line_argv(argv[0],
TRUE, argv, socket_path, error))
3609 "can't lookup socket from launchd; launchd support not compiled in");
3614 #ifdef DBUS_ENABLE_LAUNCHD
3624 "Unable to find launchd socket when setuid");
3630 _DBUS_SET_OOM (error);
3645 "launchd did not provide a socket path, "
3646 "verify that org.freedesktop.dbus-session.plist is loaded!");
3652 _DBUS_SET_OOM (error);
3659 _DBUS_SET_OOM (error);
3693 #ifdef DBUS_ENABLE_LAUNCHD
3695 return _dbus_lookup_session_address_launchd (address, error);
3726 const char *xdg_data_home;
3727 const char *xdg_data_dirs;
3736 if (xdg_data_home !=
NULL)
3760 if (xdg_data_dirs !=
NULL)
3784 DBUS_UNIX_STANDARD_SESSION_SERVICEDIR,
3827 static const char standard_search_path[] =
3837 DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR,
3913 #ifdef DBUS_BUILD_TESTS
3915 const char *
override;
3918 if (
override !=
NULL && *
override !=
'\0')
3924 _dbus_verbose (
"Using fake homedir for testing: %s\n",
3930 if (!already_warned)
3932 _dbus_warn (
"Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid\n");
3933 already_warned =
TRUE;
3959 _dbus_daemon_publish_session_bus_address (
const char* addr,
3967 _dbus_daemon_unpublish_session_bus_address (
void)
3981 return errno == EAGAIN || errno == EWOULDBLOCK;
3995 const char *filename_c;
3997 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4001 if (rmdir (filename_c) != 0)
4004 "Failed to remove directory %s: %s\n",
4005 filename_c, _dbus_strerror (errno));
4025 struct sockaddr_storage storage;
4026 struct sockaddr_un un;
4029 socklen_t sa_len =
sizeof(sa_buf);
4033 if (getsockname(fd, &sa_buf.sa, &sa_len) < 0)
4036 return sa_buf.sa.sa_family == AF_UNIX;
4053 _dbus_replace_install_prefix (
const char *configure_time_path)
4055 return configure_time_path;
4073 d = opendir (
"/proc/self/fd");
4083 k = readdir_r (d, &buf, &de);
4087 if (de->d_name[0] ==
'.')
4091 l = strtol (de->d_name, &e, 10);
4092 if (errno != 0 || e ==
NULL || *e !=
'\0')
4099 if (fd == dirfd (d))
4110 maxfds = sysconf (_SC_OPEN_MAX);
4119 for (i = 3; i < maxfds; i++)
4138 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE)
4141 extern int __libc_enable_secure;
4142 return __libc_enable_secure;
4144 #elif defined(HAVE_ISSETUGID)
4146 return issetugid ();
4148 uid_t ruid, euid, suid;
4149 gid_t rgid, egid, sgid;
4154 if (_DBUS_UNLIKELY (!check_setuid_initialised))
4156 #ifdef HAVE_GETRESUID
4157 if (getresuid (&ruid, &euid, &suid) != 0 ||
4158 getresgid (&rgid, &egid, &sgid) != 0)
4161 suid = ruid = getuid ();
4162 sgid = rgid = getgid ();
4167 check_setuid_initialised =
TRUE;
4168 is_setuid = (ruid != euid || ruid != suid ||
4169 rgid != egid || rgid != sgid);
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
dbus_bool_t _dbus_string_parse_int(const DBusString *str, int start, long *value_return, int *end_return)
Parses an integer contained in a DBusString.
An atomic integer safe to increment or decrement from multiple threads.
dbus_uid_t _dbus_credentials_get_unix_uid(DBusCredentials *credentials)
Gets the UNIX user ID in the credentials, or DBUS_UID_UNSET if the credentials object doesn't contain...
dbus_bool_t _dbus_string_append_uint(DBusString *str, unsigned long value)
Appends an unsigned integer to a DBusString.
dbus_int32_t _dbus_atomic_get(DBusAtomic *atomic)
Atomically get the value of an integer.
#define NULL
A null pointer, defined appropriately for C or C++.
dbus_bool_t _dbus_append_system_config_file(DBusString *str)
Append the absolute path of the system.conf file (there is no system bus on Windows so this can just ...
#define DBUS_ERROR_SPAWN_EXEC_FAILED
While starting a new process, the exec() call failed.
volatile dbus_int32_t value
Value of the atomic integer.
dbus_bool_t _dbus_check_dir_is_private_to_user(DBusString *dir, DBusError *error)
Checks to make sure the given directory is private to the user.
#define _DBUS_POLLHUP
Hung up.
void * dbus_realloc(void *memory, size_t bytes)
Resizes a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
dbus_bool_t _dbus_delete_directory(const DBusString *filename, DBusError *error)
Removes a directory; Directory must be empty.
dbus_bool_t _dbus_socket_can_pass_unix_fd(int fd)
Checks whether file descriptors may be passed via the socket.
#define _DBUS_POLLNVAL
Invalid request: fd not open.
int _dbus_write(int fd, const DBusString *buffer, int start, int len)
Thin wrapper around the write() system call that writes a part of a DBusString and handles EINTR for ...
#define DBUS_ERROR_NOT_SUPPORTED
Requested operation isn't supported (like ENOSYS on UNIX).
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
#define DBUS_GID_FORMAT
an appropriate printf format for dbus_gid_t
#define DBUS_PID_FORMAT
an appropriate printf format for dbus_pid_t
void _dbus_flush_caches(void)
Called when the bus daemon is signaled to reload its configuration; any caches should be nuked...
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
dbus_bool_t _dbus_full_duplex_pipe(int *fd1, int *fd2, dbus_bool_t blocking, DBusError *error)
Creates a full-duplex pipe (as in socketpair()).
int _dbus_write_socket_two(int fd, const DBusString *buffer1, int start1, int len1, const DBusString *buffer2, int start2, int len2)
Like _dbus_write_two() but only works on sockets and is thus available on Windows.
dbus_bool_t _dbus_check_setuid(void)
NOTE: If you modify this function, please also consider making the corresponding change in GLib...
void _dbus_user_database_flush_system(void)
Flushes the system global user database;.
void dbus_error_free(DBusError *error)
Frees an error that's been set (or just initialized), then reinitializes the error as in dbus_error_i...
dbus_bool_t _dbus_get_standard_session_servicedirs(DBusList **dirs)
Returns the standard directories for a session bus to look for service activation files...
dbus_gid_t primary_gid
GID.
#define _DBUS_POLLPRI
There is urgent data to read.
int _dbus_read_socket_with_unix_fds(int fd, DBusString *buffer, int count, int *fds, int *n_fds)
Like _dbus_read_socket() but also tries to read unix fds from the socket.
A portable struct pollfd wrapper.
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...
int _dbus_accept(int listen_fd)
Accepts a connection on a listening socket.
unsigned char _dbus_string_get_byte(const DBusString *str, int start)
Gets the byte at the given position.
int _dbus_dup(int fd, DBusError *error)
Duplicates a file descriptor.
#define _DBUS_POLLIN
There is data to read.
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
dbus_pid_t _dbus_getpid(void)
Gets our process ID.
dbus_bool_t _dbus_append_user_from_current_process(DBusString *str)
Append to the string the identity we would like to have when we authenticate, on UNIX this is the cur...
#define DBUS_ERROR_IO_ERROR
Something went wrong reading or writing to a socket, for example.
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
short events
Events to poll for.
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
dbus_bool_t _dbus_read_credentials_socket(int client_fd, DBusCredentials *credentials, DBusError *error)
Reads a single byte which must be nul (an error occurs otherwise), and reads unix credentials if avai...
#define DBUS_PID_UNSET
an invalid PID used to represent an uninitialized dbus_pid_t field
void _dbus_credentials_clear(DBusCredentials *credentials)
Clear all credentials in the object.
#define DBUS_UID_UNSET
an invalid UID used to represent an uninitialized dbus_uid_t field
dbus_bool_t _dbus_parse_uid(const DBusString *uid_str, dbus_uid_t *uid)
Gets a UID from a UID string.
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
dbus_bool_t _dbus_get_local_machine_uuid_encoded(DBusString *uuid_str)
Gets the hex-encoded UUID of the machine this function is executed on.
dbus_bool_t _dbus_get_autolaunch_address(const char *scope, DBusString *address, DBusError *error)
Returns the address of a new session bus.
const char * _dbus_error_from_errno(int error_number)
Converts a UNIX errno, or Windows errno or WinSock error value into a DBusError name.
dbus_bool_t _dbus_user_info_fill(DBusUserInfo *info, const DBusString *username, DBusError *error)
Gets user info for the given username.
dbus_bool_t _dbus_homedir_from_uid(dbus_uid_t uid, DBusString *homedir)
Gets the home directory for the given user.
void _dbus_get_monotonic_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
unsigned long dbus_pid_t
A process ID.
dbus_gid_t * group_ids
Groups IDs, including above primary group.
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
void _dbus_fd_set_close_on_exec(intptr_t fd)
Sets the file descriptor to be close on exec.
dbus_bool_t _dbus_lookup_launchd_socket(DBusString *socket_path, const char *launchd_env_var, DBusError *error)
quries launchd for a specific env var which holds the socket path.
void _dbus_get_real_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory.
void _dbus_close_all(void)
Closes all file descriptors except the first three (i.e.
dbus_bool_t _dbus_credentials_are_anonymous(DBusCredentials *credentials)
Checks whether a credentials object contains a user identity.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
char * _dbus_string_get_data(DBusString *str)
Gets the raw character buffer from the string.
int n_group_ids
Size of group IDs array.
int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll().
#define _DBUS_POLLOUT
Writing now will not block.
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
int _dbus_string_get_length(const DBusString *str)
Gets the length of a string (not including nul termination).
dbus_bool_t _dbus_append_keyring_directory_for_credentials(DBusString *directory, DBusCredentials *credentials)
Appends the directory in which a keyring for the given credentials should be stored.
int _dbus_read_socket(int fd, DBusString *buffer, int count)
Like _dbus_read(), but only works on sockets so is available on Windows.
Object representing an exception.
void _dbus_disable_sigpipe(void)
signal (SIGPIPE, SIG_IGN);
dbus_bool_t _dbus_send_credentials_socket(int server_fd, DBusError *error)
Sends a single nul byte with our UNIX credentials as ancillary data.
#define DBUS_ERROR_BAD_ADDRESS
A D-Bus bus address was malformed.
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
dbus_bool_t _dbus_credentials_add_adt_audit_data(DBusCredentials *credentials, void *audit_data, dbus_int32_t size)
Add ADT audit data to the credentials.
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof().
dbus_bool_t _dbus_close(int fd, DBusError *error)
Closes a file descriptor.
dbus_bool_t _dbus_create_directory(const DBusString *filename, DBusError *error)
Creates a directory; succeeds if the directory is created or already existed.
int _dbus_connect_exec(const char *path, char *const argv[], DBusError *error)
Creates a UNIX domain socket and connects it to the specified process to execute. ...
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
#define DBUS_GID_UNSET
an invalid GID used to represent an uninitialized dbus_gid_t field
dbus_bool_t _dbus_credentials_add_from_current_process(DBusCredentials *credentials)
Adds the credentials of the current process to the passed-in credentials object.
#define TRUE
Expands to "1".
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
#define READ_END
Helps remember which end of the pipe is which.
#define DBUS_UID_FORMAT
an appropriate printf format for dbus_uid_t
dbus_bool_t _dbus_read_uuid_file(const DBusString *filename, DBusGUID *uuid, dbus_bool_t create_if_not_found, DBusError *error)
Reads (and optionally writes) a uuid to a file.
char * homedir
Home directory.
dbus_uid_t _dbus_getuid(void)
Gets our UID.
const char * _dbus_get_tmpdir(void)
Gets the temporary files directory by inspecting the environment variables TMPDIR, TMP, and TEMP in that order.
#define _DBUS_DEFINE_GLOBAL_LOCK(name)
Defines a global lock variable with the given name.
dbus_bool_t _dbus_homedir_from_current_process(const DBusString **homedir)
Gets homedir of user owning current process.
unsigned long _dbus_pid_for_log(void)
The only reason this is separate from _dbus_getpid() is to allow it on Windows for logging but not fo...
void _dbus_generate_pseudorandom_bytes_buffer(char *buffer, int n_bytes)
Random numbers.
int _dbus_write_socket(int fd, const DBusString *buffer, int start, int len)
Like _dbus_write(), but only supports sockets and is thus available on Windows.
const char * _dbus_string_get_const_data_len(const DBusString *str, int start, int len)
const version of _dbus_string_get_data_len().
void _dbus_exit(int code)
Exit the process, returning the given value.
dbus_bool_t _dbus_split_paths_and_append(DBusString *dirs, const char *suffix, DBusList **dir_list)
Split paths into a list of char strings.
dbus_bool_t _dbus_get_is_errno_eagain_or_ewouldblock(void)
See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently for Winsock so is abstracted) ...
dbus_bool_t _dbus_user_info_fill_uid(DBusUserInfo *info, dbus_uid_t uid, DBusError *error)
Gets user info for the given user ID.
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
dbus_bool_t _dbus_lookup_session_address(dbus_bool_t *supported, DBusString *address, DBusError *error)
Determines the address of the session bus by querying a platform-specific method. ...
dbus_bool_t _dbus_credentials_add_unix_pid(DBusCredentials *credentials, dbus_pid_t pid)
Add a UNIX process ID to the credentials.
#define FALSE
Expands to "0".
dbus_bool_t _dbus_read_local_machine_uuid(DBusGUID *machine_id, dbus_bool_t create_if_not_found, DBusError *error)
Reads the uuid of the machine we're running on from the dbus configuration.
void _dbus_print_backtrace(void)
On GNU libc systems, print a crude backtrace to stderr.
void dbus_set_error_const(DBusError *error, const char *name, const char *message)
Assigns an error name and message to a DBusError.
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
#define _DBUS_LOCK(name)
Locks a global lock.
int _dbus_write_two(int fd, const DBusString *buffer1, int start1, int len1, const DBusString *buffer2, int start2, int len2)
Like _dbus_write() but will use writev() if possible to write both buffers in sequence.
int _dbus_printf_string_upper_bound(const char *format, va_list args)
Measure the length of the given format string and arguments, not including the terminating nul...
void _dbus_verbose_bytes_of_string(const DBusString *str, int start, int len)
Dump the given part of the string to verbose log.
dbus_uid_t _dbus_geteuid(void)
Gets our effective UID.
#define WRITE_END
Helps remember which end of the pipe is which.
unsigned long dbus_gid_t
A group ID.
int dbus_int32_t
A 32-bit signed integer on all platforms.
char * _dbus_strdup(const char *str)
Duplicates a string.
dbus_bool_t _dbus_close_socket(int fd, DBusError *error)
Closes a socket.
#define _DBUS_ZERO(object)
Sets all bits in an object to zero.
dbus_bool_t _dbus_credentials_add_unix_uid(DBusCredentials *credentials, dbus_uid_t uid)
Add a UNIX user ID to the credentials.
dbus_bool_t _dbus_append_session_config_file(DBusString *str)
Append the absolute path of the session.conf file.
unsigned long dbus_uid_t
A user ID.
short revents
Events that occurred.
const char * _dbus_string_get_const_data(const DBusString *str)
Gets the raw character buffer from a const string.
int _dbus_connect_unix_socket(const char *path, dbus_bool_t abstract, DBusError *error)
Creates a socket and connects it to the UNIX domain socket at the given path.
dbus_bool_t _dbus_get_standard_system_servicedirs(DBusList **dirs)
Returns the standard directories for a system bus to look for service activation files.
void _dbus_sleep_milliseconds(int milliseconds)
Sleeps the given number of milliseconds.
int _dbus_read(int fd, DBusString *buffer, int count)
Thin wrapper around the read() system call that appends the data it reads to the DBusString buffer...
dbus_bool_t dbus_error_is_set(const DBusError *error)
Checks whether an error occurred (the error is set).
int _dbus_listen_unix_socket(const char *path, dbus_bool_t abstract, DBusError *error)
Creates a socket and binds it to the given path, then listens on the socket.
int _dbus_connect_tcp_socket(const char *host, const char *port, const char *family, DBusError *error)
Creates a socket and connects to a socket at the given host and port.
int _dbus_listen_systemd_sockets(int **fds, DBusError *error)
Acquires one or more sockets passed in from systemd.
int _dbus_listen_tcp_socket(const char *host, const char *port, const char *family, DBusString *retport, int **fds_p, DBusError *error)
Creates a socket and binds it to the given path, then listens on the socket.
dbus_bool_t _dbus_generate_random_bytes(DBusString *str, int n_bytes)
Generates the given number of random bytes, using the best mechanism we can come up with...
Information about a UNIX user.
#define _DBUS_POLLERR
Error condition.