29#include "dbus-internals.h" 
   30#include "dbus-sysdeps.h" 
   31#include "dbus-sysdeps-unix.h" 
   32#include "dbus-threads.h" 
   33#include "dbus-protocol.h" 
   35#include "dbus-transport.h" 
   36#include "dbus-string.h" 
   37#include "dbus-userdb.h" 
   39#include "dbus-credentials.h" 
   40#include "dbus-nonce.h" 
   50#include <sys/socket.h> 
   59#include <netinet/in.h> 
   60#include <netinet/tcp.h> 
   68#ifdef HAVE_LINUX_CLOSE_RANGE_H 
   69#include <linux/close_range.h> 
   80#ifdef HAVE_GETPEERUCRED 
   86#ifdef HAVE_SYS_RANDOM_H 
   87#include <sys/random.h> 
   89#ifdef HAVE_SYS_SYSCALL_H 
   90#include <sys/syscall.h> 
   98#include <systemd/sd-daemon.h> 
  101#if !defined(HAVE_STDATOMIC_H) && !DBUS_USE_SYNC 
  110#define AI_ADDRCONFIG 0 
  113#ifndef HAVE_SOCKLEN_T 
  117#if defined (__sun) || defined (__sun__) 
  130#     define CMSG_ALIGN(len) _CMSG_DATA_ALIGN (len) 
  133#     define CMSG_ALIGN(len) (((len) + sizeof (long) - 1) & \ 
  134                              ~(sizeof (long) - 1)) 
  139#   define CMSG_SPACE(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + \ 
  144#   define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len)) 
  149#if defined(__linux__) && defined(__NR_close_range) && !defined(HAVE_CLOSE_RANGE) 
  154close_range (
unsigned int first,
 
  158  return syscall (__NR_close_range, first, last, flags);
 
  161#define HAVE_CLOSE_RANGE 
  180                           const char                 **error_str_p)
 
  182  static int const relevant_flag[] = { DBUS_FORCE_STDIN_NULL,
 
  183      DBUS_FORCE_STDOUT_NULL,
 
  184      DBUS_FORCE_STDERR_NULL };
 
  186  const char *error_str = 
"Failed mysteriously";
 
  190  _DBUS_STATIC_ASSERT (STDIN_FILENO == 0);
 
  191  _DBUS_STATIC_ASSERT (STDOUT_FILENO == 1);
 
  192  _DBUS_STATIC_ASSERT (STDERR_FILENO == 2);
 
  195  for (i = STDIN_FILENO; i <= STDERR_FILENO; i++)
 
  201        devnull = open (
"/dev/null", O_RDWR);
 
  205          error_str = 
"Failed to open /dev/null";
 
  214      if (devnull != i && (flags & relevant_flag[i]) != 0)
 
  216          if (dup2 (devnull, i) < 0)
 
  218              error_str = 
