27 #include "dbus-internals.h"    28 #include "dbus-sysdeps.h"    29 #include "dbus-sysdeps-unix.h"    30 #include "dbus-threads.h"    31 #include "dbus-protocol.h"    32 #include "dbus-file.h"    33 #include "dbus-transport.h"    34 #include "dbus-string.h"    35 #include "dbus-userdb.h"    36 #include "dbus-list.h"    37 #include "dbus-credentials.h"    38 #include "dbus-nonce.h"    40 #include <sys/types.h>    47 #include <sys/socket.h>    56 #include <netinet/in.h>    57 #include <netinet/tcp.h>    60 #include <arpa/inet.h>    77 #ifdef HAVE_GETPEERUCRED    89 #include <systemd/sd-daemon.h>   100 #ifndef AI_ADDRCONFIG   101 #define AI_ADDRCONFIG 0   104 #ifndef HAVE_SOCKLEN_T   105 #define socklen_t int   108 #if defined (__sun) || defined (__sun__)   121 #     define CMSG_ALIGN(len) _CMSG_DATA_ALIGN (len)   124 #     define CMSG_ALIGN(len) (((len) + sizeof (long) - 1) & \   125                               ~(sizeof (long) - 1))   130 #   define CMSG_SPACE(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + \   135 #   define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))   156                            const char                 **error_str_p)
   158   static int const relevant_flag[] = { DBUS_FORCE_STDIN_NULL,
   159       DBUS_FORCE_STDOUT_NULL,
   160       DBUS_FORCE_STDERR_NULL };
   162   const char *error_str = 
"Failed mysteriously";
   166   _DBUS_STATIC_ASSERT (STDIN_FILENO == 0);
   167   _DBUS_STATIC_ASSERT (STDOUT_FILENO == 1);
   168   _DBUS_STATIC_ASSERT (STDERR_FILENO == 2);
   171   for (i = STDIN_FILENO; i <= STDERR_FILENO; i++)
   177         devnull = open (
"/dev/null", O_RDWR);
   181           error_str = 
"Failed to open /dev/null";
   190       if (devnull != i && (flags & relevant_flag[i]) != 0)
   192           if (dup2 (devnull, i) < 0)
   194               error_str = 
