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)
 
 4371 #if EAGAIN == EWOULDBLOCK 
 4374   return e == EAGAIN || e == EWOULDBLOCK;
 
 4389   const char *filename_c;
 
 4391   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
 4393   filename_c = _dbus_string_get_const_data (filename);
 
 4395   if (rmdir (filename_c) != 0)
 
 4398                       "Failed to remove directory %s: %s\n",
 
 4399                       filename_c, _dbus_strerror (errno));
 
 4419     struct sockaddr_storage storage;
 
 4420     struct sockaddr_un un;
 
 4423   socklen_t sa_len = 
sizeof(sa_buf);
 
 4427   if (getsockname(fd.fd, &sa_buf.sa, &sa_len) < 0)
 
 4430   return sa_buf.sa.sa_family == AF_UNIX;
 
 4453   d = opendir (
"/proc/self/fd");
 
 4467           if (de->d_name[0] == 
'.')
 
 4471           l = strtol (de->d_name, &e, 10);
 
 4472           if (errno != 0 || e == 
NULL || *e != 
'\0')
 
 4479           if (fd == dirfd (d))
 
 4490   maxfds = sysconf (_SC_OPEN_MAX);
 
 4499   for (i = 3; i < maxfds; i++)
 
 4518 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE) 
 4521     extern int __libc_enable_secure;
 
 4522     return __libc_enable_secure;
 
 4524 #elif defined(HAVE_ISSETUGID) 
 4526   return issetugid ();
 
 4528   uid_t ruid, euid, suid; 
 
 4529   gid_t rgid, egid, sgid; 
 
 4536   if (_DBUS_UNLIKELY (!check_setuid_initialised))
 
 4538 #ifdef HAVE_GETRESUID 
 4539       if (getresuid (&ruid, &euid, &suid) != 0 ||
 
 4540           getresgid (&rgid, &egid, &sgid) != 0)
 
 4543           suid = ruid = getuid ();
 
 4544           sgid = rgid = getgid ();
 
 4549       check_setuid_initialised = 
TRUE;
 
 4550       is_setuid = (ruid != euid || ruid != suid ||
 
 4551                    rgid != egid || rgid != sgid);
 
 4572       struct sockaddr_storage storage;
 
 4573       struct sockaddr_un un;
 
 4574       struct sockaddr_in ipv4;
 
 4575       struct sockaddr_in6 ipv6;
 
 4577   char hostip[INET6_ADDRSTRLEN];
 
 4578   socklen_t size = 
sizeof (socket);
 
 4581   if (getsockname (fd.fd, &socket.sa, &size))
 
 4584   switch (socket.sa.sa_family)
 
 4587       if (socket.un.sun_path[0]==
'\0')
 
 4603       if (inet_ntop (AF_INET, &socket.ipv4.sin_addr, hostip, sizeof (hostip)))
 
 4605                                         hostip, ntohs (socket.ipv4.sin_port)))
 
 4611       if (inet_ntop (AF_INET6, &socket.ipv6.sin6_addr, hostip, sizeof (hostip)))
 
 4613                                         ntohs (socket.ipv6.sin6_port)) &&
 
 4621                       "Failed to read address from socket: Unknown socket type.");
 
 4627                   "Failed to open socket: %s",
 
 4628                   _dbus_strerror (errno));
 
 4633 _dbus_save_socket_errno (
void)
 
 4639 _dbus_restore_socket_errno (
int saved_errno)
 
 4641   errno = saved_errno;
 
 4644 static const char *syslog_tag = 
"dbus";
 
 4645 #ifdef HAVE_SYSLOG_H 
 4646 static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
 
 4669       (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
 
 4673 #ifdef HAVE_SYSLOG_H 
 4676   if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
 
 4677     openlog (tag, LOG_PID, LOG_DAEMON);
 
 4694 #ifdef HAVE_SYSLOG_H 
 4695   if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
 
 4700           case DBUS_SYSTEM_LOG_INFO:
 
 4701             flags =  LOG_DAEMON | LOG_INFO;
 
 4703           case DBUS_SYSTEM_LOG_WARNING:
 
 4704             flags =  LOG_DAEMON | LOG_WARNING;
 
 4706           case DBUS_SYSTEM_LOG_SECURITY:
 
 4707             flags = LOG_AUTH | LOG_NOTICE;
 
 4709           case DBUS_SYSTEM_LOG_ERROR:
 
 4710             flags = LOG_DAEMON|LOG_CRIT;
 
 4716       DBUS_VA_COPY (tmp, args);
 
 4717       vsyslog (flags, msg, tmp);
 
 4723   if (log_flags & DBUS_LOG_FLAGS_STDERR)
 
 4726       DBUS_VA_COPY (tmp, args);
 
 4728       vfprintf (stderr, msg, tmp);
 
 4729       fputc (
'\n', stderr);