"Failed to dup2 /dev/null onto a standard fd";
 
  229  if (devnull > STDERR_FILENO)
 
  232  if (error_str_p != 
NULL)
 
  233    *error_str_p = error_str;
 
  236  return (error_str == 
NULL);
 
 
  239static dbus_bool_t _dbus_set_fd_nonblocking (
int             fd,
 
  243_dbus_open_socket (
int              *fd_p,
 
  252  *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
 
  253  cloexec_done = *fd_p >= 0;
 
  256  if (*fd_p < 0 && (errno == EINVAL || errno == EPROTOTYPE))
 
  259      *fd_p = socket (domain, type, protocol);
 
  271      _dbus_verbose (
"socket fd %d opened\n", *fd_p);
 
  278                     "Failed to open socket: %s",
 
  279                     _dbus_strerror (errno));
 
  295_dbus_open_unix_socket (
int              *fd,
 
  298  return _dbus_open_socket(fd, AF_UNIX, SOCK_STREAM, 0, error);
 
  320  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
  323  _dbus_socket_invalidate (fd);
 
 
  361#if HAVE_DECL_MSG_NOSIGNAL 
  365  data = _dbus_string_get_const_data_len (buffer, start, len);
 
  369  bytes_written = send (fd.fd, data, len, MSG_NOSIGNAL);
 
  371  if (bytes_written < 0 && errno == EINTR)
 
  374  return bytes_written;
 
 
  398                                 unsigned int     *n_fds) {
 
  399#ifndef HAVE_UNIX_FD_PASSING 
  417  start = _dbus_string_get_length (buffer);
 
  437  m.msg_controllen = CMSG_SPACE(*n_fds * 
sizeof(
int));
 
  441  m.msg_control = alloca(m.msg_controllen);
 
  442  memset(m.msg_control, 0, m.msg_controllen);
 
  448  m.msg_controllen = CMSG_LEN (*n_fds * 
sizeof(
int));
 
  452  bytes_read = recvmsg (fd.fd, &m, 0
 
  453#ifdef MSG_CMSG_CLOEXEC
 
  474      for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
 
  475        if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
 
  478            int *payload = (
int *) (
void *) CMSG_DATA (cm);
 
  479            size_t payload_len_bytes = (cm->cmsg_len - CMSG_LEN (0));
 
  480            size_t payload_len_fds;
 
  485            _DBUS_STATIC_ASSERT (
sizeof (
size_t) >= 
sizeof (
unsigned int));
 
  487            if ((m.msg_flags & MSG_CTRUNC) && CMSG_NXTHDR(&m, cm) == 
NULL &&
 
  488              (
char *) payload + payload_len_bytes >
 
  489              (
char *) m.msg_control + m.msg_controllen)
 
  500                 payload_len_bytes = m.msg_controllen -
 
  501                   ((
char *) payload - (
char *) m.msg_control);
 
  504            payload_len_fds = payload_len_bytes / 
sizeof (int);
 
  506            if (_DBUS_LIKELY (payload_len_fds <= (
size_t) *n_fds))
 
  509                fds_to_use = payload_len_fds;
 
  517                fds_to_use = (size_t) *n_fds;
 
  522                for (i = fds_to_use; i < payload_len_fds; i++)
 
  528            memcpy (fds, payload, fds_to_use * 
sizeof (
int));
 
  533            *n_fds = (
unsigned int) fds_to_use;
 
  538            for (i = 0; i < fds_to_use; i++)
 
  547      if (m.msg_flags & MSG_CTRUNC)
 
  558          for (i = 0; i < *n_fds; i++)
 
 
  581_dbus_write_socket_with_unix_fds(
DBusSocket        fd,
 
  588#ifndef HAVE_UNIX_FD_PASSING 
  597  return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len, 
NULL, 0, 0, fds, n_fds);
 
  602_dbus_write_socket_with_unix_fds_two(
DBusSocket        fd,
 
  612#ifndef HAVE_UNIX_FD_PASSING 
  620                                buffer1, start1, len1,
 
  621                                buffer2, start2, len2);
 
  634  iov[0].iov_base = (
char*) _dbus_string_get_const_data_len (buffer1, start1, len1);
 
  635  iov[0].iov_len = len1;
 
  639      iov[1].iov_base = (
char*) _dbus_string_get_const_data_len (buffer2, start2, len2);
 
  640      iov[1].iov_len = len2;
 
  645  m.msg_iovlen = buffer2 ? 2 : 1;
 
  649      m.msg_controllen = CMSG_SPACE(n_fds * 
sizeof(
int));
 
  650      m.msg_control = alloca(m.msg_controllen);
 
  651      memset(m.msg_control, 0, m.msg_controllen);
 
  653      cm = CMSG_FIRSTHDR(&m);
 
  654      cm->cmsg_level = SOL_SOCKET;
 
  655      cm->cmsg_type = SCM_RIGHTS;
 
  656      cm->cmsg_len = CMSG_LEN(n_fds * 
sizeof(
int));
 
  657      memcpy(CMSG_DATA(cm), fds, n_fds * 
sizeof(
int));
 
  662  bytes_written = sendmsg (fd.fd, &m, 0
 
  663#
if HAVE_DECL_MSG_NOSIGNAL
 
  668  if (bytes_written < 0 && errno == EINTR)
 
  672  if (bytes_written > 0)
 
  676  return bytes_written;
 
  702#if HAVE_DECL_MSG_NOSIGNAL 
  703  struct iovec vectors[2];
 
  715  data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
 
  718    data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
 
  726  vectors[0].iov_base = (
char*) data1;
 
  727  vectors[0].iov_len = len1;
 
  728  vectors[1].iov_base = (
char*) data2;
 
  729  vectors[1].iov_len = len2;
 
  733  m.msg_iovlen = data2 ? 2 : 1;
 
  737  bytes_written = sendmsg (fd.fd, &m, MSG_NOSIGNAL);
 
  739  if (bytes_written < 0 && errno == EINTR)
 
  742  return bytes_written;
 
  746                          buffer2, start2, len2);
 
 
  777  start = _dbus_string_get_length (buffer);
 
  789  bytes_read = read (fd, data, count);
 
 
  835  data = _dbus_string_get_const_data_len (buffer, start, len);
 
  839  bytes_written = write (fd, data, len);
 
  841  if (bytes_written < 0 && errno == EINTR)
 
  845  if (bytes_written > 0)
 
  849  return bytes_written;
 
 
  889    struct iovec vectors[2];
 
  894    data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
 
  897      data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
 
  905    vectors[0].iov_base = (
char*) data1;
 
  906    vectors[0].iov_len = len1;
 
  907    vectors[1].iov_base = (
char*) data2;
 
  908    vectors[1].iov_len = len2;
 
  912    bytes_written = writev (fd,
 
  916    if (bytes_written < 0 && errno == EINTR)
 
  919    return bytes_written;
 
  926    if (ret1 == len1 && buffer2 != 
NULL)
 
 
  963  struct sockaddr_un addr;
 
  966  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
  968  _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
 
  972  if (!_dbus_open_unix_socket (&fd.fd, error))
 
  974      _DBUS_ASSERT_ERROR_IS_SET(error);
 
  977  _DBUS_ASSERT_ERROR_IS_CLEAR(error);
 
  980  addr.sun_family = AF_UNIX;
 
  981  path_len = strlen (path);
 
  986      addr.sun_path[0] = 
'\0'; 
 
  992                      "Abstract socket name too long\n");
 
  997      strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
 
 1001                      "Operating system does not support abstract socket namespace\n");
 
 1011                      "Socket name too long\n");
 
 1016      strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
 
 1019  if (connect (fd.fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
 
 1023                      "Failed to connect to socket %s: %s",
 
 1024                      path, _dbus_strerror (errno));
 
 1030  if (!_dbus_set_fd_nonblocking (fd.fd, error))
 
 1032      _DBUS_ASSERT_ERROR_IS_SET (error);
 
 
 1064  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 1066  _dbus_verbose (
"connecting to process %s\n", path);
 
 1069  retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
 
 1070  cloexec_done = (retval >= 0);
 
 1072  if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
 
 1075      retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
 
 1082                      "Failed to create socket pair: %s",
 
 1083                      _dbus_strerror (errno));
 
 1104                      "Failed to fork() to call %s: %s",
 
 1105                      path, _dbus_strerror (errno));
 
 1117      dup2 (fds[1], STDIN_FILENO);
 
 1118      dup2 (fds[1], STDOUT_FILENO);
 
 1120      if (fds[1] != STDIN_FILENO &&
 
 1121          fds[1] != STDOUT_FILENO)
 
 1129      execvp (path, (
char * 
const *) argv);
 
 1131      fprintf (stderr, 
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
 
 1139  if (!_dbus_set_fd_nonblocking (fds[0], error))
 
 1141      _DBUS_ASSERT_ERROR_IS_SET (error);
 
 
 1176  struct sockaddr_un addr;
 
 1180  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 1182  _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
 
 1185  if (!_dbus_open_unix_socket (&listen_fd, error))
 
 1187      _DBUS_ASSERT_ERROR_IS_SET(error);
 
 1190  _DBUS_ASSERT_ERROR_IS_CLEAR(error);
 
 1193  addr.sun_family = AF_UNIX;
 
 1194  path_len = strlen (path);
 
 1202      addr.sun_path[0] = 
'\0'; 
 
 1208                      "Abstract socket name too long\n");
 
 1213      strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
 
 1217                      "Operating system does not support abstract socket namespace\n");
 
 1237        if (stat (path, &sb) == 0 &&
 
 1238            S_ISSOCK (sb.st_mode))
 
 1245                      "Socket name too long\n");
 
 1250      strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
 
 1253  if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
 
 1256                      "Failed to bind socket \"%s\": %s",
 
 1257                      path, _dbus_strerror (errno));
 
 1262  if (listen (listen_fd, SOMAXCONN ) < 0)
 
 1265                      "Failed to listen on socket \"%s\": %s",
 
 1266                      path, _dbus_strerror (errno));
 
 1271  if (!_dbus_set_fd_nonblocking (listen_fd, error))
 
 1273      _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1281  if (!abstract && chmod (path, 0777) < 0)
 
 1282    _dbus_warn (
"Could not set mode 0777 on socket %s", path);
 
 
 1307  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 1309  n = sd_listen_fds (
TRUE);
 
 1313                      "Failed to acquire systemd socket: %s",
 
 1314                      _dbus_strerror (-n));
 
 1321                      "No socket received.");
 
 1325  for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
 
 1327      r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
 
 1331                          "Failed to verify systemd socket type: %s",
 
 1332                          _dbus_strerror (-r));
 
 1339                          "Passed socket has wrong type.");
 
 1351                      "Failed to allocate file handle array.");
 
 1355  for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
 
 1357      if (!_dbus_set_fd_nonblocking (fd, error))
 
 1359          _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1363      new_fds[fd - SD_LISTEN_FDS_START].fd = fd;
 
 1371  for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
 
 1380                        "dbus was compiled without systemd support");
 
 
 1388_dbus_error_from_gai (
int gai_res,
 
 1454    return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
 
 
 1458_dbus_connect_tcp_socket_with_nonce (
const char     *host,
 
 1461                                     const char     *noncefile,
 
 1464  int saved_errno = 0;
 
 1468  struct addrinfo hints;
 
 1469  struct addrinfo *ai = 
NULL;
 
 1470  const struct addrinfo *tmp;
 
 1473  _DBUS_ASSERT_ERROR_IS_CLEAR(error);
 
 1478    hints.ai_family = AF_UNSPEC;
 
 1479  else if (!strcmp(family, 
"ipv4"))
 
 1480    hints.ai_family = AF_INET;
 
 1481  else if (!strcmp(family, 
"ipv6"))
 
 1482    hints.ai_family = AF_INET6;
 
 1487                      "Unknown address family %s", family);
 
 1488      return _dbus_socket_get_invalid ();
 
 1490  hints.ai_protocol = IPPROTO_TCP;
 
 1491  hints.ai_socktype = SOCK_STREAM;
 
 1492  hints.ai_flags = AI_ADDRCONFIG;
 
 1494  if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
 
 1497                      _dbus_error_from_gai (res, errno),
 
 1498                      "Failed to lookup host/port: \"%s:%s\": %s (%d)",
 
 1499                      host, port, gai_strerror(res), res);
 
 1506      if (!_dbus_open_socket (&fd.fd, tmp->ai_family, SOCK_STREAM, 0, error))
 
 1508          _DBUS_ASSERT_ERROR_IS_SET(error);
 
 1509          _dbus_socket_invalidate (&fd);
 
 1512      _DBUS_ASSERT_ERROR_IS_CLEAR(error);
 
 1514      if (connect (fd.fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
 
 1516          saved_errno = errno;
 
 1521          if (connect_error == 
NULL)
 
 1523              _DBUS_SET_OOM (error);
 
 1528          _dbus_set_error_with_inet_sockaddr (connect_error,
 
 1529                                              tmp->ai_addr, tmp->ai_addrlen,
 
 1530                                              "Failed to connect to socket",
 
 1537              _DBUS_SET_OOM (error);
 
 1548  if (!_dbus_socket_is_valid (fd))
 
 1550      _dbus_combine_tcp_errors (&connect_errors, 
"Failed to connect",
 
 1555  if (noncefile != 
NULL)
 
 1560      ret = _dbus_send_nonce (fd, &noncefileStr, error);
 
 1569  if (!_dbus_set_fd_nonblocking (fd.fd, error))
 
 1610                         const char    **retfamily,
 
 1615  int nlisten_fd = 0, res, i;
 
 1619  struct addrinfo hints;
 
 1620  struct addrinfo *ai, *tmp;
 
 1621  unsigned int reuseaddr;
 
 1626  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 1631    hints.ai_family = AF_UNSPEC;
 
 1632  else if (!strcmp(family, 
"ipv4"))
 
 1633    hints.ai_family = AF_INET;
 
 1634  else if (!strcmp(family, 
"ipv6"))
 
 1635    hints.ai_family = AF_INET6;
 
 1640                      "Unknown address family %s", family);
 
 1644  hints.ai_protocol = IPPROTO_TCP;
 
 1645  hints.ai_socktype = SOCK_STREAM;
 
 1646  hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
 
 1648 redo_lookup_with_port:
 
 1650  if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
 
 1653                      _dbus_error_from_gai (res, errno),
 
 1654                      "Failed to lookup host/port: \"%s:%s\": %s (%d)",
 
 1655                      host ? host : 
"*", port ? port : 
"0", gai_strerror(res), res);
 
 1662      int fd = -1, tcp_nodelay_on;
 
 1665      if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
 
 1667          _DBUS_ASSERT_ERROR_IS_SET(error);
 
 1670      _DBUS_ASSERT_ERROR_IS_CLEAR(error);
 
 1673      if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, 
sizeof(reuseaddr))==-1)
 
 1675          _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
 
 1676                      host ? host : 