"Failed to dup2 /dev/null onto a standard fd";
   205   if (devnull > STDERR_FILENO)
   208   if (error_str_p != 
NULL)
   209     *error_str_p = error_str;
   212   return (error_str == 
NULL);
   215 static dbus_bool_t _dbus_set_fd_nonblocking (
int             fd,
   219 _dbus_open_socket (
int              *fd_p,
   228   *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
   229   cloexec_done = *fd_p >= 0;
   232   if (*fd_p < 0 && (errno == EINVAL || errno == EPROTOTYPE))
   235       *fd_p = socket (domain, type, protocol);
   247       _dbus_verbose (
"socket fd %d opened\n", *fd_p);
   254                      "Failed to open socket: %s",
   255                      _dbus_strerror (errno));
   271 _dbus_open_unix_socket (
int              *fd,
   274   return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);
   325 #if HAVE_DECL_MSG_NOSIGNAL   329   data = _dbus_string_get_const_data_len (buffer, start, len);
   333   bytes_written = send (fd.fd, data, len, MSG_NOSIGNAL);
   335   if (bytes_written < 0 && errno == EINTR)
   338   return bytes_written;
   362                                  unsigned int     *n_fds) {
   363 #ifndef HAVE_UNIX_FD_PASSING   381   start = _dbus_string_get_length (buffer);
   401   m.msg_controllen = CMSG_SPACE(*n_fds * 
sizeof(
int));
   405   m.msg_control = alloca(m.msg_controllen);
   406   memset(m.msg_control, 0, m.msg_controllen);
   412   m.msg_controllen = CMSG_LEN (*n_fds * 
sizeof(
int));
   416   bytes_read = recvmsg (fd.fd, &m, 0
   417 #ifdef MSG_CMSG_CLOEXEC
   438       if (m.msg_flags & MSG_CTRUNC)
   450       for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
   451         if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
   454             int *payload = (
int *) CMSG_DATA (cm);
   455             size_t payload_len_bytes = (cm->cmsg_len - CMSG_LEN (0));
   456             size_t payload_len_fds = payload_len_bytes / 
sizeof (int);
   461             _DBUS_STATIC_ASSERT (
sizeof (
size_t) >= 
sizeof (
unsigned int));
   463             if (_DBUS_LIKELY (payload_len_fds <= (
size_t) *n_fds))
   466                 fds_to_use = payload_len_fds;
   474                 fds_to_use = (size_t) *n_fds;
   479                 for (i = fds_to_use; i < payload_len_fds; i++)
   485             memcpy (fds, payload, fds_to_use * 
sizeof (
int));
   490             *n_fds = (
unsigned int) fds_to_use;
   495             for (i = 0; i < fds_to_use; i++)
   518 _dbus_write_socket_with_unix_fds(
DBusSocket        fd,
   525 #ifndef HAVE_UNIX_FD_PASSING   534   return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len, 
NULL, 0, 0, fds, n_fds);
   539 _dbus_write_socket_with_unix_fds_two(
DBusSocket        fd,
   549 #ifndef HAVE_UNIX_FD_PASSING   557                                 buffer1, start1, len1,
   558                                 buffer2, start2, len2);
   571   iov[0].iov_base = (
char*) _dbus_string_get_const_data_len (buffer1, start1, len1);
   572   iov[0].iov_len = len1;
   576       iov[1].iov_base = (
char*) _dbus_string_get_const_data_len (buffer2, start2, len2);
   577       iov[1].iov_len = len2;
   582   m.msg_iovlen = buffer2 ? 2 : 1;
   586       m.msg_controllen = CMSG_SPACE(n_fds * 
sizeof(
int));
   587       m.msg_control = alloca(m.msg_controllen);
   588       memset(m.msg_control, 0, m.msg_controllen);
   590       cm = CMSG_FIRSTHDR(&m);
   591       cm->cmsg_level = SOL_SOCKET;
   592       cm->cmsg_type = SCM_RIGHTS;
   593       cm->cmsg_len = CMSG_LEN(n_fds * 
sizeof(
int));
   594       memcpy(CMSG_DATA(cm), fds, n_fds * 
sizeof(
int));
   599   bytes_written = sendmsg (fd.fd, &m, 0
   600 #
if HAVE_DECL_MSG_NOSIGNAL
   605   if (bytes_written < 0 && errno == EINTR)
   609   if (bytes_written > 0)
   613   return bytes_written;
   639 #if HAVE_DECL_MSG_NOSIGNAL   640   struct iovec vectors[2];
   652   data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
   655     data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
   663   vectors[0].iov_base = (
char*) data1;
   664   vectors[0].iov_len = len1;
   665   vectors[1].iov_base = (
char*) data2;
   666   vectors[1].iov_len = len2;
   670   m.msg_iovlen = data2 ? 2 : 1;
   674   bytes_written = sendmsg (fd.fd, &m, MSG_NOSIGNAL);
   676   if (bytes_written < 0 && errno == EINTR)
   679   return bytes_written;
   683                           buffer2, start2, len2);
   714   start = _dbus_string_get_length (buffer);
   726   bytes_read = read (fd, data, count);
   772   data = _dbus_string_get_const_data_len (buffer, start, len);
   776   bytes_written = write (fd, data, len);
   778   if (bytes_written < 0 && errno == EINTR)
   782   if (bytes_written > 0)
   786   return bytes_written;
   826     struct iovec vectors[2];
   831     data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
   834       data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
   842     vectors[0].iov_base = (
char*) data1;
   843     vectors[0].iov_len = len1;
   844     vectors[1].iov_base = (
char*) data2;
   845     vectors[1].iov_len = len2;
   849     bytes_written = writev (fd,
   853     if (bytes_written < 0 && errno == EINTR)
   856     return bytes_written;
   863     if (ret1 == len1 && buffer2 != 
NULL)
   877 #define _DBUS_MAX_SUN_PATH_LENGTH 99   915   struct sockaddr_un addr;
   916   _DBUS_STATIC_ASSERT (
sizeof (addr.sun_path) > _DBUS_MAX_SUN_PATH_LENGTH);
   918   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
   920   _dbus_verbose (
"connecting to unix socket %s abstract=%d\n",
   924   if (!_dbus_open_unix_socket (&fd, error))
   926       _DBUS_ASSERT_ERROR_IS_SET(error);
   929   _DBUS_ASSERT_ERROR_IS_CLEAR(error);
   932   addr.sun_family = AF_UNIX;
   933   path_len = strlen (path);
   938       addr.sun_path[0] = 
'\0'; 
   941       if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
   944                       "Abstract socket name too long\n");
   949       strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
   953                       "Operating system does not support abstract socket namespace\n");
   960       if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
   963                       "Socket name too long\n");
   968       strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
   971   if (connect (fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
   975                       "Failed to connect to socket %s: %s",
   976                       path, _dbus_strerror (errno));
   982   if (!_dbus_set_fd_nonblocking (fd, error))
   984       _DBUS_ASSERT_ERROR_IS_SET (error);
  1015   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1017   _dbus_verbose (
"connecting to process %s\n", path);
  1020   retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
  1021   cloexec_done = (retval >= 0);
  1023   if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
  1026       retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
  1033                       "Failed to create socket pair: %s",
  1034                       _dbus_strerror (errno));
  1049                       "Failed to fork() to call %s: %s",
  1050                       path, _dbus_strerror (errno));
  1061       dup2 (fds[1], STDIN_FILENO);
  1062       dup2 (fds[1], STDOUT_FILENO);
  1064       if (fds[1] != STDIN_FILENO &&
  1065           fds[1] != STDOUT_FILENO)
  1073       execvp (path, (
char * 
const *) argv);
  1075       fprintf (stderr, 
"Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
  1083   if (!_dbus_set_fd_nonblocking (fds[0], error))
  1085       _DBUS_ASSERT_ERROR_IS_SET (error);
  1117   struct sockaddr_un addr;
  1119   _DBUS_STATIC_ASSERT (
sizeof (addr.sun_path) > _DBUS_MAX_SUN_PATH_LENGTH);
  1121   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1123   _dbus_verbose (
"listening on unix socket %s abstract=%d\n",
  1126   if (!_dbus_open_unix_socket (&listen_fd, error))
  1128       _DBUS_ASSERT_ERROR_IS_SET(error);
  1131   _DBUS_ASSERT_ERROR_IS_CLEAR(error);
  1134   addr.sun_family = AF_UNIX;
  1135   path_len = strlen (path);
  1143       addr.sun_path[0] = 
'\0'; 
  1146       if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
  1149                       "Abstract socket name too long\n");
  1154       strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
  1158                       "Operating system does not support abstract socket namespace\n");
  1178         if (stat (path, &sb) == 0 &&
  1179             S_ISSOCK (sb.st_mode))
  1183       if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
  1186                       "Socket name too long\n");
  1191       strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
  1194   if (bind (listen_fd, (
struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (
struct sockaddr_un, sun_path) + path_len) < 0)
  1197                       "Failed to bind socket \"%s\": %s",
  1198                       path, _dbus_strerror (errno));
  1203   if (listen (listen_fd, SOMAXCONN ) < 0)
  1206                       "Failed to listen on socket \"%s\": %s",
  1207                       path, _dbus_strerror (errno));
  1212   if (!_dbus_set_fd_nonblocking (listen_fd, error))
  1214       _DBUS_ASSERT_ERROR_IS_SET (error);
  1222   if (!
abstract && chmod (path, 0777) < 0)
  1223     _dbus_warn (
"Could not set mode 0777 on socket %s", path);
  1247   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1249   n = sd_listen_fds (
TRUE);
  1253                       "Failed to acquire systemd socket: %s",
  1254                       _dbus_strerror (-n));
  1261                       "No socket received.");
  1265   for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
  1267       r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
  1271                           "Failed to verify systemd socket type: %s",
  1272                           _dbus_strerror (-r));
  1279                           "Passed socket has wrong type.");
  1291                       "Failed to allocate file handle array.");
  1295   for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
  1297       if (!_dbus_set_fd_nonblocking (fd, error))
  1299           _DBUS_ASSERT_ERROR_IS_SET (error);
  1303       new_fds[fd - SD_LISTEN_FDS_START].fd = fd;
  1311   for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
  1320                         "dbus was compiled without systemd support");
  1328 _dbus_error_from_gai (
int gai_res,
  1394     return _dbus_connect_tcp_socket_with_nonce (host, port, family, (
const char*)
NULL, error);
  1398 _dbus_connect_tcp_socket_with_nonce (
const char     *host,
  1401                                      const char     *noncefile,
  1404   int saved_errno = 0;
  1407   struct addrinfo hints;
  1408   struct addrinfo *ai, *tmp;
  1410   _DBUS_ASSERT_ERROR_IS_CLEAR(error);
  1415     hints.ai_family = AF_UNSPEC;
  1416   else if (!strcmp(family, 
"ipv4"))
  1417     hints.ai_family = AF_INET;
  1418   else if (!strcmp(family, 
"ipv6"))
  1419     hints.ai_family = AF_INET6;
  1424                       "Unknown address family %s", family);
  1425       return _dbus_socket_get_invalid ();
  1427   hints.ai_protocol = IPPROTO_TCP;
  1428   hints.ai_socktype = SOCK_STREAM;
  1429   hints.ai_flags = AI_ADDRCONFIG;
  1431   if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
  1434                       _dbus_error_from_gai (res, errno),
  1435                       "Failed to lookup host/port: \"%s:%s\": %s (%d)",
  1436                       host, port, gai_strerror(res), res);
  1437       return _dbus_socket_get_invalid ();
  1443       if (!_dbus_open_socket (&fd.fd, tmp->ai_family, SOCK_STREAM, 0, error))
  1446           _DBUS_ASSERT_ERROR_IS_SET(error);
  1447           return _dbus_socket_get_invalid ();
  1449       _DBUS_ASSERT_ERROR_IS_CLEAR(error);
  1451       if (connect (fd.fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
  1453           saved_errno = errno;
  1468                       "Failed to connect to socket \"%s:%s\" %s",
  1469                       host, port, _dbus_strerror(saved_errno));
  1470       return _dbus_socket_get_invalid ();
  1473   if (noncefile != 
NULL)
  1478       ret = _dbus_send_nonce (fd, &noncefileStr, error);
  1484           return _dbus_socket_get_invalid ();
  1488   if (!_dbus_set_fd_nonblocking (fd.fd, error))
  1491       return _dbus_socket_get_invalid ();
  1522   int nlisten_fd = 0, res, i;
  1524   struct addrinfo hints;
  1525   struct addrinfo *ai, *tmp;
  1526   unsigned int reuseaddr;
  1529   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1534     hints.ai_family = AF_UNSPEC;
  1535   else if (!strcmp(family, 
"ipv4"))
  1536     hints.ai_family = AF_INET;
  1537   else if (!strcmp(family, 
"ipv6"))
  1538     hints.ai_family = AF_INET6;
  1543                       "Unknown address family %s", family);
  1547   hints.ai_protocol = IPPROTO_TCP;
  1548   hints.ai_socktype = SOCK_STREAM;
  1549   hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
  1551  redo_lookup_with_port:
  1553   if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
  1556                       _dbus_error_from_gai (res, errno),
  1557                       "Failed to lookup host/port: \"%s:%s\": %s (%d)",
  1558                       host ? host : 
