27 #include "dbus-internals.h" 28 #include "dbus-sysdeps.h" 29 #include "dbus-sysdeps-unix.h" 30 #include "dbus-threads.h" 31 #include "dbus-protocol.h" 32 #include "dbus-file.h" 33 #include "dbus-transport.h" 34 #include "dbus-string.h" 35 #include "dbus-userdb.h" 36 #include "dbus-list.h" 37 #include "dbus-credentials.h" 38 #include "dbus-nonce.h" 40 #include <sys/types.h> 47 #include <sys/socket.h> 56 #include <netinet/in.h> 57 #include <netinet/tcp.h> 60 #include <arpa/inet.h> 74 #ifdef HAVE_GETPEERUCRED 86 #include <systemd/sd-daemon.h> 98 #define AI_ADDRCONFIG 0 101 #ifndef HAVE_SOCKLEN_T 102 #define socklen_t int 105 #if defined (__sun) || defined (__sun__) 118 # define CMSG_ALIGN(len) _CMSG_DATA_ALIGN (len) 121 # define CMSG_ALIGN(len) (((len) + sizeof (long) - 1) & \ 122 ~(sizeof (long) - 1)) 127 # define CMSG_SPACE(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + \ 132 # define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len)) 137 static dbus_bool_t _dbus_set_fd_nonblocking (
int fd,
141 _dbus_open_socket (
int *fd_p,
150 *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
151 cloexec_done = *fd_p >= 0;
154 if (*fd_p < 0 && (errno == EINVAL || errno == EPROTOTYPE))
157 *fd_p = socket (domain, type, protocol);
169 _dbus_verbose (
"socket fd %d opened\n", *fd_p);
176 "Failed to open socket: %s",
177 _dbus_strerror (errno));
193 _dbus_open_unix_socket (
int *fd,
196 return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);
247 #if HAVE_DECL_MSG_NOSIGNAL 251 data = _dbus_string_get_const_data_len (buffer, start, len);
255 bytes_written = send (fd.fd, data, len, MSG_NOSIGNAL);
257 if (bytes_written < 0 && errno == EINTR)
260 return bytes_written;
285 #ifndef HAVE_UNIX_FD_PASSING 303 start = _dbus_string_get_length (buffer);
323 m.msg_controllen = CMSG_SPACE(*n_fds *
sizeof(
int));
327 m.msg_control = alloca(m.msg_controllen);
328 memset(m.msg_control, 0, m.msg_controllen);
334 m.msg_controllen = CMSG_LEN (*n_fds *
sizeof(
int));
338 bytes_read = recvmsg (fd.fd, &m, 0
339 #ifdef MSG_CMSG_CLOEXEC
360 if (m.msg_flags & MSG_CTRUNC)
372 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
373 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
376 int *payload = (
int *) CMSG_DATA (cm);
377 size_t payload_len_bytes = (cm->cmsg_len - CMSG_LEN (0));
378 size_t payload_len_fds = payload_len_bytes /
sizeof (int);
384 _DBUS_STATIC_ASSERT (
sizeof (
size_t) >=
sizeof (
int));
386 if (_DBUS_LIKELY (payload_len_fds <= (
size_t) *n_fds))
389 fds_to_use = payload_len_fds;
397 fds_to_use = (size_t) *n_fds;
402 for (i = fds_to_use; i < payload_len_fds; i++)
408 memcpy (fds, payload, fds_to_use *
sizeof (
int));
412 *n_fds = (int) fds_to_use;
417 for (i = 0; i < fds_to_use; i++)
440 _dbus_write_socket_with_unix_fds(
DBusSocket fd,
447 #ifndef HAVE_UNIX_FD_PASSING 456 return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len,
NULL, 0, 0, fds, n_fds);
461 _dbus_write_socket_with_unix_fds_two(
DBusSocket fd,
471 #ifndef HAVE_UNIX_FD_PASSING 479 buffer1, start1, len1,
480 buffer2, start2, len2);
493 iov[0].iov_base = (
char*) _dbus_string_get_const_data_len (buffer1, start1, len1);
494 iov[0].iov_len = len1;
498 iov[1].iov_base = (
char*) _dbus_string_get_const_data_len (buffer2, start2, len2);
499 iov[1].iov_len = len2;
504 m.msg_iovlen = buffer2 ? 2 : 1;
508 m.msg_controllen = CMSG_SPACE(n_fds *
sizeof(
int));
509 m.msg_control = alloca(m.msg_controllen);
510 memset(m.msg_control, 0, m.msg_controllen);
512 cm = CMSG_FIRSTHDR(&m);
513 cm->cmsg_level = SOL_SOCKET;
514 cm->cmsg_type = SCM_RIGHTS;
515 cm->cmsg_len = CMSG_LEN(n_fds *
sizeof(
int));
516 memcpy(CMSG_DATA(cm), fds, n_fds *
sizeof(
int));
521 bytes_written = sendmsg (fd.fd, &m, 0
522 #
if HAVE_DECL_MSG_NOSIGNAL
527 if (bytes_written < 0 && errno == EINTR)
531 if (bytes_written > 0)
535 return bytes_written;
561 #if HAVE_DECL_MSG_NOSIGNAL 562 struct iovec vectors[2];
574 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
577 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
585 vectors[0].iov_base = (
char*) data1;
586 vectors[0].iov_len = len1;
587 vectors[1].iov_base = (
char*) data2;
588 vectors[1].iov_len = len2;
592 m.msg_iovlen = data2 ? 2 : 1;
596 bytes_written = sendmsg (fd.fd, &m, MSG_NOSIGNAL);
598 if (bytes_written < 0 && errno == EINTR)
601 return bytes_written;
605 buffer2, start2, len2);
636 start = _dbus_string_get_length (buffer);
648 bytes_read = read (fd, data, count);
694 data = _dbus_string_get_const_data_len (buffer, start, len);
698 bytes_written = write (fd, data, len);
700 if (bytes_written < 0 && errno == EINTR)
704 if (bytes_written > 0)
708 return bytes_written;
748 struct iovec vectors[2];
753 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
756 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
764 vectors[0].iov_base = (
char*) data1;
765 vectors[0].iov_len = len1;
766 vectors[1].iov_base = (
char*) data2;
767 vectors[1].iov_len = len2;
771 bytes_written = writev (fd,
775 if (bytes_written < 0 && errno == EINTR)
778 return bytes_written;
785 if (ret1 == len1 && buffer2 !=
NULL)
799 #define _DBUS_MAX_SUN_PATH_LENGTH 99 837 struct sockaddr_un addr;
839 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
841 _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
845 if (!_dbus_open_unix_socket (&fd, error))
847 _DBUS_ASSERT_ERROR_IS_SET(error);
850 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
853 addr.sun_family = AF_UNIX;
854 path_len = strlen (path);
858 #ifdef HAVE_ABSTRACT_SOCKETS 859 addr.sun_path[0] =
'\0';
862 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
865 "Abstract socket name too long\n");
870 strncpy (&addr.sun_path[1], path, path_len);
874 "Operating system does not support abstract socket namespace\n");
881 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
884 "Socket name too long\n");
889 strncpy (addr.sun_path, path, path_len);
892 if (connect (fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
896 "Failed to connect to socket %s: %s",
897 path, _dbus_strerror (errno));
903 if (!_dbus_set_fd_nonblocking (fd, error))
905 _DBUS_ASSERT_ERROR_IS_SET (error);
936 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
938 _dbus_verbose (
"connecting to process %s\n", path);
941 retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
942 cloexec_done = (retval >= 0);
944 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
947 retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
954 "Failed to create socket pair: %s",
955 _dbus_strerror (errno));
970 "Failed to fork() to call %s: %s",
971 path, _dbus_strerror (errno));
982 dup2 (fds[1], STDIN_FILENO);
983 dup2 (fds[1], STDOUT_FILENO);
985 if (fds[1] != STDIN_FILENO &&
986 fds[1] != STDOUT_FILENO)
996 fprintf (stderr,
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
1004 if (!_dbus_set_fd_nonblocking (fds[0], error))
1006 _DBUS_ASSERT_ERROR_IS_SET (error);
1038 struct sockaddr_un addr;
1041 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1043 _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
1046 if (!_dbus_open_unix_socket (&listen_fd, error))
1048 _DBUS_ASSERT_ERROR_IS_SET(error);
1051 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1054 addr.sun_family = AF_UNIX;
1055 path_len = strlen (path);
1059 #ifdef HAVE_ABSTRACT_SOCKETS 1063 addr.sun_path[0] =
'\0';
1066 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1069 "Abstract socket name too long\n");
1074 strncpy (&addr.sun_path[1], path, path_len);
1078 "Operating system does not support abstract socket namespace\n");
1098 if (stat (path, &sb) == 0 &&
1099 S_ISSOCK (sb.st_mode))
1103 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1106 "Socket name too long\n");
1111 strncpy (addr.sun_path, path, path_len);
1114 if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
1117 "Failed to bind socket \"%s\": %s",
1118 path, _dbus_strerror (errno));
1123 if (listen (listen_fd, 30 ) < 0)
1126 "Failed to listen on socket \"%s\": %s",
1127 path, _dbus_strerror (errno));
1132 if (!_dbus_set_fd_nonblocking (listen_fd, error))
1134 _DBUS_ASSERT_ERROR_IS_SET (error);
1142 if (!
abstract && chmod (path, 0777) < 0)
1143 _dbus_warn (
"Could not set mode 0777 on socket %s\n",
1168 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1170 n = sd_listen_fds (
TRUE);
1174 "Failed to acquire systemd socket: %s",
1175 _dbus_strerror (-n));
1182 "No socket received.");
1186 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1188 r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1192 "Failed to verify systemd socket type: %s",
1193 _dbus_strerror (-r));
1200 "Passed socket has wrong type.");
1212 "Failed to allocate file handle array.");
1216 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1218 if (!_dbus_set_fd_nonblocking (fd, error))
1220 _DBUS_ASSERT_ERROR_IS_SET (error);
1224 new_fds[fd - SD_LISTEN_FDS_START].fd = fd;
1232 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1241 "dbus was compiled without systemd support");
1265 return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
1269 _dbus_connect_tcp_socket_with_nonce (
const char *host,
1272 const char *noncefile,
1275 int saved_errno = 0;
1278 struct addrinfo hints;
1279 struct addrinfo *ai, *tmp;
1281 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1286 hints.ai_family = AF_UNSPEC;
1287 else if (!strcmp(family,
"ipv4"))
1288 hints.ai_family = AF_INET;
1289 else if (!strcmp(family,
"ipv6"))
1290 hints.ai_family = AF_INET6;
1295 "Unknown address family %s", family);
1296 return _dbus_socket_get_invalid ();
1298 hints.ai_protocol = IPPROTO_TCP;
1299 hints.ai_socktype = SOCK_STREAM;
1300 hints.ai_flags = AI_ADDRCONFIG;
1302 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1306 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1307 host, port, gai_strerror(res), res);
1308 return _dbus_socket_get_invalid ();
1314 if (!_dbus_open_socket (&fd.fd, tmp->ai_family, SOCK_STREAM, 0, error))
1317 _DBUS_ASSERT_ERROR_IS_SET(error);
1318 return _dbus_socket_get_invalid ();
1320 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1322 if (connect (fd.fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1324 saved_errno = errno;
1339 "Failed to connect to socket \"%s:%s\" %s",
1340 host, port, _dbus_strerror(saved_errno));
1341 return _dbus_socket_get_invalid ();
1344 if (noncefile !=
NULL)
1349 ret = _dbus_send_nonce (fd, &noncefileStr, error);
1355 return _dbus_socket_get_invalid ();
1359 if (!_dbus_set_fd_nonblocking (fd.fd, error))
1362 return _dbus_socket_get_invalid ();
1393 int nlisten_fd = 0, res, i;
1395 struct addrinfo hints;
1396 struct addrinfo *ai, *tmp;
1397 unsigned int reuseaddr;
1400 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1405 hints.ai_family = AF_UNSPEC;
1406 else if (!strcmp(family,
"ipv4"))
1407 hints.ai_family = AF_INET;
1408 else if (!strcmp(family,
"ipv6"))
1409 hints.ai_family = AF_INET6;
1414 "Unknown address family %s", family);
1418 hints.ai_protocol = IPPROTO_TCP;
1419 hints.ai_socktype = SOCK_STREAM;
1420 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1422 redo_lookup_with_port:
1424 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1428 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1429 host ? host :
"*", port, gai_strerror(res), res);
1436 int fd = -1, tcp_nodelay_on;
1439 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1441 _DBUS_ASSERT_ERROR_IS_SET(error);
1444 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1447 if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
sizeof(reuseaddr))==-1)
1449 _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
1450 host ? host :
"*", port, _dbus_strerror (errno));
1456 if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay_on,
sizeof (tcp_nodelay_on)) == -1)
1458 _dbus_warn (
"Failed to set TCP_NODELAY socket option \"%s:%s\": %s",
1459 host ? host :
"*", port, _dbus_strerror (errno));
1462 if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1464 saved_errno = errno;
1466 if (saved_errno == EADDRINUSE)
1484 "Failed to bind socket \"%s:%s\": %s",
1485 host ? host :
"*", port, _dbus_strerror (saved_errno));
1489 if (listen (fd, 30 ) < 0)
1491 saved_errno = errno;
1494 "Failed to listen on socket \"%s:%s\": %s",
1495 host ? host :
"*", port, _dbus_strerror (saved_errno));
1502 saved_errno = errno;
1505 "Failed to allocate file handle array: %s",
1506 _dbus_strerror (saved_errno));
1509 listen_fd = newlisten_fd;
1510 listen_fd[nlisten_fd].fd = fd;
1513 if (!_dbus_string_get_length(retport))
1519 if (!port || !strcmp(port,
"0"))
1522 struct sockaddr_storage addr;
1526 addrlen =
sizeof(addr);
1527 result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
1530 (res = getnameinfo ((
struct sockaddr*)&addr, addrlen,
NULL, 0,
1531 portbuf,
sizeof(portbuf),
1532 NI_NUMERICHOST | NI_NUMERICSERV)) != 0)
1535 "Failed to resolve port \"%s:%s\": %s (%s)",
1536 host ? host :
"*", port, gai_strerror(res), res);
1546 port = _dbus_string_get_const_data(retport);
1548 goto redo_lookup_with_port;
1569 "Failed to bind socket \"%s:%s\": %s",
1570 host ? host :
"*", port, _dbus_strerror (errno));
1574 for (i = 0 ; i < nlisten_fd ; i++)
1576 if (!_dbus_set_fd_nonblocking (listen_fd[i].fd, error))
1589 for (i = 0 ; i < nlisten_fd ; i++)
1596 write_credentials_byte (
int server_fd,
1600 char buf[1] = {
'\0' };
1601 #if defined(HAVE_CMSGCRED) 1604 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1615 msg.msg_control = (caddr_t) &cmsg;
1616 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1618 cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
1619 cmsg.hdr.cmsg_level = SOL_SOCKET;
1620 cmsg.hdr.cmsg_type = SCM_CREDS;
1623 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1627 #if defined(HAVE_CMSGCRED) 1628 bytes_written = sendmsg (server_fd, &msg, 0
1629 #
if HAVE_DECL_MSG_NOSIGNAL
1637 if (bytes_written < 0 && errno == EINVAL)
1640 bytes_written = send (server_fd, buf, 1, 0
1641 #
if HAVE_DECL_MSG_NOSIGNAL
1647 if (bytes_written < 0 && errno == EINTR)
1650 if (bytes_written < 0)
1653 "Failed to write credentials byte: %s",
1654 _dbus_strerror (errno));
1657 else if (bytes_written == 0)
1660 "wrote zero bytes writing credentials byte");
1666 _dbus_verbose (
"wrote credentials byte\n");
1673 add_linux_security_label_to_credentials (
int client_fd,
1676 #if defined(__linux__) && defined(SO_PEERSEC) 1678 socklen_t len = 1024;
1685 while (getsockopt (client_fd, SOL_SOCKET, SO_PEERSEC,
1686 _dbus_string_get_data (&buf), &len) < 0)
1690 _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
1691 _dbus_strerror (e), (
unsigned long) len);
1693 if (e != ERANGE || len <= _dbus_string_get_length_uint (&buf))
1695 _dbus_verbose (
"Failed to getsockopt(SO_PEERSEC): %s\n",
1696 _dbus_strerror (e));
1708 _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
1713 _dbus_verbose (
"getsockopt(SO_PEERSEC) yielded <= 0 bytes: %lu\n",
1714 (
unsigned long) len);
1718 if (len > _dbus_string_get_length_uint (&buf))
1720 _dbus_verbose (
"%lu > %u", (
unsigned long) len,
1721 _dbus_string_get_length_uint (&buf));
1725 if (_dbus_string_get_byte (&buf, len - 1) == 0)
1729 _dbus_verbose (
"subtracting trailing \\0\n");
1740 if (strlen (_dbus_string_get_const_data (&buf)) != len)
1745 _dbus_verbose (
"security label from kernel had an embedded \\0, " 1750 _dbus_verbose (
"getsockopt(SO_PEERSEC): %lu bytes excluding \\0: %s\n",
1751 (
unsigned long) len,
1752 _dbus_string_get_const_data (&buf));
1755 _dbus_string_get_const_data (&buf)))
1822 #ifdef HAVE_CMSGCRED 1825 char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
1833 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
1834 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
1835 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
1840 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1844 iov.iov_base = &buf;
1851 #if defined(HAVE_CMSGCRED) 1853 msg.msg_control = (caddr_t) &cmsg;
1854 msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
1858 bytes_read = recvmsg (client_fd.fd, &msg, 0);
1871 "Failed to read credentials byte: %s",
1872 _dbus_strerror (errno));
1875 else if (bytes_read == 0)
1881 "Failed to read credentials byte (zero-length read)");
1884 else if (buf !=
'\0')
1887 "Credentials byte was not nul");
1891 _dbus_verbose (
"read credentials byte\n");
1904 struct sockpeercred cr;
1908 int cr_len =
sizeof (cr);
1910 if (getsockopt (client_fd.fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) != 0)
1912 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED): %s\n",
1913 _dbus_strerror (errno));
1915 else if (cr_len !=
sizeof (cr))
1917 _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED), returned %d bytes, expected %d\n",
1918 cr_len, (
int)
sizeof (cr));
1925 #elif defined(HAVE_UNPCBID) && defined(LOCAL_PEEREID) 1929 socklen_t cr_len =
sizeof (cr);
1931 if (getsockopt (client_fd.fd, 0, LOCAL_PEEREID, &cr, &cr_len) != 0)
1933 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID): %s\n",
1934 _dbus_strerror (errno));
1936 else if (cr_len !=
sizeof (cr))
1938 _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID), returned %d bytes, expected %d\n",
1939 cr_len, (
int)
sizeof (cr));
1943 pid_read = cr.unp_pid;
1944 uid_read = cr.unp_euid;
1946 #elif defined(HAVE_CMSGCRED) 1955 struct cmsgcred *cred;
1956 struct cmsghdr *cmsgp;
1958 for (cmsgp = CMSG_FIRSTHDR (&msg);
1960 cmsgp = CMSG_NXTHDR (&msg, cmsgp))
1962 if (cmsgp->cmsg_type == SCM_CREDS &&
1963 cmsgp->cmsg_level == SOL_SOCKET &&
1964 cmsgp->cmsg_len >= CMSG_LEN (
sizeof (
struct cmsgcred)))
1966 cred = (
struct cmsgcred *) CMSG_DATA (cmsgp);
1967 pid_read = cred->cmcred_pid;
1968 uid_read = cred->cmcred_euid;
1973 #elif defined(HAVE_GETPEERUCRED) 1977 ucred_t * ucred =
NULL;
1978 if (getpeerucred (client_fd.fd, &ucred) == 0)
1980 pid_read = ucred_getpid (ucred);
1981 uid_read = ucred_geteuid (ucred);
1984 adt_session_data_t *adth =
NULL;
1985 adt_export_data_t *data =
NULL;
1987 if (adt_start_session (&adth,
NULL, 0) || (adth ==
NULL))
1989 _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
1993 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
1995 _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
1999 size = adt_export_session_data (adth, &data);
2002 _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
2010 (void) adt_end_session (adth);
2016 _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
2026 #elif defined(HAVE_GETPEEREID) 2044 if (getpeereid (client_fd.fd, &euid, &egid) == 0)
2050 _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
2054 #warning Socket credentials not supported on this Unix OS 2055 #warning Please tell https://bugs.freedesktop.org/enter_bug.cgi?product=DBus 2061 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \ 2062 defined(__linux__) || \ 2063 defined(__OpenBSD__) || \ 2065 # error Credentials passing not working on this OS is a regression! 2068 _dbus_verbose (
"Socket credentials not supported on this OS\n");
2072 _dbus_verbose (
"Credentials:" 2083 _DBUS_SET_OOM (error);
2092 _DBUS_SET_OOM (error);
2097 if (!add_linux_security_label_to_credentials (client_fd.fd, credentials))
2099 _DBUS_SET_OOM (error);
2127 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2129 if (write_credentials_byte (server_fd.fd, error))
2148 struct sockaddr addr;
2154 addrlen =
sizeof (addr);
2164 client_fd.fd = accept4 (listen_fd.fd, &addr, &addrlen, SOCK_CLOEXEC);
2165 cloexec_done = client_fd.fd >= 0;
2167 if (client_fd.fd < 0 && (errno == ENOSYS || errno == EINVAL))
2170 client_fd.fd = accept (listen_fd.fd, &addr, &addrlen);
2173 if (client_fd.fd < 0)
2179 _dbus_verbose (
"client fd %d accepted\n", client_fd.fd);
2202 const char *directory;
2205 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2207 directory = _dbus_string_get_const_data (dir);
2209 if (stat (directory, &sb) < 0)
2212 "%s", _dbus_strerror (errno));
2217 if (sb.st_uid != geteuid ())
2220 "%s directory is owned by user %lu, not %lu",
2222 (
unsigned long) sb.st_uid,
2223 (
unsigned long) geteuid ());
2227 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
2228 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
2231 "%s directory is not private to the user", directory);
2239 fill_user_info_from_passwd (
struct passwd *p,
2246 info->
uid = p->pw_uid;
2267 const char *username_c;
2280 if (username !=
NULL)
2281 username_c = _dbus_string_get_const_data (username);
2290 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R) 2296 struct passwd p_str;
2299 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
2305 if ((
long) buflen <= 0)
2319 #ifdef HAVE_POSIX_GETPWNAM_R 2321 result = getpwuid_r (uid, &p_str, buf, buflen,
2324 result = getpwnam_r (username_c, &p_str, buf, buflen,
2328 p = getpwuid_r (uid, &p_str, buf, buflen);
2330 p = getpwnam_r (username_c, &p_str, buf, buflen);
2334 if (result == ERANGE && buflen < 512 * 1024)
2344 if (result == 0 && p == &p_str)
2346 if (!fill_user_info_from_passwd (p, info, error))
2356 "User \"%s\" unknown or no memory to allocate password entry\n",
2357 username_c ? username_c :
"???");
2358 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2371 p = getpwnam (username_c);
2375 if (!fill_user_info_from_passwd (p, info, error))
2383 "User \"%s\" unknown or no memory to allocate password entry\n",
2384 username_c ? username_c :
"???");
2385 _dbus_verbose (
"User %s unknown\n", username_c ? username_c :
"???");
2394 #ifdef HAVE_GETGROUPLIST 2399 int initial_buf_count;
2401 initial_buf_count = 17;
2402 buf_count = initial_buf_count;
2410 if (getgrouplist (username_c,
2412 buf, &buf_count) < 0)
2428 if (buf_count == initial_buf_count)
2443 if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
2447 _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2448 username_c, buf_count, buf_count);
2454 "Failed to get groups for username \"%s\" primary GID " 2457 _dbus_strerror (errno));
2472 for (i = 0; i < buf_count; ++i)
2495 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2500 _DBUS_ASSERT_ERROR_IS_SET (error);
2534 return fill_user_info (info, uid,
2552 _DBUS_STATIC_ASSERT (
sizeof (pid_t) <=
sizeof (
dbus_pid_t));
2553 _DBUS_STATIC_ASSERT (
sizeof (uid_t) <=
sizeof (
dbus_uid_t));
2554 _DBUS_STATIC_ASSERT (
sizeof (gid_t) <=
sizeof (
dbus_gid_t));
2636 if (_dbus_string_get_length (uid_str) == 0)
2638 _dbus_verbose (
"UID string was zero length\n");
2647 _dbus_verbose (
"could not parse string as a UID\n");
2651 if (end != _dbus_string_get_length (uid_str))
2653 _dbus_verbose (
"string contained trailing stuff after UID\n");
2668 static pthread_mutex_t atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
2681 return __sync_add_and_fetch(&atomic->
value, 1)-1;
2685 pthread_mutex_lock (&atomic_mutex);
2686 res = atomic->
value;
2688 pthread_mutex_unlock (&atomic_mutex);
2704 return __sync_sub_and_fetch(&atomic->
value, 1)+1;
2708 pthread_mutex_lock (&atomic_mutex);
2709 res = atomic->
value;
2711 pthread_mutex_unlock (&atomic_mutex);
2728 __sync_synchronize ();
2729 return atomic->
value;
2733 pthread_mutex_lock (&atomic_mutex);
2734 res = atomic->
value;
2735 pthread_mutex_unlock (&atomic_mutex);
2752 int timeout_milliseconds)
2754 #if defined(HAVE_POLL) && !defined(BROKEN_POLL) 2756 if (timeout_milliseconds < -1)
2758 timeout_milliseconds = -1;
2763 timeout_milliseconds);
2766 fd_set read_set, write_set, err_set;
2772 FD_ZERO (&read_set);
2773 FD_ZERO (&write_set);
2776 for (i = 0; i < n_fds; i++)
2781 FD_SET (fdp->
fd, &read_set);
2784 FD_SET (fdp->
fd, &write_set);
2786 FD_SET (fdp->
fd, &err_set);
2788 max_fd = MAX (max_fd, fdp->
fd);
2791 tv.tv_sec = timeout_milliseconds / 1000;
2792 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
2794 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
2795 timeout_milliseconds < 0 ?
NULL : &tv);
2799 for (i = 0; i < n_fds; i++)
2805 if (FD_ISSET (fdp->
fd, &read_set))
2808 if (FD_ISSET (fdp->
fd, &write_set))
2811 if (FD_ISSET (fdp->
fd, &err_set))
2831 #ifdef HAVE_MONOTONIC_CLOCK 2833 clock_gettime (CLOCK_MONOTONIC, &ts);
2836 *tv_sec = ts.tv_sec;
2838 *tv_usec = ts.tv_nsec / 1000;
2842 gettimeofday (&t,
NULL);
2847 *tv_usec = t.tv_usec;
2864 gettimeofday (&t,
NULL);
2869 *tv_usec = t.tv_usec;
2884 const char *filename_c;
2886 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2888 filename_c = _dbus_string_get_const_data (filename);
2890 if (mkdir (filename_c, 0700) < 0)
2892 if (errno == EEXIST)
2896 "Failed to create directory %s: %s\n",
2897 filename_c, _dbus_strerror (errno));
2921 if (_dbus_string_get_length (dir) == 0 ||
2922 _dbus_string_get_length (next_component) == 0)
2925 dir_ends_in_slash =
'/' == _dbus_string_get_byte (dir,
2926 _dbus_string_get_length (dir) - 1);
2928 file_starts_with_slash =
'/' == _dbus_string_get_byte (next_component, 0);
2930 if (dir_ends_in_slash && file_starts_with_slash)
2934 else if (!(dir_ends_in_slash || file_starts_with_slash))
2941 _dbus_string_get_length (dir));
2945 #define NANOSECONDS_PER_SECOND 1000000000 2947 #define MICROSECONDS_PER_SECOND 1000000 2949 #define MILLISECONDS_PER_SECOND 1000 2951 #define NANOSECONDS_PER_MILLISECOND 1000000 2953 #define MICROSECONDS_PER_MILLISECOND 1000 2962 #ifdef HAVE_NANOSLEEP 2963 struct timespec req;
2964 struct timespec rem;
2966 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
2967 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
2971 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
2973 #elif defined (HAVE_USLEEP) 2974 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
2976 sleep (MAX (milliseconds / 1000, 1));
2998 old_len = _dbus_string_get_length (str);
3002 fd = open (
"/dev/urandom", O_RDONLY);
3007 "Could not open /dev/urandom: %s",
3008 _dbus_strerror (errno));
3012 _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
3016 if (result != n_bytes)
3020 "Could not read /dev/urandom: %s",
3021 _dbus_strerror (errno));
3024 "Short read from /dev/urandom");
3031 _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
3059 _dbus_strerror (
int error_number)
3063 msg = strerror (error_number);
3076 signal (SIGPIPE, SIG_IGN);
3091 val = fcntl (fd, F_GETFD, 0);
3098 fcntl (fd, F_SETFD, val);
3112 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3121 "Could not close fd %d", fd);
3142 #ifdef F_DUPFD_CLOEXEC 3145 new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
3146 cloexec_done = new_fd >= 0;
3148 if (new_fd < 0 && errno == EINVAL)
3151 new_fd = fcntl(fd, F_DUPFD, 3);
3157 "Could not duplicate fd %d", fd);
3161 #ifdef F_DUPFD_CLOEXEC 3182 return _dbus_set_fd_nonblocking (fd.fd, error);
3186 _dbus_set_fd_nonblocking (
int fd,
3191 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3193 val = fcntl (fd, F_GETFL, 0);
3197 "Failed to get flags from file descriptor %d: %s",
3198 fd, _dbus_strerror (errno));
3199 _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
3200 _dbus_strerror (errno));
3204 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
3207 "Failed to set nonblocking flag of file descriptor %d: %s",
3208 fd, _dbus_strerror (errno));
3209 _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
3210 fd, _dbus_strerror (errno));
3226 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC) 3232 bt_size = backtrace (bt, 500);
3234 syms = backtrace_symbols (bt, bt_size);
3240 fprintf (stderr,
" %s\n", syms[i]);
3246 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC) 3247 fprintf (stderr,
" D-Bus not built with -rdynamic so unable to print a backtrace\n");
3249 fprintf (stderr,
" D-Bus not compiled with backtrace support so unable to print a backtrace\n");
3271 #ifdef HAVE_SOCKETPAIR 3278 retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
3279 cloexec_done = retval >= 0;
3281 if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
3284 retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
3290 "Could not create full-duplex pipe");
3294 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3305 (!_dbus_set_fd_nonblocking (fds[0],
NULL) ||
3306 !_dbus_set_fd_nonblocking (fds[1],
NULL)))
3309 "Could not set full-duplex pipe nonblocking");
3320 _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
3325 _dbus_warn (
"_dbus_socketpair() not implemented on this OS\n");
3327 "_dbus_socketpair() not implemented on this OS");
3344 char static_buf[1024];
3345 int bufsize =
sizeof (static_buf);
3349 DBUS_VA_COPY (args_copy, args);
3350 len = vsnprintf (static_buf, bufsize, format, args_copy);
3367 DBUS_VA_COPY (args_copy, args);
3369 if (vsnprintf (static_buf, 1, format, args_copy) == 1)
3388 DBUS_VA_COPY (args_copy, args);
3389 len = vsnprintf (buf, bufsize, format, args_copy);
3414 static const char* tmpdir =
NULL;
3426 tmpdir = getenv(
"TMPDIR");
3432 tmpdir = getenv(
"TMP");
3434 tmpdir = getenv(
"TEMP");
3448 #if defined(DBUS_ENABLE_X11_AUTOLAUNCH) || defined(DBUS_ENABLE_LAUNCHD) 3469 _read_subprocess_line_argv (
const char *progpath,
3475 int result_pipe[2] = { -1, -1 };
3476 int errors_pipe[2] = { -1, -1 };
3483 sigset_t new_set, old_set;
3485 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3492 sigemptyset (&new_set);
3493 sigaddset (&new_set, SIGCHLD);
3494 sigprocmask (SIG_BLOCK, &new_set, &old_set);
3496 orig_len = _dbus_string_get_length (result);
3500 if (pipe (result_pipe) < 0)
3503 "Failed to create a pipe to call %s: %s",
3504 progpath, _dbus_strerror (errno));
3505 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3506 progpath, _dbus_strerror (errno));
3509 if (pipe (errors_pipe) < 0)
3512 "Failed to create a pipe to call %s: %s",
3513 progpath, _dbus_strerror (errno));
3514 _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
3515 progpath, _dbus_strerror (errno));
3523 "Failed to fork() to call %s: %s",
3524 progpath, _dbus_strerror (errno));
3525 _dbus_verbose (
"Failed to fork() to call %s: %s\n",
3526 progpath, _dbus_strerror (errno));
3535 fd = open (
"/dev/null", O_RDWR);
3540 _dbus_verbose (
"/dev/null fd %d opened\n", fd);
3544 close (errors_pipe[READ_END]);
3546 if (dup2 (fd, 0) == -1)
3548 if (dup2 (result_pipe[
WRITE_END], 1) == -1)
3550 if (dup2 (errors_pipe[WRITE_END], 2) == -1)
3555 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3558 if (progpath[0] ==
'/')
3560 execv (progpath, argv);
3569 execvp (strrchr (progpath,
'/')+1, argv);
3572 execvp (progpath, argv);
3580 close (errors_pipe[WRITE_END]);
3594 ret = waitpid (pid, &status, 0);
3596 while (ret == -1 && errno == EINTR);
3600 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
3606 _DBUS_SET_OOM (error);
3618 if (_dbus_string_get_length (&error_message) > 0)
3620 "%s terminated abnormally with the following error: %s",
3621 progpath, _dbus_string_get_data (&error_message));
3624 "%s terminated abnormally without any error message",
3632 sigprocmask (SIG_SETMASK, &old_set,
NULL);
3635 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3637 _DBUS_ASSERT_ERROR_IS_SET (error);
3639 if (result_pipe[0] != -1)
3640 close (result_pipe[0]);
3641 if (result_pipe[1] != -1)
3642 close (result_pipe[1]);
3643 if (errors_pipe[0] != -1)
3644 close (errors_pipe[0]);
3645 if (errors_pipe[1] != -1)
3646 close (errors_pipe[1]);
3669 #ifdef DBUS_ENABLE_X11_AUTOLAUNCH 3673 const char *display;
3683 "Unable to autolaunch when setuid");
3687 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3700 if (display ==
NULL || display[0] ==
'\0')
3703 "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
3709 _DBUS_SET_OOM (error);
3718 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 3720 progpath = TEST_BUS_LAUNCH_BINARY;
3723 progpath = DBUS_BINDIR
"/dbus-launch";
3730 argv[i] =
"dbus-launch";
3732 argv[i] =
"--autolaunch";
3734 argv[i] = _dbus_string_get_data (&uuid);
3736 argv[i] =
"--binary-syntax";
3738 argv[i] =
"--close-stderr";
3745 retval = _read_subprocess_line_argv (progpath,
3747 argv, address, error);
3754 "Using X11 for dbus-daemon autolaunch was disabled at compile time, " 3755 "set your DBUS_SESSION_BUS_ADDRESS instead");
3808 if (!create_if_not_found)
3830 const char *launchd_env_var,
3833 #ifdef DBUS_ENABLE_LAUNCHD 3837 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3842 "Unable to find launchd socket when setuid");
3847 argv[i] =
"launchctl";
3851 argv[i] = (
char*)launchd_env_var;
3858 if (!_read_subprocess_line_argv(argv[0],
TRUE, argv, socket_path, error))
3864 if (_dbus_string_get_length(socket_path) == 0)
3874 "can't lookup socket from launchd; launchd support not compiled in");
3879 #ifdef DBUS_ENABLE_LAUNCHD 3889 "Unable to find launchd socket when setuid");
3895 _DBUS_SET_OOM (error);
3910 "launchd did not provide a socket path, " 3911 "verify that org.freedesktop.dbus-session.plist is loaded!");
3917 _DBUS_SET_OOM (error);
3922 _dbus_string_get_length (address)))
3924 _DBUS_SET_OOM (error);
3939 const char *runtime_dir =
_dbus_getenv (
"XDG_RUNTIME_DIR");
3944 if (runtime_dir ==
NULL)
3946 _dbus_verbose (
"XDG_RUNTIME_DIR not found in environment");
3953 _DBUS_SET_OOM (error);
3959 _DBUS_SET_OOM (error);
3963 if (lstat (_dbus_string_get_const_data (&user_bus_path), &stbuf) == -1)
3965 _dbus_verbose (
"XDG_RUNTIME_DIR/bus not available: %s",
3966 _dbus_strerror (errno));
3972 if (stbuf.st_uid != getuid ())
3974 _dbus_verbose (
"XDG_RUNTIME_DIR/bus owned by uid %ld, not our uid %ld",
3975 (
long) stbuf.st_uid, (
long) getuid ());
3981 if ((stbuf.st_mode & S_IFMT) != S_IFSOCK)
3983 _dbus_verbose (
"XDG_RUNTIME_DIR/bus is not a socket: st_mode = 0o%lo",
3984 (
long) stbuf.st_mode);
3993 _DBUS_SET_OOM (error);
4029 #ifdef DBUS_ENABLE_LAUNCHD 4031 return _dbus_lookup_session_address_launchd (address, error);
4035 if (!_dbus_lookup_user_bus (supported, address, error))
4037 else if (*supported)
4095 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 4097 const char *
override;
4100 if (
override !=
NULL && *
override !=
'\0')
4106 _dbus_verbose (
"Using fake homedir for testing: %s\n",
4107 _dbus_string_get_const_data (&homedir));
4114 if (!already_warned)
4116 _dbus_warn (
"Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid\n");
4117 already_warned =
TRUE;
4129 directory, _dbus_string_get_length (directory))) {
4143 _dbus_daemon_publish_session_bus_address (
const char* addr,
4151 _dbus_daemon_unpublish_session_bus_address (
void)
4165 return e == EAGAIN || e == EWOULDBLOCK;
4179 const char *filename_c;
4181 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4183 filename_c = _dbus_string_get_const_data (filename);
4185 if (rmdir (filename_c) != 0)
4188 "Failed to remove directory %s: %s\n",
4189 filename_c, _dbus_strerror (errno));
4209 struct sockaddr_storage storage;
4210 struct sockaddr_un un;
4213 socklen_t sa_len =
sizeof(sa_buf);
4217 if (getsockname(fd.fd, &sa_buf.sa, &sa_len) < 0)
4220 return sa_buf.sa.sa_family == AF_UNIX;
4243 d = opendir (
"/proc/self/fd");
4248 struct dirent buf, *de;
4253 k = readdir_r (d, &buf, &de);
4257 if (de->d_name[0] ==
'.')
4261 l = strtol (de->d_name, &e, 10);
4262 if (errno != 0 || e ==
NULL || *e !=
'\0')
4269 if (fd == dirfd (d))
4280 maxfds = sysconf (_SC_OPEN_MAX);
4289 for (i = 3; i < maxfds; i++)
4308 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE) 4311 extern int __libc_enable_secure;
4312 return __libc_enable_secure;
4314 #elif defined(HAVE_ISSETUGID) 4316 return issetugid ();
4318 uid_t ruid, euid, suid;
4319 gid_t rgid, egid, sgid;
4326 if (_DBUS_UNLIKELY (!check_setuid_initialised))
4328 #ifdef HAVE_GETRESUID 4329 if (getresuid (&ruid, &euid, &suid) != 0 ||
4330 getresgid (&rgid, &egid, &sgid) != 0)
4333 suid = ruid = getuid ();
4334 sgid = rgid = getgid ();
4339 check_setuid_initialised =
TRUE;
4340 is_setuid = (ruid != euid || ruid != suid ||
4341 rgid != egid || rgid != sgid);
4362 struct sockaddr_storage storage;
4363 struct sockaddr_un un;
4364 struct sockaddr_in ipv4;
4365 struct sockaddr_in6 ipv6;
4367 char hostip[INET6_ADDRSTRLEN];
4368 int size =
sizeof (socket);
4371 if (getsockname (fd.fd, &socket.sa, &size))
4374 switch (socket.sa.sa_family)
4377 if (socket.un.sun_path[0]==
'\0')
4393 if (inet_ntop (AF_INET, &socket.ipv4.sin_addr, hostip, sizeof (hostip)))
4395 hostip, ntohs (socket.ipv4.sin_port)))
4401 if (inet_ntop (AF_INET6, &socket.ipv6.sin6_addr, hostip, sizeof (hostip)))
4403 ntohs (socket.ipv6.sin6_port)) &&
4411 "Failed to read address from socket: Unknown socket type.");
4417 "Failed to open socket: %s",
4418 _dbus_strerror (errno));
4423 _dbus_save_socket_errno (
void)
4429 _dbus_restore_socket_errno (
int saved_errno)
4431 errno = saved_errno;
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
DBUS_PRIVATE_EXPORT 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_PRIVATE_EXPORT 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++.
#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.
void _dbus_close_all(void)
Closes all file descriptors except the first three (i.e.
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_socketpair(DBusSocket *fd1, DBusSocket *fd2, dbus_bool_t blocking, DBusError *error)
Creates pair of connect sockets (as in socketpair()).
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
dbus_bool_t _dbus_generate_uuid(DBusGUID *uuid, DBusError *error)
Generates a new UUID.
dbus_bool_t _dbus_get_local_machine_uuid_encoded(DBusString *uuid_str, DBusError *error)
Gets the hex-encoded UUID of the machine this function is executed on.
dbus_bool_t _dbus_append_address_from_socket(DBusSocket fd, DBusString *address, DBusError *error)
Read the address from the socket and append it to the string.
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_gid_t primary_gid
GID.
dbus_bool_t _dbus_credentials_add_linux_security_label(DBusCredentials *credentials, const char *label)
Add a Linux security label, as used by LSMs such as SELinux, Smack and AppArmor, to the credentials...
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...
dbus_pid_t _dbus_getpid(void)
Gets our process ID.
#define _DBUS_POLLIN
There is data to read.
dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory.
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
int _dbus_read_socket(DBusSocket fd, DBusString *buffer, int count)
Like _dbus_read(), but only works on sockets so is available on Windows.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
#define DBUS_ERROR_IO_ERROR
Something went wrong reading or writing to a socket, for example.
int _dbus_dup(int fd, DBusError *error)
Duplicates a file descriptor.
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...
#define DBUS_PID_UNSET
an invalid PID used to represent an uninitialized dbus_pid_t field
dbus_bool_t _dbus_send_credentials_socket(DBusSocket server_fd, DBusError *error)
Sends a single nul byte with our UNIX credentials as ancillary data.
dbus_bool_t _dbus_close_socket(DBusSocket fd, DBusError *error)
Closes a socket.
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.
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.
unsigned long dbus_pid_t
A process ID.
int _dbus_read_socket_with_unix_fds(DBusSocket fd, DBusString *buffer, int count, int *fds, int *n_fds)
Like _dbus_read_socket() but also tries to read unix fds from the socket.
dbus_gid_t * group_ids
Groups IDs, including above primary group.
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
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_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
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...
dbus_bool_t _dbus_credentials_are_anonymous(DBusCredentials *credentials)
Checks whether a credentials object contains a user identity.
dbus_bool_t _dbus_get_is_errno_eagain_or_ewouldblock(int e)
See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently for Winsock so is abstracted) ...
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.
int n_group_ids
Size of group IDs array.
int _dbus_listen_systemd_sockets(DBusSocket **fds, DBusError *error)
Acquires one or more sockets passed in from systemd.
#define _DBUS_POLLOUT
Writing now will not block.
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
int _dbus_write_socket_two(DBusSocket 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.
DBusSocket _dbus_accept(DBusSocket listen_fd)
Accepts a connection on a listening socket.
dbus_bool_t _dbus_string_init_preallocated(DBusString *str, int allocate_size)
Initializes a string that can be up to the given allocation size before it has to realloc...
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_string_append_printf(DBusString *str, const char *format,...)
Appends a printf-style formatted string to the DBusString.
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.
dbus_bool_t _dbus_read_credentials_socket(DBusSocket client_fd, DBusCredentials *credentials, DBusError *error)
Reads a single byte which must be nul (an error occurs otherwise), and reads unix credentials if avai...
dbus_bool_t _dbus_create_directory(const DBusString *filename, DBusError *error)
Creates a directory; succeeds if the directory is created or already existed.
dbus_bool_t _dbus_delete_directory(const DBusString *filename, DBusError *error)
Removes a directory; Directory must be empty.
Object representing an exception.
dbus_bool_t _dbus_address_append_escaped(DBusString *escaped, const DBusString *unescaped)
Appends an escaped version of one string to another string, using the D-Bus address escaping mechanis...
void _dbus_get_monotonic_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
int _dbus_listen_tcp_socket(const char *host, const char *port, const char *family, DBusString *retport, DBusSocket **fds_p, DBusError *error)
Creates a socket and binds it to the given path, then listens on the socket.
void _dbus_disable_sigpipe(void)
signal (SIGPIPE, SIG_IGN);
#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().
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
void _dbus_flush_caches(void)
Called when the bus daemon is signaled to reload its configuration; any caches should be nuked...
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. ...
const char * _dbus_get_tmpdir(void)
Gets the temporary files directory by inspecting the environment variables TMPDIR, TMP, and TEMP in that order.
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.
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_uid_t _dbus_geteuid(void)
Gets our effective UID.
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".
DBusPollable fd
File descriptor.
dbus_bool_t _dbus_credentials_add_pid(DBusCredentials *credentials, dbus_pid_t pid)
Add a UNIX process ID to the credentials.
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
#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.
void _dbus_exit(int code)
Exit the process, returning the given value.
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_fd_set_close_on_exec(int fd)
Sets the file descriptor to be close on exec.
DBusSocket _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.
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
dbus_uid_t _dbus_getuid(void)
Gets our UID.
dbus_bool_t _dbus_generate_random_bytes(DBusString *str, int n_bytes, DBusError *error)
Generates the given number of securely random bytes, using the best mechanism we can come up with...
dbus_bool_t _dbus_user_info_fill_uid(DBusUserInfo *info, dbus_uid_t uid, DBusError *error)
Gets user info for the given user ID.
dbus_bool_t _dbus_set_socket_nonblocking(DBusSocket fd, DBusError *error)
Sets a file descriptor to be nonblocking.
#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_close(int fd, DBusError *error)
Closes a file descriptor.
#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.
dbus_bool_t _dbus_write_uuid_file(const DBusString *filename, const DBusGUID *uuid, DBusError *error)
Write the give UUID to a file.
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.
int _dbus_write_socket(DBusSocket fd, const DBusString *buffer, int start, int len)
Like _dbus_write(), but only supports sockets and is thus available on Windows.
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.
void _dbus_sleep_milliseconds(int milliseconds)
Sleeps the given number of milliseconds.
DBUS_PRIVATE_EXPORT void _dbus_verbose_bytes_of_string(const DBusString *str, int start, int len)
Dump the given part of the string to verbose log.
#define WRITE_END
Helps remember which end of the pipe is which.
unsigned long dbus_gid_t
A group ID.
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...
int dbus_int32_t
A 32-bit signed integer on all platforms.
char * _dbus_strdup(const char *str)
Duplicates a string.
#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_socket_can_pass_unix_fd(DBusSocket fd)
Checks whether file descriptors may be passed via the socket.
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
unsigned long dbus_uid_t
A user ID.
int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll().
short revents
Events that occurred.
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.
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary.
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.
void _dbus_get_real_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
Information about a UNIX user.
#define _DBUS_POLLERR
Error condition.