"*", port ? port : 
"0", _dbus_strerror (errno));
 
 1682      if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay_on, 
sizeof (tcp_nodelay_on)) == -1)
 
 1684          _dbus_warn (
"Failed to set TCP_NODELAY socket option \"%s:%s\": %s",
 
 1685                      host ? host : 
"*", port ? port : 
"0", _dbus_strerror (errno));
 
 1688      if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
 
 1690          saved_errno = errno;
 
 1714          if (bind_error == 
NULL)
 
 1716              _DBUS_SET_OOM (error);
 
 1721          _dbus_set_error_with_inet_sockaddr (bind_error, tmp->ai_addr, tmp->ai_addrlen,
 
 1722                                              "Failed to bind socket",
 
 1729              _DBUS_SET_OOM (error);
 
 1738      if (listen (fd, 30 ) < 0)
 
 1740          saved_errno = errno;
 
 1742          _dbus_set_error_with_inet_sockaddr (error, tmp->ai_addr, tmp->ai_addrlen,
 
 1743                                              "Failed to listen on socket",
 
 1753                          "Failed to allocate file handle array");
 
 1756      listen_fd = newlisten_fd;
 
 1757      listen_fd[nlisten_fd].fd = fd;
 
 1760      if (tmp->ai_addr->sa_family == AF_INET)
 
 1762      else if (tmp->ai_addr->sa_family == AF_INET6)
 
 1765      if (!_dbus_string_get_length(retport))
 
 1771          if (!port || !strcmp(port, 
"0"))
 
 1774              struct sockaddr_storage addr;
 
 1778              addrlen = 
sizeof(addr);
 
 1779              result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
 
 1783                  saved_errno = errno;
 
 1785                                  "Failed to retrieve socket name for \"%s:%s\": %s",
 
 1786                                  host ? host : 
"*", port ? port : 
"0", _dbus_strerror (saved_errno));
 
 1790              if ((res = getnameinfo ((
struct sockaddr*)&addr, addrlen, 
NULL, 0,
 
 1791                                      portbuf, 
sizeof(portbuf),
 
 1792                                      NI_NUMERICHOST | NI_NUMERICSERV)) != 0)
 
 1794                  saved_errno = errno;
 
 1796                                  "Failed to resolve port \"%s:%s\": %s (%d)",
 
 1797                                  host ? host : 
"*", port ? port : 
"0", gai_strerror(res), res);
 
 1808              port = _dbus_string_get_const_data(retport);
 
 1810              goto redo_lookup_with_port;
 
 1829      _dbus_combine_tcp_errors (&bind_errors, 
"Failed to bind", host,
 
 1834  if (have_ipv4 && !have_ipv6)
 
 1835    *retfamily = 
"ipv4";
 
 1836  else if (!have_ipv4 && have_ipv6)
 
 1837    *retfamily = 
"ipv6";
 
 1839  for (i = 0 ; i < nlisten_fd ; i++)
 
 1841      if (!_dbus_set_fd_nonblocking (listen_fd[i].fd, error))
 
 1862  for (i = 0 ; i < nlisten_fd ; i++)
 
 
 1876write_credentials_byte (
int             server_fd,
 
 1880  char buf[1] = { 
'\0' };
 
 1881#if defined(HAVE_CMSGCRED) 
 1884          char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
 
 1895  msg.msg_control = (caddr_t) &cmsg;
 
 1896  msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
 
 1898  cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
 
 1899  cmsg.hdr.cmsg_level = SOL_SOCKET;
 
 1900  cmsg.hdr.cmsg_type = SCM_CREDS;
 
 1903  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 1907#if defined(HAVE_CMSGCRED) 
 1908  bytes_written = sendmsg (server_fd, &msg, 0
 
 1909#
if HAVE_DECL_MSG_NOSIGNAL
 
 1917  if (bytes_written < 0 && errno == EINVAL)
 
 1920      bytes_written = send (server_fd, buf, 1, 0
 
 1921#
if HAVE_DECL_MSG_NOSIGNAL
 
 1927  if (bytes_written < 0 && errno == EINTR)
 
 1930  if (bytes_written < 0)
 
 1933                      "Failed to write credentials byte: %s",
 
 1934                     _dbus_strerror (errno));
 
 1937  else if (bytes_written == 0)
 
 1940                      "wrote zero bytes writing credentials byte");
 
 1946      _dbus_verbose (
"wrote credentials byte\n");
 
 1953add_groups_to_credentials (
int              client_fd,
 
 1957#if defined(__linux__) && defined(SO_PEERGROUPS) 
 1958  _DBUS_STATIC_ASSERT (
sizeof (gid_t) <= 
sizeof (
dbus_gid_t));
 
 1960  _DBUS_STATIC_ASSERT (((socklen_t) -1) > 0);
 
 1962  socklen_t len = 1024;
 
 1970  n_gids = ((size_t) len) / 
sizeof (gid_t);
 
 1976  while (getsockopt (client_fd, SOL_SOCKET, SO_PEERGROUPS, buf, &len) < 0)
 
 1981      _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
 
 1982                     _dbus_strerror (e), (
unsigned long) len);
 
 1984      if (e != ERANGE || (
size_t) len <= n_gids * 
sizeof (gid_t))
 
 1986          _dbus_verbose (
"Failed to getsockopt(SO_PEERGROUPS): %s\n",
 
 1987                         _dbus_strerror (e));
 
 1993      n_gids = ((size_t) len) / 
sizeof (gid_t);
 
 1996      if (replacement == 
NULL)
 
 2003      _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
 
 2006  if (len > n_gids * 
sizeof (gid_t))
 
 2008      _dbus_verbose (
"%lu > %zu", (
unsigned long) len, n_gids * 
sizeof (gid_t));
 
 2012  if (len % 
sizeof (gid_t) != 0)
 
 2014      _dbus_verbose (
"getsockopt(SO_PEERGROUPS) did not return an " 
 2015                     "integer multiple of sizeof(gid_t): %lu should be " 
 2017                     (
unsigned long) len, 
sizeof (gid_t));
 
 2022  n_gids = ((size_t) len) / 
sizeof (gid_t);
 
 2030      _dbus_verbose (
"getsockopt(SO_PEERGROUPS) returned a huge number " 
 2031                     "of groups (%lu bytes), ignoring",
 
 2032                     (
unsigned long) len);
 
 2038  if (converted_gids == 
NULL)
 
 2044  for (i = 0; i < n_gids; i++)
 
 2048      if (converted_gids[i] == primary)
 
 2049        need_primary = 
FALSE;
 
 2054      converted_gids[n_gids] = primary;
 
 2071add_linux_security_label_to_credentials (
int              client_fd,
 
 2074#if defined(__linux__) && defined(SO_PEERSEC) 
 2076  socklen_t len = 1024;
 
 2083  while (getsockopt (client_fd, SOL_SOCKET, SO_PEERSEC,
 
 2084         _dbus_string_get_data (&buf), &len) < 0)
 
 2088      _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
 
 2089                     _dbus_strerror (e), (
unsigned long) len);
 
 2091      if (e != ERANGE || len <= _dbus_string_get_length_uint (&buf))
 
 2093          _dbus_verbose (
"Failed to getsockopt(SO_PEERSEC): %s\n",
 
 2094                         _dbus_strerror (e));
 
 2106      _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
 
 2111      _dbus_verbose (
"getsockopt(SO_PEERSEC) yielded <= 0 bytes: %lu\n",
 
 2112                     (
unsigned long) len);
 
 2116  if (len > _dbus_string_get_length_uint (&buf))
 
 2118      _dbus_verbose (
"%lu > %u", (
unsigned long) len,
 
 2119                     _dbus_string_get_length_uint (&buf));
 
 2123  if (_dbus_string_get_byte (&buf, len - 1) == 0)
 
 2127      _dbus_verbose (
"subtracting trailing \\0\n");
 
 2138  if (strlen (_dbus_string_get_const_data (&buf)) != len)
 
 2143      _dbus_verbose (
"security label from kernel had an embedded \\0, " 
 2148  _dbus_verbose (
"getsockopt(SO_PEERSEC): %lu bytes excluding \\0: %s\n",
 
 2149                 (
unsigned long) len,
 
 2150                 _dbus_string_get_const_data (&buf));
 
 2153        _dbus_string_get_const_data (&buf)))
 
 2225    char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
 
 2233  _DBUS_STATIC_ASSERT (
sizeof (pid_t) <= 
sizeof (
dbus_pid_t));
 
 2234  _DBUS_STATIC_ASSERT (
sizeof (uid_t) <= 
sizeof (
dbus_uid_t));
 
 2235  _DBUS_STATIC_ASSERT (
sizeof (gid_t) <= 
sizeof (
dbus_gid_t));
 
 2242  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2246  iov.iov_base = &buf;
 
 2253#if defined(HAVE_CMSGCRED) 
 2255  msg.msg_control = (caddr_t) &cmsg;
 
 2256  msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
 
 2260  bytes_read = recvmsg (client_fd.fd, &msg, 0);
 
 2273                      "Failed to read credentials byte: %s",
 
 2274                      _dbus_strerror (errno));
 
 2277  else if (bytes_read == 0)
 
 2283                      "Failed to read credentials byte (zero-length read)");
 
 2286  else if (buf != 
'\0')
 
 2289                      "Credentials byte was not nul");
 
 2293  _dbus_verbose (
"read credentials byte\n");
 
 2306    struct sockpeercred cr;
 
 2310    socklen_t cr_len = 