"*", port, gai_strerror(res), res);
  1565       int fd = -1, tcp_nodelay_on;
  1568       if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
  1570           _DBUS_ASSERT_ERROR_IS_SET(error);
  1573       _DBUS_ASSERT_ERROR_IS_CLEAR(error);
  1576       if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, 
sizeof(reuseaddr))==-1)
  1578           _dbus_warn (
"Failed to set socket option \"%s:%s\": %s",
  1579                       host ? host : 
"*", port, _dbus_strerror (errno));
  1585       if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay_on, 
sizeof (tcp_nodelay_on)) == -1)
  1587           _dbus_warn (
"Failed to set TCP_NODELAY socket option \"%s:%s\": %s",
  1588                       host ? host : 
"*", port, _dbus_strerror (errno));
  1591       if (bind (fd, (
struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
  1593           saved_errno = errno;
  1595           if (saved_errno == EADDRINUSE)
  1613                           "Failed to bind socket \"%s:%s\": %s",
  1614                           host ? host : 
"*", port, _dbus_strerror (saved_errno));
  1618       if (listen (fd, 30 ) < 0)
  1620           saved_errno = errno;
  1623                           "Failed to listen on socket \"%s:%s\": %s",
  1624                           host ? host : 
"*", port, _dbus_strerror (saved_errno));
  1633                           "Failed to allocate file handle array");
  1636       listen_fd = newlisten_fd;
  1637       listen_fd[nlisten_fd].fd = fd;
  1640       if (!_dbus_string_get_length(retport))
  1646           if (!port || !strcmp(port, 
"0"))
  1649               struct sockaddr_storage addr;
  1653               addrlen = 
sizeof(addr);
  1654               result = getsockname(fd, (
struct sockaddr*) &addr, &addrlen);
  1658                   saved_errno = errno;
  1660                                   "Failed to retrieve socket name for \"%s:%s\": %s",
  1661                                   host ? host : 
"*", port, _dbus_strerror (saved_errno));
  1665               if ((res = getnameinfo ((
struct sockaddr*)&addr, addrlen, 
NULL, 0,
  1666                                       portbuf, 
sizeof(portbuf),
  1667                                       NI_NUMERICHOST | NI_NUMERICSERV)) != 0)
  1669                   saved_errno = errno;
  1671                                   "Failed to resolve port \"%s:%s\": %s (%d)",
  1672                                   host ? host : 
"*", port, gai_strerror(res), res);
  1683               port = _dbus_string_get_const_data(retport);
  1685               goto redo_lookup_with_port;
  1706                       "Failed to bind socket \"%s:%s\": %s",
  1707                       host ? host : 
"*", port, _dbus_strerror (errno));
  1711   for (i = 0 ; i < nlisten_fd ; i++)
  1713       if (!_dbus_set_fd_nonblocking (listen_fd[i].fd, error))
  1726   for (i = 0 ; i < nlisten_fd ; i++)
  1733 write_credentials_byte (
int             server_fd,
  1737   char buf[1] = { 
'\0' };
  1738 #if defined(HAVE_CMSGCRED)  1741           char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
  1752   msg.msg_control = (caddr_t) &cmsg;
  1753   msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
  1755   cmsg.hdr.cmsg_len = CMSG_LEN (
sizeof (
struct cmsgcred));
  1756   cmsg.hdr.cmsg_level = SOL_SOCKET;
  1757   cmsg.hdr.cmsg_type = SCM_CREDS;
  1760   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1764 #if defined(HAVE_CMSGCRED)  1765   bytes_written = sendmsg (server_fd, &msg, 0
  1766 #
if HAVE_DECL_MSG_NOSIGNAL
  1774   if (bytes_written < 0 && errno == EINVAL)
  1777       bytes_written = send (server_fd, buf, 1, 0
  1778 #
if HAVE_DECL_MSG_NOSIGNAL
  1784   if (bytes_written < 0 && errno == EINTR)
  1787   if (bytes_written < 0)
  1790                       "Failed to write credentials byte: %s",
  1791                      _dbus_strerror (errno));
  1794   else if (bytes_written == 0)
  1797                       "wrote zero bytes writing credentials byte");
  1803       _dbus_verbose (
"wrote credentials byte\n");
  1810 add_linux_security_label_to_credentials (
int              client_fd,
  1813 #if defined(__linux__) && defined(SO_PEERSEC)  1815   socklen_t len = 1024;
  1822   while (getsockopt (client_fd, SOL_SOCKET, SO_PEERSEC,
  1823          _dbus_string_get_data (&buf), &len) < 0)
  1827       _dbus_verbose (
"getsockopt failed with %s, len now %lu\n",
  1828                      _dbus_strerror (e), (
unsigned long) len);
  1830       if (e != ERANGE || len <= _dbus_string_get_length_uint (&buf))
  1832           _dbus_verbose (
"Failed to getsockopt(SO_PEERSEC): %s\n",
  1833                          _dbus_strerror (e));
  1845       _dbus_verbose (
"will try again with %lu\n", (
unsigned long) len);
  1850       _dbus_verbose (
"getsockopt(SO_PEERSEC) yielded <= 0 bytes: %lu\n",
  1851                      (
unsigned long) len);
  1855   if (len > _dbus_string_get_length_uint (&buf))
  1857       _dbus_verbose (
"%lu > %u", (
unsigned long) len,
  1858                      _dbus_string_get_length_uint (&buf));
  1862   if (_dbus_string_get_byte (&buf, len - 1) == 0)
  1866       _dbus_verbose (
"subtracting trailing \\0\n");
  1877   if (strlen (_dbus_string_get_const_data (&buf)) != len)
  1882       _dbus_verbose (
"security label from kernel had an embedded \\0, "  1887   _dbus_verbose (
"getsockopt(SO_PEERSEC): %lu bytes excluding \\0: %s\n",
  1888                  (
unsigned long) len,
  1889                  _dbus_string_get_const_data (&buf));
  1892         _dbus_string_get_const_data (&buf)))
  1959 #ifdef HAVE_CMSGCRED  1962     char cred[CMSG_SPACE (