sizeof (cr);
 
 2312    if (getsockopt (client_fd.fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) != 0)
 
 2314        _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED): %s\n",
 
 2315                       _dbus_strerror (errno));
 
 2317    else if (cr_len != 
sizeof (cr))
 
 2319        _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED), returned %d bytes, expected %d\n",
 
 2320                       cr_len, (
int) 
sizeof (cr));
 
 2327        if (cr.uid != (uid_t)-1)
 
 2333        if (cr.gid != (gid_t)-1)
 
 2334          primary_gid_read = cr.gid;
 
 2341    cr_len = 
sizeof (int);
 
 2343    if (getsockopt (client_fd.fd, SOL_SOCKET, SO_PEERPIDFD, &pid_fd_read, &cr_len) != 0)
 
 2345        _dbus_verbose (
"Failed to getsockopt(SO_PEERPIDFD): %s\n",
 
 2346                       _dbus_strerror (errno));
 
 2348    else if (cr_len != 
sizeof (
int))
 
 2350        _dbus_verbose (
"Failed to getsockopt(SO_PEERPIDFD), returned %d bytes, expected %d\n",
 
 2351                       cr_len, (
int) 
sizeof (
int));
 
 2355#elif defined(HAVE_UNPCBID) && defined(LOCAL_PEEREID) 
 2359    socklen_t cr_len = 
sizeof (cr);
 
 2361    if (getsockopt (client_fd.fd, 0, LOCAL_PEEREID, &cr, &cr_len) != 0)
 
 2363        _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID): %s\n",
 
 2364                       _dbus_strerror (errno));
 
 2366    else if (cr_len != 
sizeof (cr))
 
 2368        _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID), returned %d bytes, expected %d\n",
 
 2369                       cr_len, (
int) 
sizeof (cr));
 
 2373        pid_read = cr.unp_pid;
 
 2374        uid_read = cr.unp_euid;
 
 2376#elif defined(HAVE_CMSGCRED) 
 2385    struct cmsgcred *cred;
 
 2386    struct cmsghdr *cmsgp;
 
 2388    for (cmsgp = CMSG_FIRSTHDR (&msg);
 
 2390         cmsgp = CMSG_NXTHDR (&msg, cmsgp))
 
 2392        if (cmsgp->cmsg_type == SCM_CREDS &&
 
 2393            cmsgp->cmsg_level == SOL_SOCKET &&
 
 2394            cmsgp->cmsg_len >= CMSG_LEN (
sizeof (
struct cmsgcred)))
 
 2396            cred = (
struct cmsgcred *) (
void *) CMSG_DATA (cmsgp);
 
 2397            pid_read = cred->cmcred_pid;
 
 2398            uid_read = cred->cmcred_euid;
 
 2403#elif defined(HAVE_GETPEERUCRED) 
 2407    ucred_t * ucred = 
NULL;
 
 2408    if (getpeerucred (client_fd.fd, &ucred) == 0)
 
 2411        adt_session_data_t *adth = 
NULL;
 
 2413        pid_read = ucred_getpid (ucred);
 
 2414        uid_read = ucred_geteuid (ucred);
 
 2417        if (adt_start_session (&adth, 
NULL, 0) || (adth == 
NULL))
 
 2419            _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
 
 2423            if (adt_set_from_ucred (adth, ucred, ADT_NEW))
 
 2425                _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
 
 2429                adt_export_data_t *data = 
NULL;
 
 2430                size_t size = adt_export_session_data (adth, &data);
 
 2433                    _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
 
 2441            (void) adt_end_session (adth);
 
 2447        _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
 
 2457#elif defined(HAVE_GETPEEREID) 
 2475    if (getpeereid (client_fd.fd, &euid, &egid) == 0)
 
 2481        _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
 
 2485#warning Socket credentials not supported on this Unix OS 
 2486#warning Please tell https: 
 2492#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \ 
 2493    defined(__linux__) || \ 
 2494    defined(__OpenBSD__) || \ 
 2496# error Credentials passing not working on this OS is a regression! 
 2499    _dbus_verbose (
"Socket credentials not supported on this OS\n");
 
 2503  _dbus_verbose (
"Credentials:" 
 2512  if (pid_fd_read >= 0)
 
 2519          _DBUS_SET_OOM (error);
 
 2528          _DBUS_SET_OOM (error);
 
 2533  if (!add_linux_security_label_to_credentials (client_fd.fd, credentials))
 
 2535      _DBUS_SET_OOM (error);
 
 2541  if (!add_groups_to_credentials (client_fd.fd, credentials, primary_gid_read))
 
 2543      _DBUS_SET_OOM (error);
 
 
 2571  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2573  if (write_credentials_byte (server_fd.fd, error))
 
 
 2592  struct sockaddr addr;
 
 2598  addrlen = 
sizeof (addr);
 
 2608  client_fd.fd = accept4 (listen_fd.fd, &addr, &addrlen, SOCK_CLOEXEC);
 
 2609  cloexec_done = client_fd.fd >= 0;
 
 2611  if (client_fd.fd < 0 && (errno == ENOSYS || errno == EINVAL))
 
 2614      client_fd.fd = accept (listen_fd.fd, &addr, &addrlen);
 
 2617  if (client_fd.fd < 0)
 
 2623  _dbus_verbose (
"client fd %d accepted\n", client_fd.fd);
 
 
 2646  const char *directory;
 
 2649  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2651  directory = _dbus_string_get_const_data (dir);
 
 2653  if (stat (directory, &sb) < 0)
 
 2656                      "%s", _dbus_strerror (errno));
 
 2661  if (sb.st_uid != geteuid ())
 
 2664                     "%s directory is owned by user %lu, not %lu",
 
 2666                     (
unsigned long) sb.st_uid,
 
 2667                     (
unsigned long) geteuid ());
 
 2671  if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
 
 2672      (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
 
 2675                     "%s directory is not private to the user", directory);
 
 
 2683fill_user_info_from_passwd (
struct passwd *p,
 
 2690  info->
uid = p->pw_uid;
 
 2711  const char *username_c;
 
 2724  if (username != 
NULL)
 
 2725    username_c = _dbus_string_get_const_data (username);
 
 2738#ifdef HAVE_GETPWNAM_R 
 2740    struct passwd p_str;
 
 2743    buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
 
 2749    if ((
long) buflen <= 0)
 
 2764          result = getpwuid_r (uid, &p_str, buf, buflen,
 
 2767          result = getpwnam_r (username_c, &p_str, buf, buflen,
 
 2770        if (result == ERANGE && buflen < 512 * 1024)
 
 2788    if (result != 0 || p != &p_str)
 
 2793#warning getpwnam_r() not available, please report this to the dbus maintainers with details of your OS 
 2803      p = getpwnam (username_c);
 
 2811        if (!fill_user_info_from_passwd (p, info, error))
 
 2821        const char *error_str;
 
 2824          error_str = 
"not found";
 
 2826          error_str = _dbus_strerror (result);
 
 2834                          "Looking up user \"%s\": %s",
 
 2835                          username_c ? username_c : 
"???", error_str);
 
 2837        _dbus_verbose (
"%s", local_error.
message);
 
 2847#ifdef HAVE_GETGROUPLIST 
 2852    int initial_buf_count;
 
 2854    initial_buf_count = 17;
 
 2855    buf_count = initial_buf_count;
 
 2863    if (getgrouplist (username_c,
 
 2865                      buf, &buf_count) < 0)
 
 2881        if (buf_count == initial_buf_count)
 
 2896        if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
 
 2900                _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
 
 2901                            username_c, buf_count, buf_count);
 
 2907                                "Failed to get groups for username \"%s\" primary GID " 
 2910                                _dbus_strerror (errno));
 
 2925    for (i = 0; i < buf_count; ++i)
 
 2948  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 2953  _DBUS_ASSERT_ERROR_IS_SET (error);
 
 2987  return fill_user_info (info, uid,
 
 
 3013  _DBUS_STATIC_ASSERT (
sizeof (pid_t) <= 
sizeof (
dbus_pid_t));
 
 3014  _DBUS_STATIC_ASSERT (
sizeof (uid_t) <= 
sizeof (
dbus_uid_t));
 
 3015  _DBUS_STATIC_ASSERT (
sizeof (gid_t) <= 
sizeof (
dbus_gid_t));
 
 3017#if HAVE_DECL_SYS_PIDFD_OPEN 
 3020  int pid_fd = (int) syscall (SYS_pidfd_open, pid, 0);
 
 
 3049  DBusString content = _DBUS_STRING_INIT_INVALID;
 
 3050  DBusString filename = _DBUS_STRING_INIT_INVALID;
 
 3068      _dbus_verbose (
"Cannot read '/proc/self/fdinfo/%d', unable to resolve PID, %s: %s\n",
 
 3076      (pid_index > 0 && _dbus_string_get_byte (&content, pid_index - 1) != 
'\n'))
 
 3078      _dbus_verbose (
"Cannot find 'Pid:' in '/proc/self/fdinfo/%d', unable to resolve PID\n",
 
 3085      _dbus_verbose (
"Cannot parse 'Pid:' from '/proc/self/fdinfo/%d', unable to resolve PID\n",
 
 
 3162#if !defined(HAVE_STDATOMIC_H) && !DBUS_USE_SYNC 
 3168static pthread_mutex_t atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 3180#ifdef HAVE_STDATOMIC_H 
 3182  return atomic_fetch_add (&atomic->
value, 1);
 
 3185  return __sync_add_and_fetch(&atomic->
value, 1)-1;
 
 3189  pthread_mutex_lock (&atomic_mutex);
 
 3190  res = atomic->
value;
 
 3192  pthread_mutex_unlock (&atomic_mutex);
 
 
 3207#ifdef HAVE_STDATOMIC_H 
 3209  return atomic_fetch_sub (&atomic->
value, 1);
 
 3212  return __sync_sub_and_fetch(&atomic->
value, 1)+1;
 
 3216  pthread_mutex_lock (&atomic_mutex);
 
 3217  res = atomic->
value;
 
 3219  pthread_mutex_unlock (&atomic_mutex);
 
 
 3235#ifdef HAVE_STDATOMIC_H 
 3237  return atomic_load (&atomic->
value);
 
 3239  __sync_synchronize ();
 
 3240  return atomic->
value;
 
 3244  pthread_mutex_lock (&atomic_mutex);
 
 3245  res = atomic->
value;
 
 3246  pthread_mutex_unlock (&atomic_mutex);
 
 
 3260#ifdef HAVE_STDATOMIC_H 
 3262  atomic_store (&atomic->
value, 0);
 
 3265  __sync_and_and_fetch (&atomic->
value, 0);
 
 3267  pthread_mutex_lock (&atomic_mutex);
 
 3269  pthread_mutex_unlock (&atomic_mutex);
 
 
 3281#ifdef HAVE_STDATOMIC_H 
 3283  atomic_store (&atomic->
value, 1);
 
 3286  __sync_or_and_fetch (&atomic->
value, 1);
 
 3288  pthread_mutex_lock (&atomic_mutex);
 
 3290  pthread_mutex_unlock (&atomic_mutex);
 
 
 3305            int         timeout_milliseconds)
 
 3307#if defined(HAVE_POLL) && !defined(BROKEN_POLL) 
 3309  if (timeout_milliseconds < -1)
 
 3311      timeout_milliseconds = -1;
 
 3316               timeout_milliseconds);
 
 3319  fd_set read_set, write_set, err_set;
 
 3325  FD_ZERO (&read_set);
 
 3326  FD_ZERO (&write_set);
 
 3329  for (i = 0; i < n_fds; i++)
 
 3334        FD_SET (fdp->
fd, &read_set);
 
 3337        FD_SET (fdp->
fd, &write_set);
 
 3339      FD_SET (fdp->
fd, &err_set);
 
 3341      max_fd = MAX (max_fd, fdp->
fd);
 
 3344  tv.tv_sec = timeout_milliseconds / 1000;
 
 3345  tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
 
 3347  ready = select (max_fd + 1, &read_set, &write_set, &err_set,
 
 3348                  timeout_milliseconds < 0 ? 
NULL : &tv);
 
 3352      for (i = 0; i < n_fds; i++)
 
 3358          if (FD_ISSET (fdp->
fd, &read_set))
 
 3361          if (FD_ISSET (fdp->
fd, &write_set))
 
 3364          if (FD_ISSET (fdp->
fd, &err_set))
 
 
 3384#ifdef HAVE_MONOTONIC_CLOCK 
 3386  clock_gettime (CLOCK_MONOTONIC, &ts);
 
 3389    *tv_sec = ts.tv_sec;
 
 3391    *tv_usec = ts.tv_nsec / 1000;
 
 3395  gettimeofday (&t, 
NULL);
 
 3400    *tv_usec = t.tv_usec;
 
 
 3417  gettimeofday (&t, 
NULL);
 
 3422    *tv_usec = t.tv_usec;
 
 
 3437  const char *filename_c;
 
 3439  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3441  filename_c = _dbus_string_get_const_data (filename);
 
 3443  if (mkdir (filename_c, 0700) < 0)
 
 3445      if (errno == EEXIST)
 
 3449                      "Failed to create directory %s: %s\n",
 
 3450                      filename_c, _dbus_strerror (errno));
 
 
 3469  const char *filename_c;
 
 3471  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3473  filename_c = _dbus_string_get_const_data (filename);
 
 3475  if (mkdir (filename_c, 0700) < 0)
 
 3478                      "Failed to create directory %s: %s\n",
 
 3479                      filename_c, _dbus_strerror (errno));
 
 
 3503  if (_dbus_string_get_length (dir) == 0 ||
 
 3504      _dbus_string_get_length (next_component) == 0)
 
 3507  dir_ends_in_slash = 
'/' == _dbus_string_get_byte (dir,
 
 3508                                                    _dbus_string_get_length (dir) - 1);
 
 3510  file_starts_with_slash = 
'/' == _dbus_string_get_byte (next_component, 0);
 
 3512  if (dir_ends_in_slash && file_starts_with_slash)
 
 3516  else if (!(dir_ends_in_slash || file_starts_with_slash))
 
 3523                            _dbus_string_get_length (dir));
 
 
 3527#define NANOSECONDS_PER_SECOND       1000000000 
 3529#define MICROSECONDS_PER_SECOND      1000000 
 3531#define MILLISECONDS_PER_SECOND      1000 
 3533#define NANOSECONDS_PER_MILLISECOND  1000000 
 3535#define MICROSECONDS_PER_MILLISECOND 1000 
 3544#ifdef HAVE_NANOSLEEP 
 3545  struct timespec req;
 
 3546  struct timespec rem;
 
 3548  req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
 
 3549  req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
 
 3553  while (nanosleep (&req, &rem) < 0 && errno == EINTR)
 
 3555#elif defined (HAVE_USLEEP) 
 3556  usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
 
 3558  sleep (MAX (milliseconds / 1000, 1));
 
 
 3576  int old_len = _dbus_string_get_length (str);
 
 3579#ifdef HAVE_GETRANDOM 
 3584      _DBUS_SET_OOM (error);
 
 3589  result = getrandom (buffer, n_bytes, GRND_NONBLOCK);
 
 3591  if (result == n_bytes)
 
 3598  fd = open (
"/dev/urandom", O_RDONLY);
 
 3603                      "Could not open /dev/urandom: %s",
 
 3604                      _dbus_strerror (errno));
 
 3608  _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
 
 3612  if (result != n_bytes)
 
 3616                        "Could not read /dev/urandom: %s",
 
 3617                        _dbus_strerror (errno));
 
 3620                        "Short read from /dev/urandom");
 
 3627  _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
 
 
 3655_dbus_strerror (
int error_number)
 
 3659  msg = strerror (error_number);
 
 3672  signal (SIGPIPE, SIG_IGN);
 
 
 3687  val = fcntl (fd, F_GETFD, 0);
 
 3694  fcntl (fd, F_SETFD, val);
 
 
 3709  val = fcntl (fd, F_GETFD, 0);
 
 3716  fcntl (fd, F_SETFD, val);
 
 
 3730  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3739                      "Could not close fd %d", fd);
 
 
 3760#ifdef F_DUPFD_CLOEXEC 
 3763  new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 
 3764  cloexec_done = new_fd >= 0;
 
 3766  if (new_fd < 0 && errno == EINVAL)
 
 3769      new_fd = fcntl(fd, F_DUPFD, 3);
 
 3775                    "Could not duplicate fd %d", fd);
 
 3779#ifdef F_DUPFD_CLOEXEC 
 
 3800  return _dbus_set_fd_nonblocking (fd.fd, error);
 
 
 3804_dbus_set_fd_nonblocking (
int             fd,
 
 3809  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3811  val = fcntl (fd, F_GETFL, 0);
 
 3815                      "Failed to get flags from file descriptor %d: %s",
 
 3816                      fd, _dbus_strerror (errno));
 
 3817      _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
 
 3818                     _dbus_strerror (errno));
 
 3822  if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
 
 3825                      "Failed to set nonblocking flag of file descriptor %d: %s",
 
 3826                      fd, _dbus_strerror (errno));
 
 3827      _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
 
 3828                     fd, _dbus_strerror (errno));
 
 3844#if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC) 
 3850  bt_size = backtrace (bt, 500);
 
 3852  syms = backtrace_symbols (bt, bt_size);
 
 3858      fprintf (stderr, 
"  %s\n", syms[i]);
 
 3864#elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC) 
 3865  fprintf (stderr, 
"  D-Bus not built with -rdynamic so unable to print a backtrace\n");
 
 3867  fprintf (stderr, 
"  D-Bus not compiled with backtrace support so unable to print a backtrace\n");
 
 
 3889#ifdef HAVE_SOCKETPAIR 
 3896  retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
 
 3897  cloexec_done = retval >= 0;
 
 3899  if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
 
 3902      retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
 
 3908                      "Could not create full-duplex pipe");
 
 3912  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 3923      (!_dbus_set_fd_nonblocking (fds[0], 
NULL) ||
 
 3924       !_dbus_set_fd_nonblocking (fds[1], 
NULL)))
 
 3927                      "Could not set full-duplex pipe nonblocking");
 
 3938  _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
 
 3943  _dbus_warn (
"_dbus_socketpair() not implemented on this OS");
 
 3945                  "_dbus_socketpair() not implemented on this OS");
 
 
 3962  char static_buf[1024];
 
 3963  int bufsize = 