sizeof (
struct cmsgcred))];
  1970   _DBUS_STATIC_ASSERT (
sizeof (pid_t) <= 
sizeof (
dbus_pid_t));
  1971   _DBUS_STATIC_ASSERT (
sizeof (uid_t) <= 
sizeof (
dbus_uid_t));
  1972   _DBUS_STATIC_ASSERT (
sizeof (gid_t) <= 
sizeof (
dbus_gid_t));
  1977   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1981   iov.iov_base = &buf;
  1988 #if defined(HAVE_CMSGCRED)  1990   msg.msg_control = (caddr_t) &cmsg;
  1991   msg.msg_controllen = CMSG_SPACE (
sizeof (
struct cmsgcred));
  1995   bytes_read = recvmsg (client_fd.fd, &msg, 0);
  2008                       "Failed to read credentials byte: %s",
  2009                       _dbus_strerror (errno));
  2012   else if (bytes_read == 0)
  2018                       "Failed to read credentials byte (zero-length read)");
  2021   else if (buf != 
'\0')
  2024                       "Credentials byte was not nul");
  2028   _dbus_verbose (
"read credentials byte\n");
  2041     struct sockpeercred cr;
  2045     socklen_t cr_len = 
sizeof (cr);
  2047     if (getsockopt (client_fd.fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) != 0)
  2049         _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED): %s\n",
  2050                        _dbus_strerror (errno));
  2052     else if (cr_len != 
sizeof (cr))
  2054         _dbus_verbose (
"Failed to getsockopt(SO_PEERCRED), returned %d bytes, expected %d\n",
  2055                        cr_len, (
int) 
sizeof (cr));
  2062 #elif defined(HAVE_UNPCBID) && defined(LOCAL_PEEREID)  2066     socklen_t cr_len = 
sizeof (cr);
  2068     if (getsockopt (client_fd.fd, 0, LOCAL_PEEREID, &cr, &cr_len) != 0)
  2070         _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID): %s\n",
  2071                        _dbus_strerror (errno));
  2073     else if (cr_len != 
sizeof (cr))
  2075         _dbus_verbose (
"Failed to getsockopt(LOCAL_PEEREID), returned %d bytes, expected %d\n",
  2076                        cr_len, (
int) 
sizeof (cr));
  2080         pid_read = cr.unp_pid;
  2081         uid_read = cr.unp_euid;
  2083 #elif defined(HAVE_CMSGCRED)  2092     struct cmsgcred *cred;
  2093     struct cmsghdr *cmsgp;
  2095     for (cmsgp = CMSG_FIRSTHDR (&msg);
  2097          cmsgp = CMSG_NXTHDR (&msg, cmsgp))
  2099         if (cmsgp->cmsg_type == SCM_CREDS &&
  2100             cmsgp->cmsg_level == SOL_SOCKET &&
  2101             cmsgp->cmsg_len >= CMSG_LEN (
sizeof (
struct cmsgcred)))
  2103             cred = (
struct cmsgcred *) CMSG_DATA (cmsgp);
  2104             pid_read = cred->cmcred_pid;
  2105             uid_read = cred->cmcred_euid;
  2110 #elif defined(HAVE_GETPEERUCRED)  2114     ucred_t * ucred = 
NULL;
  2115     if (getpeerucred (client_fd.fd, &ucred) == 0)
  2118         adt_session_data_t *adth = 