sizeof (static_buf);
 
 3967  va_copy (args_copy, args);
 
 3968  len = vsnprintf (static_buf, bufsize, format, args_copy);
 
 3985      va_copy (args_copy, args);
 
 3987      if (vsnprintf (static_buf, 1, format, args_copy) == 1)
 
 4006      va_copy (args_copy, args);
 
 4007      len = vsnprintf (buf, bufsize, format, args_copy);
 
 
 4032  static const char* tmpdir = 
NULL;
 
 4044        tmpdir = getenv(
"TMPDIR");
 
 4050        tmpdir = getenv(
"TMP");
 
 4052        tmpdir = getenv(
"TEMP");
 
 
 4066#if defined(DBUS_ENABLE_X11_AUTOLAUNCH) || defined(DBUS_ENABLE_LAUNCHD) 
 4087_read_subprocess_line_argv (
const char *progpath,
 
 4089                            const char * 
const *argv,
 
 4093  int result_pipe[2] = { -1, -1 };
 
 4094  int errors_pipe[2] = { -1, -1 };
 
 4101  sigset_t new_set, old_set;
 
 4103  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 4110  sigemptyset (&new_set);
 
 4111  sigaddset (&new_set, SIGCHLD);
 
 4112  sigprocmask (SIG_BLOCK, &new_set, &old_set);
 
 4114  orig_len = _dbus_string_get_length (result);
 
 4118  if (pipe (result_pipe) < 0)
 
 4121                      "Failed to create a pipe to call %s: %s",
 
 4122                      progpath, _dbus_strerror (errno));
 
 4123      _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
 
 4124                     progpath, _dbus_strerror (errno));
 
 4127  if (pipe (errors_pipe) < 0)
 
 4130                      "Failed to create a pipe to call %s: %s",
 
 4131                      progpath, _dbus_strerror (errno));
 
 4132      _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
 
 4133                     progpath, _dbus_strerror (errno));
 
 4146                      "Failed to fork() to call %s: %s",
 
 4147                      progpath, _dbus_strerror (errno));
 
 4148      _dbus_verbose (
"Failed to fork() to call %s: %s\n",
 
 4149                     progpath, _dbus_strerror (errno));
 
 4156      const char *error_str;
 
 4160          int saved_errno = errno;
 
 4165          if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0 ||
 
 4166              write (errors_pipe[
WRITE_END], 
": ", 2) < 0)
 
 4171          error_str = _dbus_strerror (saved_errno);
 
 4173          if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0)
 
 4185      if (dup2 (result_pipe[
WRITE_END], 1) == -1) 
 
 4187      if (dup2 (errors_pipe[
WRITE_END], 2) == -1) 
 
 4192      sigprocmask (SIG_SETMASK, &old_set, 
NULL);
 
 4195      if (progpath[0] == 
'/')
 
 4197          execv (progpath, (
char * 
const *) argv);
 
 4206            execvp (strrchr (progpath, 
'/')+1, (
char * 
const *) argv);
 
 4209        execvp (progpath, (
char * 
const *) argv);
 
 4231      ret = waitpid (pid, &status, 0);
 
 4233  while (ret == -1 && errno == EINTR);
 
 4237  if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
 
 4243          _DBUS_SET_OOM (error);
 
 4255      if (_dbus_string_get_length (&error_message) > 0)
 
 4257                        "%s terminated abnormally with the following error: %s",
 
 4258                        progpath, _dbus_string_get_data (&error_message));
 
 4261                        "%s terminated abnormally without any error message",
 
 4269  sigprocmask (SIG_SETMASK, &old_set, 
NULL);
 
 4271  _DBUS_ASSERT_ERROR_XOR_BOOL (error, retval);
 
 4273  if (result_pipe[0] != -1)
 
 4274    close (result_pipe[0]);
 
 4275  if (result_pipe[1] != -1)
 
 4276    close (result_pipe[1]);
 
 4277  if (errors_pipe[0] != -1)
 
 4278    close (errors_pipe[0]);
 
 4279  if (errors_pipe[1] != -1)
 
 4280    close (errors_pipe[1]);
 
 4303#ifdef DBUS_ENABLE_X11_AUTOLAUNCH 
 4304  static const char arg_dbus_launch[] = 
"dbus-launch";
 
 4305  static const char arg_autolaunch[] = 
"--autolaunch";
 
 4306  static const char arg_binary_syntax[] = 
"--binary-syntax";
 
 4307  static const char arg_close_stderr[] = 
"--close-stderr";
 
 4312  const char *display;
 
 4313  const char *progpath;
 
 4314  const char *argv[6];
 
 4322                            "Unable to autolaunch when setuid");
 
 4326  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 4339  if (display == 
NULL || display[0] == 
'\0')
 
 4342          "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
 
 4348      _DBUS_SET_OOM (error);
 
 4357#ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 4360  if (progpath == 
NULL)
 
 4362    progpath = DBUS_BINDIR 
"/dbus-launch";
 
 4369  argv[i] = arg_dbus_launch;
 
 4371  argv[i] = arg_autolaunch;
 
 4373  argv[i] = _dbus_string_get_data (&uuid);
 
 4375  argv[i] = arg_binary_syntax;
 
 4377  argv[i] = arg_close_stderr;
 
 4384  retval = _read_subprocess_line_argv (progpath,
 
 4386                                       argv, address, error);
 
 4393      "Using X11 for dbus-daemon autolaunch was disabled at compile time, " 
 4394#ifdef DBUS_ENABLE_LAUNCHD
 
 4395      "verify that org.freedesktop.dbus-session.plist is loaded or " 
 4397      "set your DBUS_SESSION_BUS_ADDRESS instead");
 
 
 4442      if (create_if_not_found)
 
 4454  if (!create_if_not_found)
 
 4457                      "D-Bus library appears to be incorrectly set up: " 
 4458                      "see the manual page for dbus-uuidgen to correct " 
 4459                      "this issue. (%s; %s)",
 
 
 4487                             const char *launchd_env_var,
 
 4490#ifdef DBUS_ENABLE_LAUNCHD 
 4494  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 4499                            "Unable to find launchd socket when setuid");
 
 4504  argv[i] = 
"launchctl";
 
 4508  argv[i] = (
char*)launchd_env_var;
 
 4515  if (!_read_subprocess_line_argv(argv[0], 
TRUE, argv, socket_path, error))
 
 4521  if (_dbus_string_get_length(socket_path) == 0)
 
 4531                "can't lookup socket from launchd; launchd support not compiled in");
 
 
 4536#ifdef DBUS_ENABLE_LAUNCHD 
 4538_dbus_lookup_session_address_launchd (
dbus_bool_t *supported,
 
 4547      _DBUS_SET_OOM (error);
 
 4555      _dbus_verbose (
"launchd did not provide a socket path");
 
 4562      _DBUS_SET_OOM (error);
 
 4567                          _dbus_string_get_length (address)))
 
 4569      _DBUS_SET_OOM (error);
 
 4584  const char *runtime_dir = 
_dbus_getenv (
"XDG_RUNTIME_DIR");
 
 4589  if (runtime_dir == 
NULL)
 
 4591      _dbus_verbose (
"XDG_RUNTIME_DIR not found in environment");
 
 4598      _DBUS_SET_OOM (error);
 
 4604      _DBUS_SET_OOM (error);
 
 4608  if (lstat (_dbus_string_get_const_data (&user_bus_path), &stbuf) == -1)
 
 4610      _dbus_verbose (
"XDG_RUNTIME_DIR/bus not available: %s",
 
 4611                     _dbus_strerror (errno));
 
 4617  if (stbuf.st_uid != getuid ())
 
 4619      _dbus_verbose (
"XDG_RUNTIME_DIR/bus owned by uid %ld, not our uid %ld",
 
 4620                     (
long) stbuf.st_uid, (
long) getuid ());
 
 4626  if ((stbuf.st_mode & S_IFMT) != S_IFSOCK)
 
 4628      _dbus_verbose (
"XDG_RUNTIME_DIR/bus is not a socket: st_mode = 0o%lo",
 
 4629                     (
long) stbuf.st_mode);
 
 4638      _DBUS_SET_OOM (error);
 
 4674#ifdef DBUS_ENABLE_LAUNCHD 
 4676  return _dbus_lookup_session_address_launchd (supported, address, error);
 
 4680  if (!_dbus_lookup_user_bus (supported, address, error))
 
 4682  else if (*supported)
 
 
 4740#ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 4742    const char *
override;
 
 4745    if (
override != 
NULL && *
override != 
'\0')
 
 4751        _dbus_verbose (
"Using fake homedir for testing: %s\n",
 
 4752                       _dbus_string_get_const_data (&homedir));
 
 4759        if (!already_warned)
 
 4761            _dbus_warn (
"Using %s for testing, set DBUS_TEST_HOMEDIR to avoid",
 
 4762                _dbus_string_get_const_data (&homedir));
 
 4763            already_warned = 
TRUE;
 
 4775                          directory, _dbus_string_get_length (directory))) {
 
 
 4789_dbus_daemon_unpublish_session_bus_address (
void)
 
 
 4807#if EAGAIN == EWOULDBLOCK 
 4810  return e == EAGAIN || e == EWOULDBLOCK;
 
 
 4825  const char *filename_c;
 
 4827  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 4829  filename_c = _dbus_string_get_const_data (filename);
 
 4831  if (rmdir (filename_c) != 0)
 
 4834                      "Failed to remove directory %s: %s\n",
 
 4835                      filename_c, _dbus_strerror (errno));
 
 
 4855    struct sockaddr_storage storage;
 
 4856    struct sockaddr_un un;
 
 4859  socklen_t sa_len = 
sizeof(sa_buf);
 
 4863  if (getsockname(fd.fd, &sa_buf.sa, &sa_len) < 0)
 
 4866  return sa_buf.sa.sa_family == AF_UNIX;
 
 
 4879act_on_fds_3_and_up (
void (*func) (
int fd))
 
 4883#if defined(__linux__) && defined(__GLIBC__) 
 4889  d = opendir (
"/proc/self/fd");
 
 4903          if (de->d_name[0] == 
'.')
 
 4907          l = strtol (de->d_name, &e, 10);
 
 4908          if (errno != 0 || e == 
NULL || *e != 
'\0')
 
 4915          if (fd == dirfd (d))
 
 4926  maxfds = sysconf (_SC_OPEN_MAX);
 
 4935  for (i = 3; i < maxfds; i++)
 
 4942#if defined(HAVE_CLOSEFROM) && ( \ 
 4943    defined(__FreeBSD__) || \ 
 4944    defined(__NetBSD__) || \ 
 4945    defined(__OpenBSD__) || \ 
 4946    defined(__sun__) && defined(F_CLOSEFROM) \ 
 4948#define CLOSEFROM_SIGNAL_SAFE 1 
 4950#define CLOSEFROM_SIGNAL_SAFE 0 
 4952close_ignore_error (
int fd)
 
 4965#ifdef HAVE_CLOSE_RANGE 
 4966  if (close_range (3, INT_MAX, 0) == 0)
 
 4970#if CLOSEFROM_SIGNAL_SAFE 
 4973  act_on_fds_3_and_up (close_ignore_error);
 
 
 4984#if defined(HAVE_CLOSE_RANGE) && defined(CLOSE_RANGE_CLOEXEC) 
 4985  if (close_range (3, INT_MAX, CLOSE_RANGE_CLOEXEC) == 0)
 
 
 5007#if 0 && defined(HAVE_LIBC_ENABLE_SECURE) 
 5010    extern int __libc_enable_secure;
 
 5011    return __libc_enable_secure;
 
 5013#elif defined(HAVE_ISSETUGID) 
 5015  return issetugid ();
 
 5017  uid_t ruid, euid, suid; 
 
 5018  gid_t rgid, egid, sgid; 
 
 5025  if (_DBUS_UNLIKELY (!check_setuid_initialised))
 
 5027#ifdef HAVE_GETRESUID 
 5028      if (getresuid (&ruid, &euid, &suid) != 0 ||
 
 5029          getresgid (&rgid, &egid, &sgid) != 0)
 
 5032          suid = ruid = getuid ();
 
 5033          sgid = rgid = getgid ();
 
 5038      check_setuid_initialised = 
TRUE;
 
 5039      is_setuid = (ruid != euid || ruid != suid ||
 
 5040                   rgid != egid || rgid != sgid);
 
 
 5061      struct sockaddr_storage storage;
 
 5062      struct sockaddr_un un;
 
 5063      struct sockaddr_in ipv4;
 
 5064      struct sockaddr_in6 ipv6;
 
 5066  char hostip[INET6_ADDRSTRLEN];
 
 5067  socklen_t size = 
sizeof (socket);
 
 5069  const char *family_name = 
NULL;
 
 5072  if (getsockname (fd.fd, &socket.sa, &size))
 
 5075  switch (socket.sa.sa_family)
 
 5078      if (socket.un.sun_path[0]==
'\0')
 
 5088              _DBUS_SET_OOM (error);
 
 5102              _DBUS_SET_OOM (error);
 
 5115      if (_dbus_inet_sockaddr_to_string (&socket, size, hostip, 
sizeof (hostip),
 
 5116                                         &family_name, &port, error))
 
 5119                                          family_name, port) &&
 
 5126              _DBUS_SET_OOM (error);
 
 5140                      "Failed to read address from socket: Unknown socket type.");
 
 5146                  "Failed to read address from socket: %s",
 
 5147                  _dbus_strerror (errno));
 
 
 5152_dbus_save_socket_errno (
void)
 
 5158_dbus_restore_socket_errno (
int saved_errno)
 
 5160  errno = saved_errno;
 
 5163static const char *syslog_tag = 