NULL;
  2120         pid_read = ucred_getpid (ucred);
  2121         uid_read = ucred_geteuid (ucred);
  2124         if (adt_start_session (&adth, 
NULL, 0) || (adth == 
NULL))
  2126             _dbus_verbose (
"Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
  2130             if (adt_set_from_ucred (adth, ucred, ADT_NEW))
  2132                 _dbus_verbose (
"Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
  2136                 adt_export_data_t *data = 
NULL;
  2137                 size_t size = adt_export_session_data (adth, &data);
  2140                     _dbus_verbose (
"Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
  2148             (void) adt_end_session (adth);
  2154         _dbus_verbose (
"Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
  2164 #elif defined(HAVE_GETPEEREID)  2182     if (getpeereid (client_fd.fd, &euid, &egid) == 0)
  2188         _dbus_verbose (
"Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
  2192 #warning Socket credentials not supported on this Unix OS  2193 #warning Please tell https://bugs.freedesktop.org/enter_bug.cgi?product=DBus  2199 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \  2200     defined(__linux__) || \  2201     defined(__OpenBSD__) || \  2203 # error Credentials passing not working on this OS is a regression!  2206     _dbus_verbose (
"Socket credentials not supported on this OS\n");
  2210   _dbus_verbose (
"Credentials:"  2221           _DBUS_SET_OOM (error);
  2230           _DBUS_SET_OOM (error);
  2235   if (!add_linux_security_label_to_credentials (client_fd.fd, credentials))
  2237       _DBUS_SET_OOM (error);
  2265   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  2267   if (write_credentials_byte (server_fd.fd, error))
  2286   struct sockaddr addr;
  2292   addrlen = 
sizeof (addr);
  2302   client_fd.fd = accept4 (listen_fd.fd, &addr, &addrlen, SOCK_CLOEXEC);
  2303   cloexec_done = client_fd.fd >= 0;
  2305   if (client_fd.fd < 0 && (errno == ENOSYS || errno == EINVAL))
  2308       client_fd.fd = accept (listen_fd.fd, &addr, &addrlen);
  2311   if (client_fd.fd < 0)
  2317   _dbus_verbose (
"client fd %d accepted\n", client_fd.fd);
  2340   const char *directory;
  2343   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  2345   directory = _dbus_string_get_const_data (dir);
  2347   if (stat (directory, &sb) < 0)
  2350                       "%s", _dbus_strerror (errno));
  2355   if (sb.st_uid != geteuid ())
  2358                      "%s directory is owned by user %lu, not %lu",
  2360                      (
unsigned long) sb.st_uid,
  2361                      (
unsigned long) geteuid ());
  2365   if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
  2366       (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
  2369                      "%s directory is not private to the user", directory);
  2377 fill_user_info_from_passwd (
struct passwd *p,
  2384   info->
uid = p->pw_uid;
  2405   const char *username_c;
  2418   if (username != 
NULL)
  2419     username_c = _dbus_string_get_const_data (username);
  2428 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)  2434     struct passwd p_str;
  2437     buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
  2443     if ((
long) buflen <= 0)
  2457 #ifdef HAVE_POSIX_GETPWNAM_R  2459           result = getpwuid_r (uid, &p_str, buf, buflen,
  2462           result = getpwnam_r (username_c, &p_str, buf, buflen,
  2466           p = getpwuid_r (uid, &p_str, buf, buflen);
  2468           p = getpwnam_r (username_c, &p_str, buf, buflen);
  2472         if (result == ERANGE && buflen < 512 * 1024)
  2482     if (result == 0 && p == &p_str)
  2484         if (!fill_user_info_from_passwd (p, info, error))
  2494                         "User \"%s\" unknown or no memory to allocate password entry\n",
  2495                         username_c ? username_c : 
"???");
  2496         _dbus_verbose (
"User %s unknown\n", username_c ? username_c : 
"???");
  2509       p = getpwnam (username_c);
  2513         if (!fill_user_info_from_passwd (p, info, error))
  2521                         "User \"%s\" unknown or no memory to allocate password entry\n",
  2522                         username_c ? username_c : 
"???");
  2523         _dbus_verbose (
"User %s unknown\n", username_c ? username_c : 
"???");
  2532 #ifdef HAVE_GETGROUPLIST  2537     int initial_buf_count;
  2539     initial_buf_count = 17;
  2540     buf_count = initial_buf_count;
  2548     if (getgrouplist (username_c,
  2550                       buf, &buf_count) < 0)
  2566         if (buf_count == initial_buf_count)
  2581         if (getgrouplist (username_c, info->
primary_gid, buf, &buf_count) < 0)
  2585                 _dbus_warn (
"It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
  2586                             username_c, buf_count, buf_count);
  2592                                 "Failed to get groups for username \"%s\" primary GID "  2595                                 _dbus_strerror (errno));
  2610     for (i = 0; i < buf_count; ++i)
  2633   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  2638   _DBUS_ASSERT_ERROR_IS_SET (error);
  2672   return fill_user_info (info, uid,
  2690   _DBUS_STATIC_ASSERT (
sizeof (pid_t) <= 
sizeof (
dbus_pid_t));
  2691   _DBUS_STATIC_ASSERT (
sizeof (uid_t) <= 
sizeof (
dbus_uid_t));
  2692   _DBUS_STATIC_ASSERT (
sizeof (gid_t) <= 
sizeof (
dbus_gid_t));
  2774   if (_dbus_string_get_length (uid_str) == 0)
  2776       _dbus_verbose (
"UID string was zero length\n");
  2785       _dbus_verbose (
"could not parse string as a UID\n");
  2789   if (end != _dbus_string_get_length (uid_str))
  2791       _dbus_verbose (
"string contained trailing stuff after UID\n");
  2806 static pthread_mutex_t atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
  2819   return __sync_add_and_fetch(&atomic->
value, 1)-1;
  2823   pthread_mutex_lock (&atomic_mutex);
  2824   res = atomic->
value;
  2826   pthread_mutex_unlock (&atomic_mutex);
  2842   return __sync_sub_and_fetch(&atomic->
value, 1)+1;
  2846   pthread_mutex_lock (&atomic_mutex);
  2847   res = atomic->
value;
  2849   pthread_mutex_unlock (&atomic_mutex);
  2866   __sync_synchronize ();
  2867   return atomic->
value;
  2871   pthread_mutex_lock (&atomic_mutex);
  2872   res = atomic->
value;
  2873   pthread_mutex_unlock (&atomic_mutex);
  2890             int         timeout_milliseconds)
  2892 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)  2894   if (timeout_milliseconds < -1)
  2896       timeout_milliseconds = -1;
  2901                timeout_milliseconds);
  2904   fd_set read_set, write_set, err_set;
  2910   FD_ZERO (&read_set);
  2911   FD_ZERO (&write_set);
  2914   for (i = 0; i < n_fds; i++)
  2919         FD_SET (fdp->
fd, &read_set);
  2922         FD_SET (fdp->
fd, &write_set);
  2924       FD_SET (fdp->
fd, &err_set);
  2926       max_fd = MAX (max_fd, fdp->
fd);
  2929   tv.tv_sec = timeout_milliseconds / 1000;
  2930   tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
  2932   ready = select (max_fd + 1, &read_set, &write_set, &err_set,
  2933                   timeout_milliseconds < 0 ? 
NULL : &tv);
  2937       for (i = 0; i < n_fds; i++)
  2943           if (FD_ISSET (fdp->
fd, &read_set))
  2946           if (FD_ISSET (fdp->
fd, &write_set))
  2949           if (FD_ISSET (fdp->
fd, &err_set))
  2969 #ifdef HAVE_MONOTONIC_CLOCK  2971   clock_gettime (CLOCK_MONOTONIC, &ts);
  2974     *tv_sec = ts.tv_sec;
  2976     *tv_usec = ts.tv_nsec / 1000;
  2980   gettimeofday (&t, 
NULL);
  2985     *tv_usec = t.tv_usec;
  3002   gettimeofday (&t, 
NULL);
  3007     *tv_usec = t.tv_usec;
  3022   const char *filename_c;
  3024   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  3026   filename_c = _dbus_string_get_const_data (filename);
  3028   if (mkdir (filename_c, 0700) < 0)
  3030       if (errno == EEXIST)
  3034                       "Failed to create directory %s: %s\n",
  3035                       filename_c, _dbus_strerror (errno));
  3054   const char *filename_c;
  3056   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  3058   filename_c = _dbus_string_get_const_data (filename);
  3060   if (mkdir (filename_c, 0700) < 0)
  3063                       "Failed to create directory %s: %s\n",
  3064                       filename_c, _dbus_strerror (errno));
  3088   if (_dbus_string_get_length (dir) == 0 ||
  3089       _dbus_string_get_length (next_component) == 0)
  3092   dir_ends_in_slash = 
'/' == _dbus_string_get_byte (dir,
  3093                                                     _dbus_string_get_length (dir) - 1);
  3095   file_starts_with_slash = 
'/' == _dbus_string_get_byte (next_component, 0);
  3097   if (dir_ends_in_slash && file_starts_with_slash)
  3101   else if (!(dir_ends_in_slash || file_starts_with_slash))
  3108                             _dbus_string_get_length (dir));
  3112 #define NANOSECONDS_PER_SECOND       1000000000  3114 #define MICROSECONDS_PER_SECOND      1000000  3116 #define MILLISECONDS_PER_SECOND      1000  3118 #define NANOSECONDS_PER_MILLISECOND  1000000  3120 #define MICROSECONDS_PER_MILLISECOND 1000  3129 #ifdef HAVE_NANOSLEEP  3130   struct timespec req;
  3131   struct timespec rem;
  3133   req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
  3134   req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
  3138   while (nanosleep (&req, &rem) < 0 && errno == EINTR)
  3140 #elif defined (HAVE_USLEEP)  3141   usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
  3143   sleep (MAX (milliseconds / 1000, 1));
  3165   old_len = _dbus_string_get_length (str);
  3169   fd = open (
"/dev/urandom", O_RDONLY);
  3174                       "Could not open /dev/urandom: %s",
  3175                       _dbus_strerror (errno));
  3179   _dbus_verbose (
"/dev/urandom fd %d opened\n", fd);
  3183   if (result != n_bytes)
  3187                         "Could not read /dev/urandom: %s",
  3188                         _dbus_strerror (errno));
  3191                         "Short read from /dev/urandom");
  3198   _dbus_verbose (
"Read %d bytes from /dev/urandom\n",
  3226 _dbus_strerror (
int error_number)
  3230   msg = strerror (error_number);
  3243   signal (SIGPIPE, SIG_IGN);
  3258   val = fcntl (fd, F_GETFD, 0);
  3265   fcntl (fd, F_SETFD, val);
  3279   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  3288                       "Could not close fd %d", fd);
  3309 #ifdef F_DUPFD_CLOEXEC  3312   new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
  3313   cloexec_done = new_fd >= 0;
  3315   if (new_fd < 0 && errno == EINVAL)
  3318       new_fd = fcntl(fd, F_DUPFD, 3);
  3324                     "Could not duplicate fd %d", fd);
  3328 #ifdef F_DUPFD_CLOEXEC  3349   return _dbus_set_fd_nonblocking (fd.fd, error);
  3353 _dbus_set_fd_nonblocking (
int             fd,
  3358   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  3360   val = fcntl (fd, F_GETFL, 0);
  3364                       "Failed to get flags from file descriptor %d: %s",
  3365                       fd, _dbus_strerror (errno));
  3366       _dbus_verbose (
"Failed to get flags for fd %d: %s\n", fd,
  3367                      _dbus_strerror (errno));
  3371   if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
  3374                       "Failed to set nonblocking flag of file descriptor %d: %s",
  3375                       fd, _dbus_strerror (errno));
  3376       _dbus_verbose (
"Failed to set fd %d nonblocking: %s\n",
  3377                      fd, _dbus_strerror (errno));
  3393 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)  3399   bt_size = backtrace (bt, 500);
  3401   syms = backtrace_symbols (bt, bt_size);
  3407       fprintf (stderr, 
"  %s\n", syms[i]);
  3413 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)  3414   fprintf (stderr, 
"  D-Bus not built with -rdynamic so unable to print a backtrace\n");
  3416   fprintf (stderr, 
"  D-Bus not compiled with backtrace support so unable to print a backtrace\n");
  3438 #ifdef HAVE_SOCKETPAIR  3445   retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
  3446   cloexec_done = retval >= 0;
  3448   if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
  3451       retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
  3457                       "Could not create full-duplex pipe");
  3461   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  3472       (!_dbus_set_fd_nonblocking (fds[0], 
NULL) ||
  3473        !_dbus_set_fd_nonblocking (fds[1], 
NULL)))
  3476                       "Could not set full-duplex pipe nonblocking");
  3487   _dbus_verbose (
"full-duplex pipe %d <-> %d\n",
  3492   _dbus_warn (
"_dbus_socketpair() not implemented on this OS");
  3494                   "_dbus_socketpair() not implemented on this OS");
  3511   char static_buf[1024];
  3512   int bufsize = 
sizeof (static_buf);
  3516   DBUS_VA_COPY (args_copy, args);
  3517   len = vsnprintf (static_buf, bufsize, format, args_copy);
  3534       DBUS_VA_COPY (args_copy, args);
  3536       if (vsnprintf (static_buf, 1, format, args_copy) == 1)
  3555       DBUS_VA_COPY (args_copy, args);
  3556       len = vsnprintf (buf, bufsize, format, args_copy);
  3581   static const char* tmpdir = 
NULL;
  3593         tmpdir = getenv(
"TMPDIR");
  3599         tmpdir = getenv(
"TMP");
  3601         tmpdir = getenv(
"TEMP");
  3615 #if defined(DBUS_ENABLE_X11_AUTOLAUNCH) || defined(DBUS_ENABLE_LAUNCHD)  3636 _read_subprocess_line_argv (
const char *progpath,
  3638                             const char * 