"dbus";
 
 5165static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
 
 5188      (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
 
 5195  if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
 
 5196    openlog (tag, LOG_PID, LOG_DAEMON);
 
 
 5214  if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
 
 5216      int flags = LOG_DAEMON | LOG_WARNING;
 
 5219          case DBUS_SYSTEM_LOG_INFO:
 
 5220            flags =  LOG_DAEMON | LOG_INFO;
 
 5222          case DBUS_SYSTEM_LOG_WARNING:
 
 5223            flags =  LOG_DAEMON | LOG_WARNING;
 
 5225          case DBUS_SYSTEM_LOG_SECURITY:
 
 5226            flags = LOG_AUTH | LOG_NOTICE;
 
 5228          case DBUS_SYSTEM_LOG_ERROR:
 
 5229            flags = LOG_DAEMON|LOG_CRIT;
 
 5235      va_copy (tmp, args);
 
 5236      vsyslog (flags, msg, tmp);
 
 5242  if (log_flags & DBUS_LOG_FLAGS_STDERR)
 
 5245      va_copy (tmp, args);
 
 5247      vfprintf (stderr, msg, tmp);
 
 5248      fputc (
'\n', stderr);
 
 
 5262_dbus_get_low_level_socket_errno (
void)
 
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_credentials_clear(DBusCredentials *credentials)
Clear all credentials in the object.
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_GNUC_NORETURN void _dbus_credentials_take_pid_fd(DBusCredentials *credentials, int pid_fd)
Add a UNIX process ID FD to the credentials.
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.
void _dbus_credentials_take_unix_gids(DBusCredentials *credentials, dbus_gid_t *gids, size_t n_gids)
Add UNIX group IDs to the credentials, replacing any group IDs that might already have been present.
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_credentials_add_pid(DBusCredentials *credentials, dbus_pid_t pid)
Add a UNIX process ID to the credentials.
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_bool_t _dbus_credentials_are_anonymous(DBusCredentials *credentials)
Checks whether a credentials object contains a user identity.
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
void dbus_move_error(DBusError *src, DBusError *dest)
Moves an error src into dest, freeing src and overwriting dest.
void dbus_set_error_const(DBusError *error, const char *name, const char *message)
Assigns an error name and message to a DBusError.
void dbus_error_init(DBusError *error)
Initializes a DBusError structure.
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
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_file_get_contents(DBusString *str, const DBusString *filename, DBusError *error)
Appends the contents of the given file to the string, returning error code.
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
#define READ_END
Helps remember which end of the pipe is which.
#define WRITE_END
Helps remember which end of the pipe is which.
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary.
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_generate_uuid(DBusGUID *uuid, DBusError *error)
Generates a new UUID.
char * _dbus_strdup(const char *str)
Duplicates a string.
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.
void _dbus_user_database_flush_system(void)
Flushes the system global user database;.
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_write_uuid_file(const DBusString *filename, const DBusGUID *uuid, DBusError *error)
Write the give UUID to a file.
dbus_bool_t _dbus_homedir_from_uid(dbus_uid_t uid, DBusString *homedir)
Gets the home directory for the given user.
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof().
#define _DBUS_ZERO(object)
Sets all bits in an object to zero.
#define _DBUS_INT32_MAX
Maximum value of type "int32".
void * _dbus_list_pop_first(DBusList **list)
Removes the first value in the list and returns it.
dbus_bool_t _dbus_list_append(DBusList **list, void *data)
Appends a value to the list.
#define NULL
A null pointer, defined appropriately for C or C++.
#define TRUE
Expands to "1".
#define FALSE
Expands to "0".
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.
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
void * dbus_realloc(void *memory, size_t bytes)
Resizes a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
#define DBUS_MAXIMUM_MESSAGE_UNIX_FDS
The maximum total number of unix fds in a message.
#define DBUS_ERROR_NOT_SUPPORTED
Requested operation isn't supported (like ENOSYS on UNIX).
#define DBUS_ERROR_BAD_ADDRESS
A D-Bus bus address was malformed.
#define DBUS_ERROR_IO_ERROR
Something went wrong reading or writing to a socket, for example.
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
#define DBUS_ERROR_SPAWN_EXEC_FAILED
While starting a new process, the exec() call failed.
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
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_init(DBusString *str)
Initializes a string.
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
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_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.
dbus_bool_t _dbus_string_find(const DBusString *str, int start, const char *substr, int *found)
Finds the given substring in the string, returning TRUE and filling in the byte index where the subst...
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(), and fills it with the same contents as _DBUS_STRING_IN...
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_parse_uint(const DBusString *str, int start, unsigned long *value_return, int *end_return)
Parses an unsigned integer contained in a DBusString.
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
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.
dbus_bool_t _dbus_string_append_printf(DBusString *str, const char *format,...)
Appends a printf-style formatted string to the DBusString.
void _dbus_fd_clear_close_on_exec(int fd)
Sets the file descriptor to not be close-on-exec.
void _dbus_fd_set_all_close_on_exec(void)
Sets all file descriptors except the first three (i.e.
dbus_bool_t _dbus_close(int fd, DBusError *error)
Closes a file descriptor.
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 ...
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.
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.
int _dbus_listen_systemd_sockets(DBusSocket **fds, DBusError *error)
Acquires one or more sockets passed in from systemd.
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_user_info_fill(DBusUserInfo *info, const DBusString *username, DBusError *error)
Gets user info for the given username.
void _dbus_close_all(void)
Closes all file descriptors except the first three (i.e.
int _dbus_dup(int fd, DBusError *error)
Duplicates a file descriptor.
void _dbus_fd_set_close_on_exec(int fd)
Sets the file descriptor to be close on exec.
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_ensure_standard_fds(DBusEnsureStandardFdsFlags flags, const char **error_str_p)
Ensure that the standard file descriptors stdin, stdout and stderr are open, by opening /dev/null if ...
dbus_uid_t _dbus_geteuid(void)
Gets our effective UID.
dbus_bool_t _dbus_user_info_fill_uid(DBusUserInfo *info, dbus_uid_t uid, DBusError *error)
Gets user info for the given user ID.
void _dbus_logv(DBusSystemLogSeverity severity, const char *msg, va_list args)
Log a message to the system log file (e.g.
void _dbus_get_monotonic_time(dbus_int64_t *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
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.
#define _DBUS_POLLOUT
Writing now will not block.
unsigned long dbus_uid_t
A user ID.
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)
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...
unsigned long dbus_pid_t
A process ID.
int _dbus_read_socket(DBusSocket fd, DBusString *buffer, int count)
Like _dbus_read(), but only works on sockets so is available on Windows.
void _dbus_exit(int code)
Exit the process, returning the given value.
#define _DBUS_POLLERR
Error condition.
dbus_bool_t _dbus_socket_can_pass_unix_fd(DBusSocket fd)
Checks whether file descriptors may be passed via the socket.
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.
void _dbus_atomic_set_nonzero(DBusAtomic *atomic)
Atomically set the value of an integer to something nonzero.
dbus_bool_t _dbus_socketpair(DBusSocket *fd1, DBusSocket *fd2, dbus_bool_t blocking, DBusError *error)
Creates pair of connect sockets (as in socketpair()).
unsigned long dbus_gid_t
A group ID.
int _dbus_read_socket_with_unix_fds(DBusSocket fd, DBusString *buffer, int count, int *fds, unsigned int *n_fds)
Like _dbus_read_socket() but also tries to read unix fds from the socket.
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.
#define DBUS_UID_UNSET
an invalid UID used to represent an uninitialized dbus_uid_t field
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
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...
#define DBUS_PID_UNSET
an invalid PID used to represent an uninitialized dbus_pid_t field
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
DBusSocket _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.
dbus_pid_t _dbus_getpid(void)
Gets our process ID.
dbus_int32_t _dbus_atomic_get(DBusAtomic *atomic)
Atomically get the value of an integer.
dbus_bool_t _dbus_set_socket_nonblocking(DBusSocket fd, DBusError *error)
Sets a file descriptor to be nonblocking.
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.
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.
void _dbus_disable_sigpipe(void)
signal (SIGPIPE, SIG_IGN);
dbus_bool_t _dbus_check_setuid(void)
NOTE: If you modify this function, please also consider making the corresponding change in GLib.
void _dbus_sleep_milliseconds(int milliseconds)
Sleeps the given number of milliseconds.
#define DBUS_GID_UNSET
an invalid GID used to represent an uninitialized dbus_gid_t field
dbus_pid_t _dbus_resolve_pid_fd(int pid_fd)
Resolve the PID from the PID FD, if any.
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_POLLIN
There is data to read.
int _dbus_listen_tcp_socket(const char *host, const char *port, const char *family, DBusString *retport, const char **retfamily, DBusSocket **fds_p, DBusError *error)
Creates a socket and binds it to the given path, then listens on the socket.
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_uid_t _dbus_getuid(void)
Gets our UID.
dbus_bool_t _dbus_credentials_add_from_current_process(DBusCredentials *credentials)
Adds the most important credentials of the current process (the uid and pid) to the passed-in credent...
dbus_bool_t _dbus_close_socket(DBusSocket *fd, DBusError *error)
Closes a socket and invalidates it.
DBusSocket _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.
void _dbus_atomic_set_zero(DBusAtomic *atomic)
Atomically set the value of an integer to 0.
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
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.
#define DBUS_GID_FORMAT
an appropriate printf format for dbus_gid_t
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.
dbus_bool_t _dbus_delete_directory(const DBusString *filename, DBusError *error)
Removes a directory; Directory must be empty.
#define DBUS_UID_FORMAT
an appropriate printf format for dbus_uid_t
int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll().
dbus_bool_t _dbus_get_autolaunch_address(const char *scope, DBusString *address, DBusError *error)
Returns the address of a new session bus.
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.
dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory.
DBusSocket _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.
void _dbus_print_backtrace(void)
On GNU libc systems, print a crude backtrace to stderr.
void _dbus_get_real_time(dbus_int64_t *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
void _dbus_init_system_log(const char *tag, DBusLogFlags flags)
Initialize the system log.
DBusSocket _dbus_accept(DBusSocket listen_fd)
Accepts a connection on a listening socket.
#define _DBUS_MAX_SUN_PATH_LENGTH
Maximum length of the path to a UNIX domain socket, sockaddr_un::sun_path member.
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...
void _dbus_flush_caches(void)
Called when the bus daemon is signaled to reload its configuration; any caches should be nuked.
const char * _dbus_get_tmpdir(void)
Gets the temporary files directory by inspecting the environment variables TMPDIR,...
#define DBUS_PID_FORMAT
an appropriate printf format for dbus_pid_t
dbus_bool_t _dbus_ensure_directory(const DBusString *filename, DBusError *error)
Creates a directory; succeeds if the directory is created or already existed.
dbus_bool_t _dbus_create_directory(const DBusString *filename, DBusError *error)
Creates a directory.
unsigned short dbus_uint16_t
A 16-bit unsigned integer on all platforms.
_DBUS_GNUC_EXTENSION typedef long dbus_int64_t
A 64-bit signed integer.
int dbus_int32_t
A 32-bit signed integer on all platforms.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
An atomic integer safe to increment or decrement from multiple threads.
volatile dbus_int32_t value
Value of the atomic integer.
Object representing an exception.
const char * name
public error name field
const char * message
public error message field
short events
Events to poll for.
short revents
Events that occurred.
DBusPollable fd
File descriptor.
Information about a UNIX user.
int n_group_ids
Size of group IDs array.
char * homedir
Home directory.
dbus_gid_t * group_ids
Groups IDs, including above primary group.
dbus_gid_t primary_gid
GID.
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...