const *argv,
  3642   int result_pipe[2] = { -1, -1 };
  3643   int errors_pipe[2] = { -1, -1 };
  3650   sigset_t new_set, old_set;
  3652   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  3659   sigemptyset (&new_set);
  3660   sigaddset (&new_set, SIGCHLD);
  3661   sigprocmask (SIG_BLOCK, &new_set, &old_set);
  3663   orig_len = _dbus_string_get_length (result);
  3667   if (pipe (result_pipe) < 0)
  3670                       "Failed to create a pipe to call %s: %s",
  3671                       progpath, _dbus_strerror (errno));
  3672       _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
  3673                      progpath, _dbus_strerror (errno));
  3676   if (pipe (errors_pipe) < 0)
  3679                       "Failed to create a pipe to call %s: %s",
  3680                       progpath, _dbus_strerror (errno));
  3681       _dbus_verbose (
"Failed to create a pipe to call %s: %s\n",
  3682                      progpath, _dbus_strerror (errno));
  3690                       "Failed to fork() to call %s: %s",
  3691                       progpath, _dbus_strerror (errno));
  3692       _dbus_verbose (
"Failed to fork() to call %s: %s\n",
  3693                      progpath, _dbus_strerror (errno));
  3700       const char *error_str;
  3704           int saved_errno = errno;
  3709           if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0 ||
  3710               write (errors_pipe[
WRITE_END], 
": ", 2) < 0)
  3715           error_str = _dbus_strerror (saved_errno);
  3717           if (write (errors_pipe[
WRITE_END], error_str, strlen (error_str)) < 0)
  3729       if (dup2 (result_pipe[
WRITE_END], 1) == -1) 
  3731       if (dup2 (errors_pipe[
WRITE_END], 2) == -1) 
  3736       sigprocmask (SIG_SETMASK, &old_set, 
NULL);
  3739       if (progpath[0] == 
'/')
  3741           execv (progpath, (
char * 
const *) argv);
  3750             execvp (strrchr (progpath, 
'/')+1, (
char * 
const *) argv);
  3753         execvp (progpath, (
char * 
const *) argv);
  3775       ret = waitpid (pid, &status, 0);
  3777   while (ret == -1 && errno == EINTR);
  3781   if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
  3787           _DBUS_SET_OOM (error);
  3799       if (_dbus_string_get_length (&error_message) > 0)
  3801                         "%s terminated abnormally with the following error: %s",
  3802                         progpath, _dbus_string_get_data (&error_message));
  3805                         "%s terminated abnormally without any error message",
  3813   sigprocmask (SIG_SETMASK, &old_set, 
NULL);
  3816     _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  3818     _DBUS_ASSERT_ERROR_IS_SET (error);
  3820   if (result_pipe[0] != -1)
  3821     close (result_pipe[0]);
  3822   if (result_pipe[1] != -1)
  3823     close (result_pipe[1]);
  3824   if (errors_pipe[0] != -1)
  3825     close (errors_pipe[0]);
  3826   if (errors_pipe[1] != -1)
  3827     close (errors_pipe[1]);
  3850 #ifdef DBUS_ENABLE_X11_AUTOLAUNCH  3851   static const char arg_dbus_launch[] = 
"dbus-launch";
  3852   static const char arg_autolaunch[] = 
"--autolaunch";
  3853   static const char arg_binary_syntax[] = 
"--binary-syntax";
  3854   static const char arg_close_stderr[] = 
"--close-stderr";
  3859   const char *display;
  3860   const char *progpath;
  3861   const char *argv[6];
  3869                             "Unable to autolaunch when setuid");
  3873   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  3886   if (display == 
NULL || display[0] == 
'\0')
  3889           "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
  3895       _DBUS_SET_OOM (error);
  3904 #ifdef DBUS_ENABLE_EMBEDDED_TESTS  3907   if (progpath == 
NULL)
  3909     progpath = DBUS_BINDIR 
"/dbus-launch";
  3916   argv[i] = arg_dbus_launch;
  3918   argv[i] = arg_autolaunch;
  3920   argv[i] = _dbus_string_get_data (&uuid);
  3922   argv[i] = arg_binary_syntax;
  3924   argv[i] = arg_close_stderr;
  3931   retval = _read_subprocess_line_argv (progpath,
  3933                                        argv, address, error);
  3940       "Using X11 for dbus-daemon autolaunch was disabled at compile time, "  3941       "set your DBUS_SESSION_BUS_ADDRESS instead");
  3986       if (create_if_not_found)
  3998   if (!create_if_not_found)
  4001                       "D-Bus library appears to be incorrectly set up: "  4002                       "see the manual page for dbus-uuidgen to correct "  4003                       "this issue. (%s; %s)",
  4031                              const char *launchd_env_var,
  4034 #ifdef DBUS_ENABLE_LAUNCHD  4038   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  4043                             "Unable to find launchd socket when setuid");
  4048   argv[i] = 
"launchctl";
  4052   argv[i] = (
char*)launchd_env_var;
  4059   if (!_read_subprocess_line_argv(argv[0], 
TRUE, argv, socket_path, error))
  4065   if (_dbus_string_get_length(socket_path) == 0)
  4075                 "can't lookup socket from launchd; launchd support not compiled in");
  4080 #ifdef DBUS_ENABLE_LAUNCHD  4090                             "Unable to find launchd socket when setuid");
  4096       _DBUS_SET_OOM (error);
  4111                 "launchd did not provide a socket path, "  4112                 "verify that org.freedesktop.dbus-session.plist is loaded!");
  4118       _DBUS_SET_OOM (error);
  4123                           _dbus_string_get_length (address)))
  4125       _DBUS_SET_OOM (error);
  4140   const char *runtime_dir = 
_dbus_getenv (
"XDG_RUNTIME_DIR");
  4145   if (runtime_dir == 
NULL)
  4147       _dbus_verbose (
"XDG_RUNTIME_DIR not found in environment");
  4154       _DBUS_SET_OOM (error);
  4160       _DBUS_SET_OOM (error);
  4164   if (lstat (_dbus_string_get_const_data (&user_bus_path), &stbuf) == -1)
  4166       _dbus_verbose (
"XDG_RUNTIME_DIR/bus not available: %s",
  4167                      _dbus_strerror (errno));
  4173   if (stbuf.st_uid != getuid ())
  4175       _dbus_verbose (
"XDG_RUNTIME_DIR/bus owned by uid %ld, not our uid %ld",
  4176                      (
long) stbuf.st_uid, (
long) getuid ());
  4182   if ((stbuf.st_mode & S_IFMT) != S_IFSOCK)
  4184       _dbus_verbose (
"XDG_RUNTIME_DIR/bus is not a socket: st_mode = 0o%lo",
  4185                      (
long) stbuf.st_mode);
  4194       _DBUS_SET_OOM (error);
  4230 #ifdef DBUS_ENABLE_LAUNCHD  4232   return _dbus_lookup_session_address_launchd (address, error);
  4236   if (!_dbus_lookup_user_bus (supported, address, error))
  4238   else if (*supported)
  4296 #ifdef DBUS_ENABLE_EMBEDDED_TESTS  4298     const char *
override;
  4301     if (
override != 
NULL && *
override != 
'\0')
  4307         _dbus_verbose (
"Using fake homedir for testing: %s\n",
  4308                        _dbus_string_get_const_data (&homedir));
  4315         if (!already_warned)
  4317             _dbus_warn (
"Using %s for testing, set DBUS_TEST_HOMEDIR to avoid",
  4318                 _dbus_string_get_const_data (&homedir));
  4319             already_warned = 
TRUE;
  4331                           directory, _dbus_string_get_length (directory))) {
  4345 _dbus_daemon_publish_session_bus_address (
const char* addr,
  4353 _dbus_daemon_unpublish_session_bus_address (
void)
  4367   return e == EAGAIN || e == EWOULDBLOCK;
  4381   const char *filename_c;
  4383   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  4385   filename_c = _dbus_string_get_const_data (filename);
  4387   if (rmdir (filename_c) != 0)
  4390                       "Failed to remove directory %s: %s\n",
  4391                       filename_c, _dbus_strerror (errno));
  4411     struct sockaddr_storage storage;
  4412     struct sockaddr_un un;
  4415   socklen_t sa_len = 
sizeof(sa_buf);
  4419   if (getsockname(fd.fd, &sa_buf.sa, &sa_len) < 0)
  4422   return sa_buf.sa.sa_family == AF_UNIX;
  4445   d = opendir (
"/proc/self/fd");
  4459           if (de->d_name[0] == 
'.')
  4463           l = strtol (de->d_name, &e, 10);
  4464           if (errno != 0 || e == 
NULL || *e != 
'\0')
  4471           if (fd == dirfd (d))
  4482   maxfds = sysconf (_SC_OPEN_MAX);
  4491   for (i = 3; i < maxfds; i++)
  4510 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE)  4513     extern int __libc_enable_secure;
  4514     return __libc_enable_secure;
  4516 #elif defined(HAVE_ISSETUGID)  4518   return issetugid ();
  4520   uid_t ruid, euid, suid; 
  4521   gid_t rgid, egid, sgid; 
  4528   if (_DBUS_UNLIKELY (!check_setuid_initialised))
  4530 #ifdef HAVE_GETRESUID  4531       if (getresuid (&ruid, &euid, &suid) != 0 ||
  4532           getresgid (&rgid, &egid, &sgid) != 0)
  4535           suid = ruid = getuid ();
  4536           sgid = rgid = getgid ();
  4541       check_setuid_initialised = 
TRUE;
  4542       is_setuid = (ruid != euid || ruid != suid ||
  4543                    rgid != egid || rgid != sgid);
  4564       struct sockaddr_storage storage;
  4565       struct sockaddr_un un;
  4566       struct sockaddr_in ipv4;
  4567       struct sockaddr_in6 ipv6;
  4569   char hostip[INET6_ADDRSTRLEN];
  4570   socklen_t size = 
sizeof (socket);
  4573   if (getsockname (fd.fd, &socket.sa, &size))
  4576   switch (socket.sa.sa_family)
  4579       if (socket.un.sun_path[0]==
'\0')
  4595       if (inet_ntop (AF_INET, &socket.ipv4.sin_addr, hostip, sizeof (hostip)))
  4597                                         hostip, ntohs (socket.ipv4.sin_port)))
  4603       if (inet_ntop (AF_INET6, &socket.ipv6.sin6_addr, hostip, sizeof (hostip)))
  4605                                         ntohs (socket.ipv6.sin6_port)) &&
  4613                       "Failed to read address from socket: Unknown socket type.");
  4619                   "Failed to open socket: %s",
  4620                   _dbus_strerror (errno));
  4625 _dbus_save_socket_errno (
void)
  4631 _dbus_restore_socket_errno (
int saved_errno)
  4633   errno = saved_errno;
  4636 static const char *syslog_tag = 
"dbus";
  4637 #ifdef HAVE_SYSLOG_H  4638 static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
  4661       (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
  4665 #ifdef HAVE_SYSLOG_H  4668   if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
  4669     openlog (tag, LOG_PID, LOG_DAEMON);
  4686 #ifdef HAVE_SYSLOG_H  4687   if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
  4692           case DBUS_SYSTEM_LOG_INFO:
  4693             flags =  LOG_DAEMON | LOG_INFO;
  4695           case DBUS_SYSTEM_LOG_WARNING:
  4696             flags =  LOG_DAEMON | LOG_WARNING;
  4698           case DBUS_SYSTEM_LOG_SECURITY:
  4699             flags = LOG_AUTH | LOG_NOTICE;
  4701           case DBUS_SYSTEM_LOG_ERROR:
  4702             flags = LOG_DAEMON|LOG_CRIT;
  4708       DBUS_VA_COPY (tmp, args);
  4709       vsyslog (flags, msg, tmp);
  4715   if (log_flags & DBUS_LOG_FLAGS_STDERR)
  4718       DBUS_VA_COPY (tmp, args);
  4720       vfprintf (stderr, msg, tmp);
  4721       fputc (
'\n', stderr);
 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. 
const char * message
public error message field 
#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. 
dbus_bool_t _dbus_read_local_machine_uuid(DBusGUID *machine_id, dbus_bool_t create_if_not_found, DBusError *error)
Reads the uuid of the machine we're running on from the dbus configuration. 
void _dbus_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. 
dbus_bool_t _dbus_ensure_directory(const DBusString *filename, DBusError *error)
Creates a directory; succeeds if the directory is created or already existed. 
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 ...
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 ...
#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. 
#define _dbus_assert(condition)
Aborts with an error message if the condition is false. 
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. 
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack. 
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. 
#define DBUS_MAXIMUM_MESSAGE_UNIX_FDS
The maximum total number of unix fds in a message. 
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. 
dbus_gid_t * group_ids
Groups IDs, including above primary group. 
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...
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer. 
void _dbus_print_backtrace(void)
On GNU libc systems, print a crude backtrace to stderr. 
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. 
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. 
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof(). 
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. 
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. 
#define _DBUS_UNLOCK(name)
Unlocks a global lock. 
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(). 
#define DBUS_GID_UNSET
an invalid GID used to represent an uninitialized dbus_gid_t field 
dbus_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. 
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called. 
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. 
const char * name
public error name field 
#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. 
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer. 
dbus_uid_t _dbus_getuid(void)
Gets our UID. 
void _dbus_init_system_log(const char *tag, DBusLogFlags flags)
Initialize the system log. 
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. 
void _dbus_logv(DBusSystemLogSeverity severity, const char *msg, va_list args)
Log a message to the system log file (e.g. 
#define FALSE
Expands to "0". 
dbus_bool_t _dbus_write_uuid_file(const DBusString *filename, const DBusGUID *uuid, DBusError *error)
Write the give UUID to a file. 
void dbus_set_error_const(DBusError *error, const char *name, const char *message)
Assigns an error name and message to a DBusError. 
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string. 
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary. 
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. 
dbus_int32_t _dbus_atomic_get(DBusAtomic *atomic)
Atomically get the value of an integer. 
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. 
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.