D-Bus  1.12.16
dbus-sysdeps-unix.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-sysdeps-unix.c Wrappers around UNIX system/libc features (internal to D-Bus implementation)
3  *
4  * Copyright (C) 2002, 2003, 2006 Red Hat, Inc.
5  * Copyright (C) 2003 CodeFactory AB
6  *
7  * Licensed under the Academic Free License version 2.1
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  */
24 
25 #include <config.h>
26 
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"
39 
40 #include <sys/types.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <signal.h>
44 #include <unistd.h>
45 #include <stdio.h>
46 #include <fcntl.h>
47 #include <sys/socket.h>
48 #include <dirent.h>
49 #include <sys/un.h>
50 #include <pwd.h>
51 #include <time.h>
52 #include <locale.h>
53 #include <sys/time.h>
54 #include <sys/stat.h>
55 #include <sys/wait.h>
56 #include <netinet/in.h>
57 #include <netinet/tcp.h>
58 #include <netdb.h>
59 #include <grp.h>
60 #include <arpa/inet.h>
61 
62 #ifdef HAVE_ERRNO_H
63 #include <errno.h>
64 #endif
65 #ifdef HAVE_SYSLOG_H
66 #include <syslog.h>
67 #endif
68 #ifdef HAVE_WRITEV
69 #include <sys/uio.h>
70 #endif
71 #ifdef HAVE_POLL
72 #include <sys/poll.h>
73 #endif
74 #ifdef HAVE_BACKTRACE
75 #include <execinfo.h>
76 #endif
77 #ifdef HAVE_GETPEERUCRED
78 #include <ucred.h>
79 #endif
80 #ifdef HAVE_ALLOCA_H
81 #include <alloca.h>
82 #endif
83 
84 #ifdef HAVE_ADT
85 #include <bsm/adt.h>
86 #endif
87 
88 #ifdef HAVE_SYSTEMD
89 #include <systemd/sd-daemon.h>
90 #endif
91 
92 #if !DBUS_USE_SYNC
93 #include <pthread.h>
94 #endif
95 
96 #ifndef O_BINARY
97 #define O_BINARY 0
98 #endif
99 
100 #ifndef AI_ADDRCONFIG
101 #define AI_ADDRCONFIG 0
102 #endif
103 
104 #ifndef HAVE_SOCKLEN_T
105 #define socklen_t int
106 #endif
107 
108 #if defined (__sun) || defined (__sun__)
109 /*
110  * CMS_SPACE etc. definitions for Solaris < 10, based on
111  * http://mailman.videolan.org/pipermail/vlc-devel/2006-May/024402.html
112  * via
113  * http://wiki.opencsw.org/porting-faq#toc10
114  *
115  * These are only redefined for Solaris, for now: if your OS needs these too,
116  * please file a bug. (Or preferably, improve your OS so they're not needed.)
117  */
118 
119 # ifndef CMSG_ALIGN
120 # ifdef __sun__
121 # define CMSG_ALIGN(len) _CMSG_DATA_ALIGN (len)
122 # else
123  /* aligning to sizeof (long) is assumed to be portable (fd.o#40235) */
124 # define CMSG_ALIGN(len) (((len) + sizeof (long) - 1) & \
125  ~(sizeof (long) - 1))
126 # endif
127 # endif
128 
129 # ifndef CMSG_SPACE
130 # define CMSG_SPACE(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + \
131  CMSG_ALIGN (len))
132 # endif
133 
134 # ifndef CMSG_LEN
135 # define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
136 # endif
137 
138 #endif /* Solaris */
139 
155 _dbus_ensure_standard_fds (DBusEnsureStandardFdsFlags flags,
156  const char **error_str_p)
157 {
158  static int const relevant_flag[] = { DBUS_FORCE_STDIN_NULL,
159  DBUS_FORCE_STDOUT_NULL,
160  DBUS_FORCE_STDERR_NULL };
161  /* Should always get replaced with the real error before use */
162  const char *error_str = "Failed mysteriously";
163  int devnull = -1;
164  int saved_errno;
165  /* This function relies on the standard fds having their POSIX values. */
166  _DBUS_STATIC_ASSERT (STDIN_FILENO == 0);
167  _DBUS_STATIC_ASSERT (STDOUT_FILENO == 1);
168  _DBUS_STATIC_ASSERT (STDERR_FILENO == 2);
169  int i;
170 
171  for (i = STDIN_FILENO; i <= STDERR_FILENO; i++)
172  {
173  /* Because we rely on being single-threaded, and we want the
174  * standard fds to not be close-on-exec, we don't set it
175  * close-on-exec. */
176  if (devnull < i)
177  devnull = open ("/dev/null", O_RDWR);
178 
179  if (devnull < 0)
180  {
181  error_str = "Failed to open /dev/null";
182  goto out;
183  }
184 
185  /* We already opened all fds < i, so the only way this assertion
186  * could fail is if another thread closed one, and we document
187  * this function as not safe for multi-threading. */
188  _dbus_assert (devnull >= i);
189 
190  if (devnull != i && (flags & relevant_flag[i]) != 0)
191  {
192  if (dup2 (devnull, i) < 0)
193  {
194  error_str = "Failed to dup2 /dev/null onto a standard fd";
195  goto out;
196  }
197  }
198  }
199 
200  error_str = NULL;
201 
202 out:
203  saved_errno = errno;
204 
205  if (devnull > STDERR_FILENO)
206  close (devnull);
207 
208  if (error_str_p != NULL)
209  *error_str_p = error_str;
210 
211  errno = saved_errno;
212  return (error_str == NULL);
213 }
214 
215 static dbus_bool_t _dbus_set_fd_nonblocking (int fd,
216  DBusError *error);
217 
218 static dbus_bool_t
219 _dbus_open_socket (int *fd_p,
220  int domain,
221  int type,
222  int protocol,
223  DBusError *error)
224 {
225 #ifdef SOCK_CLOEXEC
226  dbus_bool_t cloexec_done;
227 
228  *fd_p = socket (domain, type | SOCK_CLOEXEC, protocol);
229  cloexec_done = *fd_p >= 0;
230 
231  /* Check if kernel seems to be too old to know SOCK_CLOEXEC */
232  if (*fd_p < 0 && (errno == EINVAL || errno == EPROTOTYPE))
233 #endif
234  {
235  *fd_p = socket (domain, type, protocol);
236  }
237 
238  if (*fd_p >= 0)
239  {
240 #ifdef SOCK_CLOEXEC
241  if (!cloexec_done)
242 #endif
243  {
245  }
246 
247  _dbus_verbose ("socket fd %d opened\n", *fd_p);
248  return TRUE;
249  }
250  else
251  {
252  dbus_set_error(error,
253  _dbus_error_from_errno (errno),
254  "Failed to open socket: %s",
255  _dbus_strerror (errno));
256  return FALSE;
257  }
258 }
259 
270 static dbus_bool_t
271 _dbus_open_unix_socket (int *fd,
272  DBusError *error)
273 {
274  return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);
275 }
276 
287  DBusError *error)
288 {
289  return _dbus_close (fd.fd, error);
290 }
291 
301 int
303  DBusString *buffer,
304  int count)
305 {
306  return _dbus_read (fd.fd, buffer, count);
307 }
308 
319 int
321  const DBusString *buffer,
322  int start,
323  int len)
324 {
325 #if HAVE_DECL_MSG_NOSIGNAL
326  const char *data;
327  int bytes_written;
328 
329  data = _dbus_string_get_const_data_len (buffer, start, len);
330 
331  again:
332 
333  bytes_written = send (fd.fd, data, len, MSG_NOSIGNAL);
334 
335  if (bytes_written < 0 && errno == EINTR)
336  goto again;
337 
338  return bytes_written;
339 
340 #else
341  return _dbus_write (fd.fd, buffer, start, len);
342 #endif
343 }
344 
357 int
359  DBusString *buffer,
360  int count,
361  int *fds,
362  unsigned int *n_fds) {
363 #ifndef HAVE_UNIX_FD_PASSING
364  int r;
365 
366  if ((r = _dbus_read_socket(fd, buffer, count)) < 0)
367  return r;
368 
369  *n_fds = 0;
370  return r;
371 
372 #else
373  int bytes_read;
374  int start;
375  struct msghdr m;
376  struct iovec iov;
377 
378  _dbus_assert (count >= 0);
380 
381  start = _dbus_string_get_length (buffer);
382 
383  if (!_dbus_string_lengthen (buffer, count))
384  {
385  errno = ENOMEM;
386  return -1;
387  }
388 
389  _DBUS_ZERO(iov);
390  iov.iov_base = _dbus_string_get_data_len (buffer, start, count);
391  iov.iov_len = count;
392 
393  _DBUS_ZERO(m);
394  m.msg_iov = &iov;
395  m.msg_iovlen = 1;
396 
397  /* Hmm, we have no clue how long the control data will actually be
398  that is queued for us. The least we can do is assume that the
399  caller knows. Hence let's make space for the number of fds that
400  we shall read at max plus the cmsg header. */
401  m.msg_controllen = CMSG_SPACE(*n_fds * sizeof(int));
402 
403  /* It's probably safe to assume that systems with SCM_RIGHTS also
404  know alloca() */
405  m.msg_control = alloca(m.msg_controllen);
406  memset(m.msg_control, 0, m.msg_controllen);
407 
408  /* Do not include the padding at the end when we tell the kernel
409  * how much we're willing to receive. This avoids getting
410  * the padding filled with additional fds that we weren't expecting,
411  * if a (potentially malicious) sender included them. (fd.o #83622) */
412  m.msg_controllen = CMSG_LEN (*n_fds * sizeof(int));
413 
414  again:
415 
416  bytes_read = recvmsg (fd.fd, &m, 0
417 #ifdef MSG_CMSG_CLOEXEC
418  |MSG_CMSG_CLOEXEC
419 #endif
420  );
421 
422  if (bytes_read < 0)
423  {
424  if (errno == EINTR)
425  goto again;
426  else
427  {
428  /* put length back (note that this doesn't actually realloc anything) */
429  _dbus_string_set_length (buffer, start);
430  return -1;
431  }
432  }
433  else
434  {
435  struct cmsghdr *cm;
436  dbus_bool_t found = FALSE;
437 
438  for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
439  if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS)
440  {
441  size_t i;
442  int *payload = (int *) CMSG_DATA (cm);
443  size_t payload_len_bytes = (cm->cmsg_len - CMSG_LEN (0));
444  size_t payload_len_fds;
445  size_t fds_to_use;
446 
447  /* Every unsigned int fits in a size_t without truncation, so
448  * casting (size_t) *n_fds is OK */
449  _DBUS_STATIC_ASSERT (sizeof (size_t) >= sizeof (unsigned int));
450 
451  if ((m.msg_flags & MSG_CTRUNC) && CMSG_NXTHDR(&m, cm) == NULL &&
452  (char *) payload + payload_len_bytes >
453  (char *) m.msg_control + m.msg_controllen)
454  {
455  /* This is the last cmsg in a truncated message and using
456  * cmsg_len would apparently overrun the allocated buffer.
457  * Some operating systems (illumos and Solaris are known) do
458  * not adjust cmsg_len in the last cmsg when truncation occurs.
459  * Adjust the payload length here. The calculation for
460  * payload_len_fds below will discard any trailing bytes that
461  * belong to an incomplete file descriptor - the kernel will
462  * have already closed that (at least for illumos and Solaris)
463  */
464  payload_len_bytes = m.msg_controllen -
465  ((char *) payload - (char *) m.msg_control);
466  }
467 
468  payload_len_fds = payload_len_bytes / sizeof (int);
469 
470  if (_DBUS_LIKELY (payload_len_fds <= (size_t) *n_fds))
471  {
472  /* The fds in the payload will fit in our buffer */
473  fds_to_use = payload_len_fds;
474  }
475  else
476  {
477  /* Too many fds in the payload. This shouldn't happen
478  * any more because we're setting m.msg_controllen to
479  * the exact number we can accept, but be safe and
480  * truncate. */
481  fds_to_use = (size_t) *n_fds;
482 
483  /* Close the excess fds to avoid DoS: if they stayed open,
484  * someone could send us an extra fd per message
485  * and we'd eventually run out. */
486  for (i = fds_to_use; i < payload_len_fds; i++)
487  {
488  close (payload[i]);
489  }
490  }
491 
492  memcpy (fds, payload, fds_to_use * sizeof (int));
493  found = TRUE;
494  /* This narrowing cast from size_t to unsigned int cannot
495  * overflow because we have chosen fds_to_use
496  * to be <= *n_fds */
497  *n_fds = (unsigned int) fds_to_use;
498 
499  /* Linux doesn't tell us whether MSG_CMSG_CLOEXEC actually
500  worked, hence we need to go through this list and set
501  CLOEXEC everywhere in any case */
502  for (i = 0; i < fds_to_use; i++)
504 
505  break;
506  }
507 
508  if (!found)
509  *n_fds = 0;
510 
511  if (m.msg_flags & MSG_CTRUNC)
512  {
513  unsigned int i;
514 
515  /* Hmm, apparently the control data was truncated. The bad
516  thing is that we might have completely lost a couple of fds
517  without chance to recover them. Hence let's treat this as a
518  serious error. */
519 
520  /* We still need to close whatever fds we *did* receive,
521  * otherwise they'll never get closed. (CVE-2020-12049) */
522  for (i = 0; i < *n_fds; i++)
523  close (fds[i]);
524 
525  *n_fds = 0;
526  errno = ENOSPC;
527  _dbus_string_set_length (buffer, start);
528  return -1;
529  }
530 
531  /* put length back (doesn't actually realloc) */
532  _dbus_string_set_length (buffer, start + bytes_read);
533 
534 #if 0
535  if (bytes_read > 0)
536  _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
537 #endif
538 
539  return bytes_read;
540  }
541 #endif
542 }
543 
544 int
545 _dbus_write_socket_with_unix_fds(DBusSocket fd,
546  const DBusString *buffer,
547  int start,
548  int len,
549  const int *fds,
550  int n_fds) {
551 
552 #ifndef HAVE_UNIX_FD_PASSING
553 
554  if (n_fds > 0) {
555  errno = ENOTSUP;
556  return -1;
557  }
558 
559  return _dbus_write_socket(fd, buffer, start, len);
560 #else
561  return _dbus_write_socket_with_unix_fds_two(fd, buffer, start, len, NULL, 0, 0, fds, n_fds);
562 #endif
563 }
564 
565 int
566 _dbus_write_socket_with_unix_fds_two(DBusSocket fd,
567  const DBusString *buffer1,
568  int start1,
569  int len1,
570  const DBusString *buffer2,
571  int start2,
572  int len2,
573  const int *fds,
574  int n_fds) {
575 
576 #ifndef HAVE_UNIX_FD_PASSING
577 
578  if (n_fds > 0) {
579  errno = ENOTSUP;
580  return -1;
581  }
582 
583  return _dbus_write_socket_two(fd,
584  buffer1, start1, len1,
585  buffer2, start2, len2);
586 #else
587 
588  struct msghdr m;
589  struct cmsghdr *cm;
590  struct iovec iov[2];
591  int bytes_written;
592 
593  _dbus_assert (len1 >= 0);
594  _dbus_assert (len2 >= 0);
595  _dbus_assert (n_fds >= 0);
596 
597  _DBUS_ZERO(iov);
598  iov[0].iov_base = (char*) _dbus_string_get_const_data_len (buffer1, start1, len1);
599  iov[0].iov_len = len1;
600 
601  if (buffer2)
602  {
603  iov[1].iov_base = (char*) _dbus_string_get_const_data_len (buffer2, start2, len2);
604  iov[1].iov_len = len2;
605  }
606 
607  _DBUS_ZERO(m);
608  m.msg_iov = iov;
609  m.msg_iovlen = buffer2 ? 2 : 1;
610 
611  if (n_fds > 0)
612  {
613  m.msg_controllen = CMSG_SPACE(n_fds * sizeof(int));
614  m.msg_control = alloca(m.msg_controllen);
615  memset(m.msg_control, 0, m.msg_controllen);
616 
617  cm = CMSG_FIRSTHDR(&m);
618  cm->cmsg_level = SOL_SOCKET;
619  cm->cmsg_type = SCM_RIGHTS;
620  cm->cmsg_len = CMSG_LEN(n_fds * sizeof(int));
621  memcpy(CMSG_DATA(cm), fds, n_fds * sizeof(int));
622  }
623 
624  again:
625 
626  bytes_written = sendmsg (fd.fd, &m, 0
627 #if HAVE_DECL_MSG_NOSIGNAL
628  |MSG_NOSIGNAL
629 #endif
630  );
631 
632  if (bytes_written < 0 && errno == EINTR)
633  goto again;
634 
635 #if 0
636  if (bytes_written > 0)
637  _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
638 #endif
639 
640  return bytes_written;
641 #endif
642 }
643 
657 int
659  const DBusString *buffer1,
660  int start1,
661  int len1,
662  const DBusString *buffer2,
663  int start2,
664  int len2)
665 {
666 #if HAVE_DECL_MSG_NOSIGNAL
667  struct iovec vectors[2];
668  const char *data1;
669  const char *data2;
670  int bytes_written;
671  struct msghdr m;
672 
673  _dbus_assert (buffer1 != NULL);
674  _dbus_assert (start1 >= 0);
675  _dbus_assert (start2 >= 0);
676  _dbus_assert (len1 >= 0);
677  _dbus_assert (len2 >= 0);
678 
679  data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
680 
681  if (buffer2 != NULL)
682  data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
683  else
684  {
685  data2 = NULL;
686  start2 = 0;
687  len2 = 0;
688  }
689 
690  vectors[0].iov_base = (char*) data1;
691  vectors[0].iov_len = len1;
692  vectors[1].iov_base = (char*) data2;
693  vectors[1].iov_len = len2;
694 
695  _DBUS_ZERO(m);
696  m.msg_iov = vectors;
697  m.msg_iovlen = data2 ? 2 : 1;
698 
699  again:
700 
701  bytes_written = sendmsg (fd.fd, &m, MSG_NOSIGNAL);
702 
703  if (bytes_written < 0 && errno == EINTR)
704  goto again;
705 
706  return bytes_written;
707 
708 #else
709  return _dbus_write_two (fd.fd, buffer1, start1, len1,
710  buffer2, start2, len2);
711 #endif
712 }
713 
730 int
731 _dbus_read (int fd,
732  DBusString *buffer,
733  int count)
734 {
735  int bytes_read;
736  int start;
737  char *data;
738 
739  _dbus_assert (count >= 0);
740 
741  start = _dbus_string_get_length (buffer);
742 
743  if (!_dbus_string_lengthen (buffer, count))
744  {
745  errno = ENOMEM;
746  return -1;
747  }
748 
749  data = _dbus_string_get_data_len (buffer, start, count);
750 
751  again:
752 
753  bytes_read = read (fd, data, count);
754 
755  if (bytes_read < 0)
756  {
757  if (errno == EINTR)
758  goto again;
759  else
760  {
761  /* put length back (note that this doesn't actually realloc anything) */
762  _dbus_string_set_length (buffer, start);
763  return -1;
764  }
765  }
766  else
767  {
768  /* put length back (doesn't actually realloc) */
769  _dbus_string_set_length (buffer, start + bytes_read);
770 
771 #if 0
772  if (bytes_read > 0)
773  _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
774 #endif
775 
776  return bytes_read;
777  }
778 }
779 
790 int
791 _dbus_write (int fd,
792  const DBusString *buffer,
793  int start,
794  int len)
795 {
796  const char *data;
797  int bytes_written;
798 
799  data = _dbus_string_get_const_data_len (buffer, start, len);
800 
801  again:
802 
803  bytes_written = write (fd, data, len);
804 
805  if (bytes_written < 0 && errno == EINTR)
806  goto again;
807 
808 #if 0
809  if (bytes_written > 0)
810  _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
811 #endif
812 
813  return bytes_written;
814 }
815 
836 int
838  const DBusString *buffer1,
839  int start1,
840  int len1,
841  const DBusString *buffer2,
842  int start2,
843  int len2)
844 {
845  _dbus_assert (buffer1 != NULL);
846  _dbus_assert (start1 >= 0);
847  _dbus_assert (start2 >= 0);
848  _dbus_assert (len1 >= 0);
849  _dbus_assert (len2 >= 0);
850 
851 #ifdef HAVE_WRITEV
852  {
853  struct iovec vectors[2];
854  const char *data1;
855  const char *data2;
856  int bytes_written;
857 
858  data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
859 
860  if (buffer2 != NULL)
861  data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
862  else
863  {
864  data2 = NULL;
865  start2 = 0;
866  len2 = 0;
867  }
868 
869  vectors[0].iov_base = (char*) data1;
870  vectors[0].iov_len = len1;
871  vectors[1].iov_base = (char*) data2;
872  vectors[1].iov_len = len2;
873 
874  again:
875 
876  bytes_written = writev (fd,
877  vectors,
878  data2 ? 2 : 1);
879 
880  if (bytes_written < 0 && errno == EINTR)
881  goto again;
882 
883  return bytes_written;
884  }
885 #else /* HAVE_WRITEV */
886  {
887  int ret1, ret2;
888 
889  ret1 = _dbus_write (fd, buffer1, start1, len1);
890  if (ret1 == len1 && buffer2 != NULL)
891  {
892  ret2 = _dbus_write (fd, buffer2, start2, len2);
893  if (ret2 < 0)
894  ret2 = 0; /* we can't report an error as the first write was OK */
895 
896  return ret1 + ret2;
897  }
898  else
899  return ret1;
900  }
901 #endif /* !HAVE_WRITEV */
902 }
903 
904 #define _DBUS_MAX_SUN_PATH_LENGTH 99
905 
935 int
936 _dbus_connect_unix_socket (const char *path,
937  dbus_bool_t abstract,
938  DBusError *error)
939 {
940  int fd;
941  size_t path_len;
942  struct sockaddr_un addr;
943  _DBUS_STATIC_ASSERT (sizeof (addr.sun_path) > _DBUS_MAX_SUN_PATH_LENGTH);
944 
945  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
946 
947  _dbus_verbose ("connecting to unix socket %s abstract=%d\n",
948  path, abstract);
949 
950 
951  if (!_dbus_open_unix_socket (&fd, error))
952  {
953  _DBUS_ASSERT_ERROR_IS_SET(error);
954  return -1;
955  }
956  _DBUS_ASSERT_ERROR_IS_CLEAR(error);
957 
958  _DBUS_ZERO (addr);
959  addr.sun_family = AF_UNIX;
960  path_len = strlen (path);
961 
962  if (abstract)
963  {
964 #ifdef __linux__
965  addr.sun_path[0] = '\0'; /* this is what says "use abstract" */
966  path_len++; /* Account for the extra nul byte added to the start of sun_path */
967 
968  if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
969  {
971  "Abstract socket name too long\n");
972  _dbus_close (fd, NULL);
973  return -1;
974  }
975 
976  strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
977  /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */
978 #else /* !__linux__ */
980  "Operating system does not support abstract socket namespace\n");
981  _dbus_close (fd, NULL);
982  return -1;
983 #endif /* !__linux__ */
984  }
985  else
986  {
987  if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
988  {
990  "Socket name too long\n");
991  _dbus_close (fd, NULL);
992  return -1;
993  }
994 
995  strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
996  }
997 
998  if (connect (fd, (struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (struct sockaddr_un, sun_path) + path_len) < 0)
999  {
1000  dbus_set_error (error,
1001  _dbus_error_from_errno (errno),
1002  "Failed to connect to socket %s: %s",
1003  path, _dbus_strerror (errno));
1004 
1005  _dbus_close (fd, NULL);
1006  return -1;
1007  }
1008 
1009  if (!_dbus_set_fd_nonblocking (fd, error))
1010  {
1011  _DBUS_ASSERT_ERROR_IS_SET (error);
1012 
1013  _dbus_close (fd, NULL);
1014  return -1;
1015  }
1016 
1017  return fd;
1018 }
1019 
1032 int
1033 _dbus_connect_exec (const char *path,
1034  char *const argv[],
1035  DBusError *error)
1036 {
1037  int fds[2];
1038  pid_t pid;
1039  int retval;
1040  dbus_bool_t cloexec_done = 0;
1041 
1042  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1043 
1044  _dbus_verbose ("connecting to process %s\n", path);
1045 
1046 #ifdef SOCK_CLOEXEC
1047  retval = socketpair (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
1048  cloexec_done = (retval >= 0);
1049 
1050  if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
1051 #endif
1052  {
1053  retval = socketpair (AF_UNIX, SOCK_STREAM, 0, fds);
1054  }
1055 
1056  if (retval < 0)
1057  {
1058  dbus_set_error (error,
1059  _dbus_error_from_errno (errno),
1060  "Failed to create socket pair: %s",
1061  _dbus_strerror (errno));
1062  return -1;
1063  }
1064 
1065  if (!cloexec_done)
1066  {
1067  _dbus_fd_set_close_on_exec (fds[0]);
1068  _dbus_fd_set_close_on_exec (fds[1]);
1069  }
1070 
1071  pid = fork ();
1072  if (pid < 0)
1073  {
1074  dbus_set_error (error,
1075  _dbus_error_from_errno (errno),
1076  "Failed to fork() to call %s: %s",
1077  path, _dbus_strerror (errno));
1078  close (fds[0]);
1079  close (fds[1]);
1080  return -1;
1081  }
1082 
1083  if (pid == 0)
1084  {
1085  /* child */
1086  close (fds[0]);
1087 
1088  dup2 (fds[1], STDIN_FILENO);
1089  dup2 (fds[1], STDOUT_FILENO);
1090 
1091  if (fds[1] != STDIN_FILENO &&
1092  fds[1] != STDOUT_FILENO)
1093  close (fds[1]);
1094 
1095  /* Inherit STDERR and the controlling terminal from the
1096  parent */
1097 
1098  _dbus_close_all ();
1099 
1100  execvp (path, (char * const *) argv);
1101 
1102  fprintf (stderr, "Failed to execute process %s: %s\n", path, _dbus_strerror (errno));
1103 
1104  _exit(1);
1105  }
1106 
1107  /* parent */
1108  close (fds[1]);
1109 
1110  if (!_dbus_set_fd_nonblocking (fds[0], error))
1111  {
1112  _DBUS_ASSERT_ERROR_IS_SET (error);
1113 
1114  close (fds[0]);
1115  return -1;
1116  }
1117 
1118  return fds[0];
1119 }
1120 
1138 int
1139 _dbus_listen_unix_socket (const char *path,
1140  dbus_bool_t abstract,
1141  DBusError *error)
1142 {
1143  int listen_fd;
1144  struct sockaddr_un addr;
1145  size_t path_len;
1146  _DBUS_STATIC_ASSERT (sizeof (addr.sun_path) > _DBUS_MAX_SUN_PATH_LENGTH);
1147 
1148  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1149 
1150  _dbus_verbose ("listening on unix socket %s abstract=%d\n",
1151  path, abstract);
1152 
1153  if (!_dbus_open_unix_socket (&listen_fd, error))
1154  {
1155  _DBUS_ASSERT_ERROR_IS_SET(error);
1156  return -1;
1157  }
1158  _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1159 
1160  _DBUS_ZERO (addr);
1161  addr.sun_family = AF_UNIX;
1162  path_len = strlen (path);
1163 
1164  if (abstract)
1165  {
1166 #ifdef __linux__
1167  /* remember that abstract names aren't nul-terminated so we rely
1168  * on sun_path being filled in with zeroes above.
1169  */
1170  addr.sun_path[0] = '\0'; /* this is what says "use abstract" */
1171  path_len++; /* Account for the extra nul byte added to the start of sun_path */
1172 
1173  if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1174  {
1176  "Abstract socket name too long\n");
1177  _dbus_close (listen_fd, NULL);
1178  return -1;
1179  }
1180 
1181  strncpy (&addr.sun_path[1], path, sizeof (addr.sun_path) - 2);
1182  /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */
1183 #else /* !__linux__ */
1185  "Operating system does not support abstract socket namespace\n");
1186  _dbus_close (listen_fd, NULL);
1187  return -1;
1188 #endif /* !__linux__ */
1189  }
1190  else
1191  {
1192  /* Discussed security implications of this with Nalin,
1193  * and we couldn't think of where it would kick our ass, but
1194  * it still seems a bit sucky. It also has non-security suckage;
1195  * really we'd prefer to exit if the socket is already in use.
1196  * But there doesn't seem to be a good way to do this.
1197  *
1198  * Just to be extra careful, I threw in the stat() - clearly
1199  * the stat() can't *fix* any security issue, but it at least
1200  * avoids inadvertent/accidental data loss.
1201  */
1202  {
1203  struct stat sb;
1204 
1205  if (stat (path, &sb) == 0 &&
1206  S_ISSOCK (sb.st_mode))
1207  unlink (path);
1208  }
1209 
1210  if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
1211  {
1213  "Socket name too long\n");
1214  _dbus_close (listen_fd, NULL);
1215  return -1;
1216  }
1217 
1218  strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
1219  }
1220 
1221  if (bind (listen_fd, (struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (struct sockaddr_un, sun_path) + path_len) < 0)
1222  {
1223  dbus_set_error (error, _dbus_error_from_errno (errno),
1224  "Failed to bind socket \"%s\": %s",
1225  path, _dbus_strerror (errno));
1226  _dbus_close (listen_fd, NULL);
1227  return -1;
1228  }
1229 
1230  if (listen (listen_fd, SOMAXCONN /* backlog */) < 0)
1231  {
1232  dbus_set_error (error, _dbus_error_from_errno (errno),
1233  "Failed to listen on socket \"%s\": %s",
1234  path, _dbus_strerror (errno));
1235  _dbus_close (listen_fd, NULL);
1236  return -1;
1237  }
1238 
1239  if (!_dbus_set_fd_nonblocking (listen_fd, error))
1240  {
1241  _DBUS_ASSERT_ERROR_IS_SET (error);
1242  _dbus_close (listen_fd, NULL);
1243  return -1;
1244  }
1245 
1246  /* Try opening up the permissions, but if we can't, just go ahead
1247  * and continue, maybe it will be good enough.
1248  */
1249  if (!abstract && chmod (path, 0777) < 0)
1250  _dbus_warn ("Could not set mode 0777 on socket %s", path);
1251 
1252  return listen_fd;
1253 }
1254 
1265 int
1267  DBusError *error)
1268 {
1269 #ifdef HAVE_SYSTEMD
1270  int r, n;
1271  int fd;
1272  DBusSocket *new_fds;
1273 
1274  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1275 
1276  n = sd_listen_fds (TRUE);
1277  if (n < 0)
1278  {
1280  "Failed to acquire systemd socket: %s",
1281  _dbus_strerror (-n));
1282  return -1;
1283  }
1284 
1285  if (n <= 0)
1286  {
1288  "No socket received.");
1289  return -1;
1290  }
1291 
1292  for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1293  {
1294  r = sd_is_socket (fd, AF_UNSPEC, SOCK_STREAM, 1);
1295  if (r < 0)
1296  {
1298  "Failed to verify systemd socket type: %s",
1299  _dbus_strerror (-r));
1300  return -1;
1301  }
1302 
1303  if (!r)
1304  {
1306  "Passed socket has wrong type.");
1307  return -1;
1308  }
1309  }
1310 
1311  /* OK, the file descriptors are all good, so let's take posession of
1312  them then. */
1313 
1314  new_fds = dbus_new (DBusSocket, n);
1315  if (!new_fds)
1316  {
1318  "Failed to allocate file handle array.");
1319  goto fail;
1320  }
1321 
1322  for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1323  {
1324  if (!_dbus_set_fd_nonblocking (fd, error))
1325  {
1326  _DBUS_ASSERT_ERROR_IS_SET (error);
1327  goto fail;
1328  }
1329 
1330  new_fds[fd - SD_LISTEN_FDS_START].fd = fd;
1331  }
1332 
1333  *fds = new_fds;
1334  return n;
1335 
1336  fail:
1337 
1338  for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++)
1339  {
1340  _dbus_close (fd, NULL);
1341  }
1342 
1343  dbus_free (new_fds);
1344  return -1;
1345 #else
1347  "dbus was compiled without systemd support");
1348  return -1;
1349 #endif
1350 }
1351 
1352 /* Convert an error code from getaddrinfo() or getnameinfo() into
1353  * a D-Bus error name. */
1354 static const char *
1355 _dbus_error_from_gai (int gai_res,
1356  int saved_errno)
1357 {
1358  switch (gai_res)
1359  {
1360 #ifdef EAI_FAMILY
1361  case EAI_FAMILY:
1362  /* ai_family not supported (at all) */
1363  return DBUS_ERROR_NOT_SUPPORTED;
1364 #endif
1365 
1366 #ifdef EAI_SOCKTYPE
1367  case EAI_SOCKTYPE:
1368  /* ai_socktype not supported (at all) */
1369  return DBUS_ERROR_NOT_SUPPORTED;
1370 #endif
1371 
1372 #ifdef EAI_MEMORY
1373  case EAI_MEMORY:
1374  /* Out of memory */
1375  return DBUS_ERROR_NO_MEMORY;
1376 #endif
1377 
1378 #ifdef EAI_SYSTEM
1379  case EAI_SYSTEM:
1380  /* Unspecified system error, details in errno */
1381  return _dbus_error_from_errno (saved_errno);
1382 #endif
1383 
1384  case 0:
1385  /* It succeeded, but we didn't get any addresses? */
1386  return DBUS_ERROR_FAILED;
1387 
1388  /* EAI_AGAIN: Transient failure */
1389  /* EAI_BADFLAGS: invalid ai_flags (programming error) */
1390  /* EAI_FAIL: Non-recoverable failure */
1391  /* EAI_NODATA: host exists but has no addresses */
1392  /* EAI_NONAME: host does not exist */
1393  /* EAI_OVERFLOW: argument buffer overflow */
1394  /* EAI_SERVICE: service not available for specified socket
1395  * type (we should never see this because we use numeric
1396  * ports) */
1397  default:
1398  return DBUS_ERROR_FAILED;
1399  }
1400 }
1401 
1415 DBusSocket
1416 _dbus_connect_tcp_socket (const char *host,
1417  const char *port,
1418  const char *family,
1419  DBusError *error)
1420 {
1421  return _dbus_connect_tcp_socket_with_nonce (host, port, family, (const char*)NULL, error);
1422 }
1423 
1424 DBusSocket
1425 _dbus_connect_tcp_socket_with_nonce (const char *host,
1426  const char *port,
1427  const char *family,
1428  const char *noncefile,
1429  DBusError *error)
1430 {
1431  int saved_errno = 0;
1432  DBusSocket fd = DBUS_SOCKET_INIT;
1433  int res;
1434  struct addrinfo hints;
1435  struct addrinfo *ai, *tmp;
1436 
1437  _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1438 
1439  _DBUS_ZERO (hints);
1440 
1441  if (!family)
1442  hints.ai_family = AF_UNSPEC;
1443  else if (!strcmp(family, "ipv4"))
1444  hints.ai_family = AF_INET;
1445  else if (!strcmp(family, "ipv6"))
1446  hints.ai_family = AF_INET6;
1447  else
1448  {
1449  dbus_set_error (error,
1451  "Unknown address family %s", family);
1452  return _dbus_socket_get_invalid ();
1453  }
1454  hints.ai_protocol = IPPROTO_TCP;
1455  hints.ai_socktype = SOCK_STREAM;
1456  hints.ai_flags = AI_ADDRCONFIG;
1457 
1458  if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
1459  {
1460  dbus_set_error (error,
1461  _dbus_error_from_gai (res, errno),
1462  "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1463  host, port, gai_strerror(res), res);
1464  return _dbus_socket_get_invalid ();
1465  }
1466 
1467  tmp = ai;
1468  while (tmp)
1469  {
1470  if (!_dbus_open_socket (&fd.fd, tmp->ai_family, SOCK_STREAM, 0, error))
1471  {
1472  freeaddrinfo(ai);
1473  _DBUS_ASSERT_ERROR_IS_SET(error);
1474  return _dbus_socket_get_invalid ();
1475  }
1476  _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1477 
1478  if (connect (fd.fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1479  {
1480  saved_errno = errno;
1481  _dbus_close (fd.fd, NULL);
1482  fd.fd = -1;
1483  tmp = tmp->ai_next;
1484  continue;
1485  }
1486 
1487  break;
1488  }
1489  freeaddrinfo(ai);
1490 
1491  if (fd.fd == -1)
1492  {
1493  dbus_set_error (error,
1494  _dbus_error_from_errno (saved_errno),
1495  "Failed to connect to socket \"%s:%s\" %s",
1496  host, port, _dbus_strerror(saved_errno));
1497  return _dbus_socket_get_invalid ();
1498  }
1499 
1500  if (noncefile != NULL)
1501  {
1502  DBusString noncefileStr;
1503  dbus_bool_t ret;
1504  _dbus_string_init_const (&noncefileStr, noncefile);
1505  ret = _dbus_send_nonce (fd, &noncefileStr, error);
1506  _dbus_string_free (&noncefileStr);
1507 
1508  if (!ret)
1509  {
1510  _dbus_close (fd.fd, NULL);
1511  return _dbus_socket_get_invalid ();
1512  }
1513  }
1514 
1515  if (!_dbus_set_fd_nonblocking (fd.fd, error))
1516  {
1517  _dbus_close (fd.fd, NULL);
1518  return _dbus_socket_get_invalid ();
1519  }
1520 
1521  return fd;
1522 }
1523 
1540 int
1541 _dbus_listen_tcp_socket (const char *host,
1542  const char *port,
1543  const char *family,
1544  DBusString *retport,
1545  DBusSocket **fds_p,
1546  DBusError *error)
1547 {
1548  int saved_errno;
1549  int nlisten_fd = 0, res, i;
1550  DBusSocket *listen_fd = NULL;
1551  struct addrinfo hints;
1552  struct addrinfo *ai, *tmp;
1553  unsigned int reuseaddr;
1554 
1555  *fds_p = NULL;
1556  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1557 
1558  _DBUS_ZERO (hints);
1559 
1560  if (!family)
1561  hints.ai_family = AF_UNSPEC;
1562  else if (!strcmp(family, "ipv4"))
1563  hints.ai_family = AF_INET;
1564  else if (!strcmp(family, "ipv6"))
1565  hints.ai_family = AF_INET6;
1566  else
1567  {
1568  dbus_set_error (error,
1570  "Unknown address family %s", family);
1571  return -1;
1572  }
1573 
1574  hints.ai_protocol = IPPROTO_TCP;
1575  hints.ai_socktype = SOCK_STREAM;
1576  hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
1577 
1578  redo_lookup_with_port:
1579  ai = NULL;
1580  if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
1581  {
1582  dbus_set_error (error,
1583  _dbus_error_from_gai (res, errno),
1584  "Failed to lookup host/port: \"%s:%s\": %s (%d)",
1585  host ? host : "*", port, gai_strerror(res), res);
1586  goto failed;
1587  }
1588 
1589  tmp = ai;
1590  while (tmp)
1591  {
1592  int fd = -1, tcp_nodelay_on;
1593  DBusSocket *newlisten_fd;
1594 
1595  if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
1596  {
1597  _DBUS_ASSERT_ERROR_IS_SET(error);
1598  goto failed;
1599  }
1600  _DBUS_ASSERT_ERROR_IS_CLEAR(error);
1601 
1602  reuseaddr = 1;
1603  if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr))==-1)
1604  {
1605  _dbus_warn ("Failed to set socket option \"%s:%s\": %s",
1606  host ? host : "*", port, _dbus_strerror (errno));
1607  }
1608 
1609  /* Nagle's algorithm imposes a huge delay on the initial messages
1610  going over TCP. */
1611  tcp_nodelay_on = 1;
1612  if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay_on, sizeof (tcp_nodelay_on)) == -1)
1613  {
1614  _dbus_warn ("Failed to set TCP_NODELAY socket option \"%s:%s\": %s",
1615  host ? host : "*", port, _dbus_strerror (errno));
1616  }
1617 
1618  if (bind (fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
1619  {
1620  saved_errno = errno;
1621  _dbus_close(fd, NULL);
1622  if (saved_errno == EADDRINUSE)
1623  {
1624  /* Depending on kernel policy, binding to an IPv6 address
1625  might implicitly bind to a corresponding IPv4
1626  address or vice versa, resulting in EADDRINUSE for the
1627  other one (e.g. bindv6only=0 on Linux).
1628 
1629  Also, after we "goto redo_lookup_with_port" after binding
1630  a port on one of the possible addresses, we will
1631  try to bind that same port on every address, including the
1632  same address again for a second time; that one will
1633  also fail with EADDRINUSE.
1634 
1635  For both those reasons, ignore EADDRINUSE here */
1636  tmp = tmp->ai_next;
1637  continue;
1638  }
1639  dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1640  "Failed to bind socket \"%s:%s\": %s",
1641  host ? host : "*", port, _dbus_strerror (saved_errno));
1642  goto failed;
1643  }
1644 
1645  if (listen (fd, 30 /* backlog */) < 0)
1646  {
1647  saved_errno = errno;
1648  _dbus_close (fd, NULL);
1649  dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1650  "Failed to listen on socket \"%s:%s\": %s",
1651  host ? host : "*", port, _dbus_strerror (saved_errno));
1652  goto failed;
1653  }
1654 
1655  newlisten_fd = dbus_realloc(listen_fd, sizeof(DBusSocket)*(nlisten_fd+1));
1656  if (!newlisten_fd)
1657  {
1658  _dbus_close (fd, NULL);
1660  "Failed to allocate file handle array");
1661  goto failed;
1662  }
1663  listen_fd = newlisten_fd;
1664  listen_fd[nlisten_fd].fd = fd;
1665  nlisten_fd++;
1666 
1667  if (!_dbus_string_get_length(retport))
1668  {
1669  /* If the user didn't specify a port, or used 0, then
1670  the kernel chooses a port. After the first address
1671  is bound to, we need to force all remaining addresses
1672  to use the same port */
1673  if (!port || !strcmp(port, "0"))
1674  {
1675  int result;
1676  struct sockaddr_storage addr;
1677  socklen_t addrlen;
1678  char portbuf[50];
1679 
1680  addrlen = sizeof(addr);
1681  result = getsockname(fd, (struct sockaddr*) &addr, &addrlen);
1682 
1683  if (result == -1)
1684  {
1685  saved_errno = errno;
1686  dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1687  "Failed to retrieve socket name for \"%s:%s\": %s",
1688  host ? host : "*", port, _dbus_strerror (saved_errno));
1689  goto failed;
1690  }
1691 
1692  if ((res = getnameinfo ((struct sockaddr*)&addr, addrlen, NULL, 0,
1693  portbuf, sizeof(portbuf),
1694  NI_NUMERICHOST | NI_NUMERICSERV)) != 0)
1695  {
1696  saved_errno = errno;
1697  dbus_set_error (error, _dbus_error_from_gai (res, saved_errno),
1698  "Failed to resolve port \"%s:%s\": %s (%d)",
1699  host ? host : "*", port, gai_strerror(res), res);
1700  goto failed;
1701  }
1702 
1703  if (!_dbus_string_append(retport, portbuf))
1704  {
1706  goto failed;
1707  }
1708 
1709  /* Release current address list & redo lookup */
1710  port = _dbus_string_get_const_data(retport);
1711  freeaddrinfo(ai);
1712  goto redo_lookup_with_port;
1713  }
1714  else
1715  {
1716  if (!_dbus_string_append(retport, port))
1717  {
1719  goto failed;
1720  }
1721  }
1722  }
1723 
1724  tmp = tmp->ai_next;
1725  }
1726  freeaddrinfo(ai);
1727  ai = NULL;
1728 
1729  if (!nlisten_fd)
1730  {
1731  errno = EADDRINUSE;
1732  dbus_set_error (error, _dbus_error_from_errno (errno),
1733  "Failed to bind socket \"%s:%s\": %s",
1734  host ? host : "*", port, _dbus_strerror (errno));
1735  goto failed;
1736  }
1737 
1738  for (i = 0 ; i < nlisten_fd ; i++)
1739  {
1740  if (!_dbus_set_fd_nonblocking (listen_fd[i].fd, error))
1741  {
1742  goto failed;
1743  }
1744  }
1745 
1746  *fds_p = listen_fd;
1747 
1748  return nlisten_fd;
1749 
1750  failed:
1751  if (ai)
1752  freeaddrinfo(ai);
1753  for (i = 0 ; i < nlisten_fd ; i++)
1754  _dbus_close(listen_fd[i].fd, NULL);
1755  dbus_free(listen_fd);
1756  return -1;
1757 }
1758 
1759 static dbus_bool_t
1760 write_credentials_byte (int server_fd,
1761  DBusError *error)
1762 {
1763  int bytes_written;
1764  char buf[1] = { '\0' };
1765 #if defined(HAVE_CMSGCRED)
1766  union {
1767  struct cmsghdr hdr;
1768  char cred[CMSG_SPACE (sizeof (struct cmsgcred))];
1769  } cmsg;
1770  struct iovec iov;
1771  struct msghdr msg;
1772  iov.iov_base = buf;
1773  iov.iov_len = 1;
1774 
1775  _DBUS_ZERO(msg);
1776  msg.msg_iov = &iov;
1777  msg.msg_iovlen = 1;
1778 
1779  msg.msg_control = (caddr_t) &cmsg;
1780  msg.msg_controllen = CMSG_SPACE (sizeof (struct cmsgcred));
1781  _DBUS_ZERO(cmsg);
1782  cmsg.hdr.cmsg_len = CMSG_LEN (sizeof (struct cmsgcred));
1783  cmsg.hdr.cmsg_level = SOL_SOCKET;
1784  cmsg.hdr.cmsg_type = SCM_CREDS;
1785 #endif
1786 
1787  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1788 
1789  again:
1790 
1791 #if defined(HAVE_CMSGCRED)
1792  bytes_written = sendmsg (server_fd, &msg, 0
1793 #if HAVE_DECL_MSG_NOSIGNAL
1794  |MSG_NOSIGNAL
1795 #endif
1796  );
1797 
1798  /* If we HAVE_CMSGCRED, the OS still might not let us sendmsg()
1799  * with a SOL_SOCKET/SCM_CREDS message - for instance, FreeBSD
1800  * only allows that on AF_UNIX. Try just doing a send() instead. */
1801  if (bytes_written < 0 && errno == EINVAL)
1802 #endif
1803  {
1804  bytes_written = send (server_fd, buf, 1, 0
1805 #if HAVE_DECL_MSG_NOSIGNAL
1806  |MSG_NOSIGNAL
1807 #endif
1808  );
1809  }
1810 
1811  if (bytes_written < 0 && errno == EINTR)
1812  goto again;
1813 
1814  if (bytes_written < 0)
1815  {
1816  dbus_set_error (error, _dbus_error_from_errno (errno),
1817  "Failed to write credentials byte: %s",
1818  _dbus_strerror (errno));
1819  return FALSE;
1820  }
1821  else if (bytes_written == 0)
1822  {
1824  "wrote zero bytes writing credentials byte");
1825  return FALSE;
1826  }
1827  else
1828  {
1829  _dbus_assert (bytes_written == 1);
1830  _dbus_verbose ("wrote credentials byte\n");
1831  return TRUE;
1832  }
1833 }
1834 
1835 /* return FALSE on OOM, TRUE otherwise, even if no credentials were found */
1836 static dbus_bool_t
1837 add_linux_security_label_to_credentials (int client_fd,
1838  DBusCredentials *credentials)
1839 {
1840 #if defined(__linux__) && defined(SO_PEERSEC)
1841  DBusString buf;
1842  socklen_t len = 1024;
1843  dbus_bool_t oom = FALSE;
1844 
1845  if (!_dbus_string_init_preallocated (&buf, len) ||
1846  !_dbus_string_set_length (&buf, len))
1847  return FALSE;
1848 
1849  while (getsockopt (client_fd, SOL_SOCKET, SO_PEERSEC,
1850  _dbus_string_get_data (&buf), &len) < 0)
1851  {
1852  int e = errno;
1853 
1854  _dbus_verbose ("getsockopt failed with %s, len now %lu\n",
1855  _dbus_strerror (e), (unsigned long) len);
1856 
1857  if (e != ERANGE || len <= _dbus_string_get_length_uint (&buf))
1858  {
1859  _dbus_verbose ("Failed to getsockopt(SO_PEERSEC): %s\n",
1860  _dbus_strerror (e));
1861  goto out;
1862  }
1863 
1864  /* If not enough space, len is updated to be enough.
1865  * Try again with a large enough buffer. */
1866  if (!_dbus_string_set_length (&buf, len))
1867  {
1868  oom = TRUE;
1869  goto out;
1870  }
1871 
1872  _dbus_verbose ("will try again with %lu\n", (unsigned long) len);
1873  }
1874 
1875  if (len <= 0)
1876  {
1877  _dbus_verbose ("getsockopt(SO_PEERSEC) yielded <= 0 bytes: %lu\n",
1878  (unsigned long) len);
1879  goto out;
1880  }
1881 
1882  if (len > _dbus_string_get_length_uint (&buf))
1883  {
1884  _dbus_verbose ("%lu > %u", (unsigned long) len,
1885  _dbus_string_get_length_uint (&buf));
1886  _dbus_assert_not_reached ("getsockopt(SO_PEERSEC) overflowed");
1887  }
1888 
1889  if (_dbus_string_get_byte (&buf, len - 1) == 0)
1890  {
1891  /* the kernel included the trailing \0 in its count,
1892  * but DBusString always has an extra \0 after the data anyway */
1893  _dbus_verbose ("subtracting trailing \\0\n");
1894  len--;
1895  }
1896 
1897  if (!_dbus_string_set_length (&buf, len))
1898  {
1899  _dbus_assert_not_reached ("shortening string should not lead to OOM");
1900  oom = TRUE;
1901  goto out;
1902  }
1903 
1904  if (strlen (_dbus_string_get_const_data (&buf)) != len)
1905  {
1906  /* LSM people on the linux-security-module@ mailing list say this
1907  * should never happen: the label should be a bytestring with
1908  * an optional trailing \0 */
1909  _dbus_verbose ("security label from kernel had an embedded \\0, "
1910  "ignoring it\n");
1911  goto out;
1912  }
1913 
1914  _dbus_verbose ("getsockopt(SO_PEERSEC): %lu bytes excluding \\0: %s\n",
1915  (unsigned long) len,
1916  _dbus_string_get_const_data (&buf));
1917 
1918 /* Remove trailing comma "," if any, BEGIN*/
1919 
1920  char* ss = _dbus_string_get_data (&buf);
1921  ss = strtok (ss, ",");
1922 
1923 /* Remove trailing comma "," if any, END*/
1924 
1926  _dbus_string_get_const_data (&buf)))
1927  {
1928  oom = TRUE;
1929  goto out;
1930  }
1931 
1932 out:
1933  _dbus_string_free (&buf);
1934  return !oom;
1935 #else
1936  /* no error */
1937  return TRUE;
1938 #endif
1939 }
1940 
1983  DBusCredentials *credentials,
1984  DBusError *error)
1985 {
1986  struct msghdr msg;
1987  struct iovec iov;
1988  char buf;
1989  dbus_uid_t uid_read;
1990  dbus_pid_t pid_read;
1991  int bytes_read;
1992 
1993 #ifdef HAVE_CMSGCRED
1994  union {
1995  struct cmsghdr hdr;
1996  char cred[CMSG_SPACE (sizeof (struct cmsgcred))];
1997  } cmsg;
1998 #endif
1999 
2000  /* The POSIX spec certainly doesn't promise this, but
2001  * we need these assertions to fail as soon as we're wrong about
2002  * it so we can do the porting fixups
2003  */
2004  _DBUS_STATIC_ASSERT (sizeof (pid_t) <= sizeof (dbus_pid_t));
2005  _DBUS_STATIC_ASSERT (sizeof (uid_t) <= sizeof (dbus_uid_t));
2006  _DBUS_STATIC_ASSERT (sizeof (gid_t) <= sizeof (dbus_gid_t));
2007 
2008  uid_read = DBUS_UID_UNSET;
2009  pid_read = DBUS_PID_UNSET;
2010 
2011  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2012 
2013  _dbus_credentials_clear (credentials);
2014 
2015  iov.iov_base = &buf;
2016  iov.iov_len = 1;
2017 
2018  _DBUS_ZERO(msg);
2019  msg.msg_iov = &iov;
2020  msg.msg_iovlen = 1;
2021 
2022 #if defined(HAVE_CMSGCRED)
2023  _DBUS_ZERO(cmsg);
2024  msg.msg_control = (caddr_t) &cmsg;
2025  msg.msg_controllen = CMSG_SPACE (sizeof (struct cmsgcred));
2026 #endif
2027 
2028  again:
2029  bytes_read = recvmsg (client_fd.fd, &msg, 0);
2030 
2031  if (bytes_read < 0)
2032  {
2033  if (errno == EINTR)
2034  goto again;
2035 
2036  /* EAGAIN or EWOULDBLOCK would be unexpected here since we would
2037  * normally only call read_credentials if the socket was ready
2038  * for reading
2039  */
2040 
2041  dbus_set_error (error, _dbus_error_from_errno (errno),
2042  "Failed to read credentials byte: %s",
2043  _dbus_strerror (errno));
2044  return FALSE;
2045  }
2046  else if (bytes_read == 0)
2047  {
2048  /* this should not happen unless we are using recvmsg wrong,
2049  * so is essentially here for paranoia
2050  */
2052  "Failed to read credentials byte (zero-length read)");
2053  return FALSE;
2054  }
2055  else if (buf != '\0')
2056  {
2058  "Credentials byte was not nul");
2059  return FALSE;
2060  }
2061 
2062  _dbus_verbose ("read credentials byte\n");
2063 
2064  {
2065 #ifdef SO_PEERCRED
2066  /* Supported by at least Linux and OpenBSD, with minor differences.
2067  *
2068  * This mechanism passes the process ID through and does not require
2069  * the peer's cooperation, so we prefer it over all others. Notably,
2070  * Linux also supports SCM_CREDENTIALS, which is similar to FreeBSD
2071  * SCM_CREDS; it's implemented in GIO, but we don't use it in dbus at all,
2072  * because this is much less fragile.
2073  */
2074 #ifdef __OpenBSD__
2075  struct sockpeercred cr;
2076 #else
2077  struct ucred cr;
2078 #endif
2079  socklen_t cr_len = sizeof (cr);
2080 
2081  if (getsockopt (client_fd.fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) != 0)
2082  {
2083  _dbus_verbose ("Failed to getsockopt(SO_PEERCRED): %s\n",
2084  _dbus_strerror (errno));
2085  }
2086  else if (cr_len != sizeof (cr))
2087  {
2088  _dbus_verbose ("Failed to getsockopt(SO_PEERCRED), returned %d bytes, expected %d\n",
2089  cr_len, (int) sizeof (cr));
2090  }
2091  else
2092  {
2093  pid_read = cr.pid;
2094  uid_read = cr.uid;
2095  }
2096 #elif defined(HAVE_UNPCBID) && defined(LOCAL_PEEREID)
2097  /* Another variant of the above - used on NetBSD
2098  */
2099  struct unpcbid cr;
2100  socklen_t cr_len = sizeof (cr);
2101 
2102  if (getsockopt (client_fd.fd, 0, LOCAL_PEEREID, &cr, &cr_len) != 0)
2103  {
2104  _dbus_verbose ("Failed to getsockopt(LOCAL_PEEREID): %s\n",
2105  _dbus_strerror (errno));
2106  }
2107  else if (cr_len != sizeof (cr))
2108  {
2109  _dbus_verbose ("Failed to getsockopt(LOCAL_PEEREID), returned %d bytes, expected %d\n",
2110  cr_len, (int) sizeof (cr));
2111  }
2112  else
2113  {
2114  pid_read = cr.unp_pid;
2115  uid_read = cr.unp_euid;
2116  }
2117 #elif defined(HAVE_CMSGCRED)
2118  /* We only check for HAVE_CMSGCRED, but we're really assuming that the
2119  * presence of that struct implies SCM_CREDS. Supported by at least
2120  * FreeBSD and DragonflyBSD.
2121  *
2122  * This mechanism requires the peer to help us (it has to send us a
2123  * SCM_CREDS message) but it does pass the process ID through,
2124  * which makes it better than getpeereid().
2125  */
2126  struct cmsgcred *cred;
2127  struct cmsghdr *cmsgp;
2128 
2129  for (cmsgp = CMSG_FIRSTHDR (&msg);
2130  cmsgp != NULL;
2131  cmsgp = CMSG_NXTHDR (&msg, cmsgp))
2132  {
2133  if (cmsgp->cmsg_type == SCM_CREDS &&
2134  cmsgp->cmsg_level == SOL_SOCKET &&
2135  cmsgp->cmsg_len >= CMSG_LEN (sizeof (struct cmsgcred)))
2136  {
2137  cred = (struct cmsgcred *) CMSG_DATA (cmsgp);
2138  pid_read = cred->cmcred_pid;
2139  uid_read = cred->cmcred_euid;
2140  break;
2141  }
2142  }
2143 
2144 #elif defined(HAVE_GETPEERUCRED)
2145  /* Supported in at least Solaris >= 10. It should probably be higher
2146  * up this list, because it carries the pid and we use this code path
2147  * for audit data. */
2148  ucred_t * ucred = NULL;
2149  if (getpeerucred (client_fd.fd, &ucred) == 0)
2150  {
2151 #ifdef HAVE_ADT
2152  adt_session_data_t *adth = NULL;
2153 #endif
2154  pid_read = ucred_getpid (ucred);
2155  uid_read = ucred_geteuid (ucred);
2156 #ifdef HAVE_ADT
2157  /* generate audit session data based on socket ucred */
2158  if (adt_start_session (&adth, NULL, 0) || (adth == NULL))
2159  {
2160  _dbus_verbose ("Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
2161  }
2162  else
2163  {
2164  if (adt_set_from_ucred (adth, ucred, ADT_NEW))
2165  {
2166  _dbus_verbose ("Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
2167  }
2168  else
2169  {
2170  adt_export_data_t *data = NULL;
2171  size_t size = adt_export_session_data (adth, &data);
2172  if (size <= 0)
2173  {
2174  _dbus_verbose ("Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
2175  }
2176  else
2177  {
2178  _dbus_credentials_add_adt_audit_data (credentials, data, size);
2179  free (data);
2180  }
2181  }
2182  (void) adt_end_session (adth);
2183  }
2184 #endif /* HAVE_ADT */
2185  }
2186  else
2187  {
2188  _dbus_verbose ("Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
2189  }
2190  if (ucred != NULL)
2191  ucred_free (ucred);
2192 
2193  /* ----------------------------------------------------------------
2194  * When adding new mechanisms, please add them above this point
2195  * if they support passing the process ID through, or below if not.
2196  * ---------------------------------------------------------------- */
2197 
2198 #elif defined(HAVE_GETPEEREID)
2199  /* getpeereid() originates from D.J. Bernstein and is fairly
2200  * widely-supported. According to a web search, it might be present in
2201  * any/all of:
2202  *
2203  * - AIX?
2204  * - Blackberry?
2205  * - Cygwin
2206  * - FreeBSD 4.6+ (but we prefer SCM_CREDS: it carries the pid)
2207  * - Mac OS X
2208  * - Minix 3.1.8+
2209  * - MirBSD?
2210  * - NetBSD 5.0+ (but LOCAL_PEEREID would be better: it carries the pid)
2211  * - OpenBSD 3.0+ (but we prefer SO_PEERCRED: it carries the pid)
2212  * - QNX?
2213  */
2214  uid_t euid;
2215  gid_t egid;
2216  if (getpeereid (client_fd.fd, &euid, &egid) == 0)
2217  {
2218  uid_read = euid;
2219  }
2220  else
2221  {
2222  _dbus_verbose ("Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
2223  }
2224 #else /* no supported mechanism */
2225 
2226 #warning Socket credentials not supported on this Unix OS
2227 #warning Please tell https://bugs.freedesktop.org/enter_bug.cgi?product=DBus
2228 
2229  /* Please add other operating systems known to support at least one of
2230  * the mechanisms above to this list, keeping alphabetical order.
2231  * Everything not in this list is best-effort.
2232  */
2233 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
2234  defined(__linux__) || \
2235  defined(__OpenBSD__) || \
2236  defined(__NetBSD__)
2237 # error Credentials passing not working on this OS is a regression!
2238 #endif
2239 
2240  _dbus_verbose ("Socket credentials not supported on this OS\n");
2241 #endif
2242  }
2243 
2244  _dbus_verbose ("Credentials:"
2245  " pid "DBUS_PID_FORMAT
2246  " uid "DBUS_UID_FORMAT
2247  "\n",
2248  pid_read,
2249  uid_read);
2250 
2251  if (pid_read != DBUS_PID_UNSET)
2252  {
2253  if (!_dbus_credentials_add_pid (credentials, pid_read))
2254  {
2255  _DBUS_SET_OOM (error);
2256  return FALSE;
2257  }
2258  }
2259 
2260  if (uid_read != DBUS_UID_UNSET)
2261  {
2262  if (!_dbus_credentials_add_unix_uid (credentials, uid_read))
2263  {
2264  _DBUS_SET_OOM (error);
2265  return FALSE;
2266  }
2267  }
2268 
2269  if (!add_linux_security_label_to_credentials (client_fd.fd, credentials))
2270  {
2271  _DBUS_SET_OOM (error);
2272  return FALSE;
2273  }
2274 
2275  return TRUE;
2276 }
2277 
2297  DBusError *error)
2298 {
2299  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2300 
2301  if (write_credentials_byte (server_fd.fd, error))
2302  return TRUE;
2303  else
2304  return FALSE;
2305 }
2306 
2316 DBusSocket
2318 {
2319  DBusSocket client_fd;
2320  struct sockaddr addr;
2321  socklen_t addrlen;
2322 #ifdef HAVE_ACCEPT4
2323  dbus_bool_t cloexec_done;
2324 #endif
2325 
2326  addrlen = sizeof (addr);
2327 
2328  retry:
2329 
2330 #ifdef HAVE_ACCEPT4
2331  /*
2332  * At compile-time, we assume that if accept4() is available in
2333  * libc headers, SOCK_CLOEXEC is too. At runtime, it is still
2334  * not necessarily true that either is supported by the running kernel.
2335  */
2336  client_fd.fd = accept4 (listen_fd.fd, &addr, &addrlen, SOCK_CLOEXEC);
2337  cloexec_done = client_fd.fd >= 0;
2338 
2339  if (client_fd.fd < 0 && (errno == ENOSYS || errno == EINVAL))
2340 #endif
2341  {
2342  client_fd.fd = accept (listen_fd.fd, &addr, &addrlen);
2343  }
2344 
2345  if (client_fd.fd < 0)
2346  {
2347  if (errno == EINTR)
2348  goto retry;
2349  }
2350 
2351  _dbus_verbose ("client fd %d accepted\n", client_fd.fd);
2352 
2353 #ifdef HAVE_ACCEPT4
2354  if (!cloexec_done)
2355 #endif
2356  {
2357  _dbus_fd_set_close_on_exec(client_fd.fd);
2358  }
2359 
2360  return client_fd;
2361 }
2362 
2373 {
2374  const char *directory;
2375  struct stat sb;
2376 
2377  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2378 
2379  directory = _dbus_string_get_const_data (dir);
2380 
2381  if (stat (directory, &sb) < 0)
2382  {
2383  dbus_set_error (error, _dbus_error_from_errno (errno),
2384  "%s", _dbus_strerror (errno));
2385 
2386  return FALSE;
2387  }
2388 
2389  if (sb.st_uid != geteuid ())
2390  {
2392  "%s directory is owned by user %lu, not %lu",
2393  directory,
2394  (unsigned long) sb.st_uid,
2395  (unsigned long) geteuid ());
2396  return FALSE;
2397  }
2398 
2399  if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
2400  (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
2401  {
2403  "%s directory is not private to the user", directory);
2404  return FALSE;
2405  }
2406 
2407  return TRUE;
2408 }
2409 
2410 static dbus_bool_t
2411 fill_user_info_from_passwd (struct passwd *p,
2412  DBusUserInfo *info,
2413  DBusError *error)
2414 {
2415  _dbus_assert (p->pw_name != NULL);
2416  _dbus_assert (p->pw_dir != NULL);
2417 
2418  info->uid = p->pw_uid;
2419  info->primary_gid = p->pw_gid;
2420  info->username = _dbus_strdup (p->pw_name);
2421  info->homedir = _dbus_strdup (p->pw_dir);
2422 
2423  if (info->username == NULL ||
2424  info->homedir == NULL)
2425  {
2427  return FALSE;
2428  }
2429 
2430  return TRUE;
2431 }
2432 
2433 static dbus_bool_t
2434 fill_user_info (DBusUserInfo *info,
2435  dbus_uid_t uid,
2436  const DBusString *username,
2437  DBusError *error)
2438 {
2439  const char *username_c;
2440 
2441  /* exactly one of username/uid provided */
2442  _dbus_assert (username != NULL || uid != DBUS_UID_UNSET);
2443  _dbus_assert (username == NULL || uid == DBUS_UID_UNSET);
2444 
2445  info->uid = DBUS_UID_UNSET;
2446  info->primary_gid = DBUS_GID_UNSET;
2447  info->group_ids = NULL;
2448  info->n_group_ids = 0;
2449  info->username = NULL;
2450  info->homedir = NULL;
2451 
2452  if (username != NULL)
2453  username_c = _dbus_string_get_const_data (username);
2454  else
2455  username_c = NULL;
2456 
2457  /* For now assuming that the getpwnam() and getpwuid() flavors
2458  * are always symmetrical, if not we have to add more configure
2459  * checks
2460  */
2461 
2462 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
2463  {
2464  struct passwd *p;
2465  int result;
2466  size_t buflen;
2467  char *buf;
2468  struct passwd p_str;
2469 
2470  /* retrieve maximum needed size for buf */
2471  buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
2472 
2473  /* sysconf actually returns a long, but everything else expects size_t,
2474  * so just recast here.
2475  * https://bugs.freedesktop.org/show_bug.cgi?id=17061
2476  */
2477  if ((long) buflen <= 0)
2478  buflen = 1024;
2479 
2480  result = -1;
2481  while (1)
2482  {
2483  buf = dbus_malloc (buflen);
2484  if (buf == NULL)
2485  {
2487  return FALSE;
2488  }
2489 
2490  p = NULL;
2491 #ifdef HAVE_POSIX_GETPWNAM_R
2492  if (uid != DBUS_UID_UNSET)
2493  result = getpwuid_r (uid, &p_str, buf, buflen,
2494  &p);
2495  else
2496  result = getpwnam_r (username_c, &p_str, buf, buflen,
2497  &p);
2498 #else
2499  if (uid != DBUS_UID_UNSET)
2500  p = getpwuid_r (uid, &p_str, buf, buflen);
2501  else
2502  p = getpwnam_r (username_c, &p_str, buf, buflen);
2503  result = 0;
2504 #endif /* !HAVE_POSIX_GETPWNAM_R */
2505  //Try a bigger buffer if ERANGE was returned
2506  if (result == ERANGE && buflen < 512 * 1024)
2507  {
2508  dbus_free (buf);
2509  buflen *= 2;
2510  }
2511  else
2512  {
2513  break;
2514  }
2515  }
2516  if (result == 0 && p == &p_str)
2517  {
2518  if (!fill_user_info_from_passwd (p, info, error))
2519  {
2520  dbus_free (buf);
2521  return FALSE;
2522  }
2523  dbus_free (buf);
2524  }
2525  else
2526  {
2527  dbus_set_error (error, _dbus_error_from_errno (errno),
2528  "User \"%s\" unknown or no memory to allocate password entry\n",
2529  username_c ? username_c : "???");
2530  _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
2531  dbus_free (buf);
2532  return FALSE;
2533  }
2534  }
2535 #else /* ! HAVE_GETPWNAM_R */
2536  {
2537  /* I guess we're screwed on thread safety here */
2538  struct passwd *p;
2539 
2540  if (uid != DBUS_UID_UNSET)
2541  p = getpwuid (uid);
2542  else
2543  p = getpwnam (username_c);
2544 
2545  if (p != NULL)
2546  {
2547  if (!fill_user_info_from_passwd (p, info, error))
2548  {
2549  return FALSE;
2550  }
2551  }
2552  else
2553  {
2554  dbus_set_error (error, _dbus_error_from_errno (errno),
2555  "User \"%s\" unknown or no memory to allocate password entry\n",
2556  username_c ? username_c : "???");
2557  _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
2558  return FALSE;
2559  }
2560  }
2561 #endif /* ! HAVE_GETPWNAM_R */
2562 
2563  /* Fill this in so we can use it to get groups */
2564  username_c = info->username;
2565 
2566 #ifdef HAVE_GETGROUPLIST
2567  {
2568  gid_t *buf;
2569  int buf_count;
2570  int i;
2571  int initial_buf_count;
2572 
2573  initial_buf_count = 17;
2574  buf_count = initial_buf_count;
2575  buf = dbus_new (gid_t, buf_count);
2576  if (buf == NULL)
2577  {
2579  goto failed;
2580  }
2581 
2582  if (getgrouplist (username_c,
2583  info->primary_gid,
2584  buf, &buf_count) < 0)
2585  {
2586  gid_t *new;
2587  /* Presumed cause of negative return code: buf has insufficient
2588  entries to hold the entire group list. The Linux behavior in this
2589  case is to pass back the actual number of groups in buf_count, but
2590  on Mac OS X 10.5, buf_count is unhelpfully left alone.
2591  So as a hack, try to help out a bit by guessing a larger
2592  number of groups, within reason.. might still fail, of course,
2593  but we can at least print a more informative message. I looked up
2594  the "right way" to do this by downloading Apple's own source code
2595  for the "id" command, and it turns out that they use an
2596  undocumented library function getgrouplist_2 (!) which is not
2597  declared in any header in /usr/include (!!). That did not seem
2598  like the way to go here.
2599  */
2600  if (buf_count == initial_buf_count)
2601  {
2602  buf_count *= 16; /* Retry with an arbitrarily scaled-up array */
2603  }
2604  new = dbus_realloc (buf, buf_count * sizeof (buf[0]));
2605  if (new == NULL)
2606  {
2608  dbus_free (buf);
2609  goto failed;
2610  }
2611 
2612  buf = new;
2613 
2614  errno = 0;
2615  if (getgrouplist (username_c, info->primary_gid, buf, &buf_count) < 0)
2616  {
2617  if (errno == 0)
2618  {
2619  _dbus_warn ("It appears that username \"%s\" is in more than %d groups.\nProceeding with just the first %d groups.",
2620  username_c, buf_count, buf_count);
2621  }
2622  else
2623  {
2624  dbus_set_error (error,
2625  _dbus_error_from_errno (errno),
2626  "Failed to get groups for username \"%s\" primary GID "
2627  DBUS_GID_FORMAT ": %s\n",
2628  username_c, info->primary_gid,
2629  _dbus_strerror (errno));
2630  dbus_free (buf);
2631  goto failed;
2632  }
2633  }
2634  }
2635 
2636  info->group_ids = dbus_new (dbus_gid_t, buf_count);
2637  if (info->group_ids == NULL)
2638  {
2640  dbus_free (buf);
2641  goto failed;
2642  }
2643 
2644  for (i = 0; i < buf_count; ++i)
2645  info->group_ids[i] = buf[i];
2646 
2647  info->n_group_ids = buf_count;
2648 
2649  dbus_free (buf);
2650  }
2651 #else /* HAVE_GETGROUPLIST */
2652  {
2653  /* We just get the one group ID */
2654  info->group_ids = dbus_new (dbus_gid_t, 1);
2655  if (info->group_ids == NULL)
2656  {
2658  goto failed;
2659  }
2660 
2661  info->n_group_ids = 1;
2662 
2663  (info->group_ids)[0] = info->primary_gid;
2664  }
2665 #endif /* HAVE_GETGROUPLIST */
2666 
2667  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2668 
2669  return TRUE;
2670 
2671  failed:
2672  _DBUS_ASSERT_ERROR_IS_SET (error);
2673  return FALSE;
2674 }
2675 
2686  const DBusString *username,
2687  DBusError *error)
2688 {
2689  return fill_user_info (info, DBUS_UID_UNSET,
2690  username, error);
2691 }
2692 
2703  dbus_uid_t uid,
2704  DBusError *error)
2705 {
2706  return fill_user_info (info, uid,
2707  NULL, error);
2708 }
2709 
2719 {
2720  /* The POSIX spec certainly doesn't promise this, but
2721  * we need these assertions to fail as soon as we're wrong about
2722  * it so we can do the porting fixups
2723  */
2724  _DBUS_STATIC_ASSERT (sizeof (pid_t) <= sizeof (dbus_pid_t));
2725  _DBUS_STATIC_ASSERT (sizeof (uid_t) <= sizeof (dbus_uid_t));
2726  _DBUS_STATIC_ASSERT (sizeof (gid_t) <= sizeof (dbus_gid_t));
2727 
2728  if (!_dbus_credentials_add_pid(credentials, _dbus_getpid()))
2729  return FALSE;
2730  if (!_dbus_credentials_add_unix_uid(credentials, _dbus_geteuid()))
2731  return FALSE;
2732 
2733  return TRUE;
2734 }
2735 
2749 {
2750  return _dbus_string_append_uint (str,
2751  _dbus_geteuid ());
2752 }
2753 
2758 dbus_pid_t
2760 {
2761  return getpid ();
2762 }
2763 
2767 dbus_uid_t
2769 {
2770  return getuid ();
2771 }
2772 
2776 dbus_uid_t
2778 {
2779  return geteuid ();
2780 }
2781 
2788 unsigned long
2790 {
2791  return getpid ();
2792 }
2793 
2802 _dbus_parse_uid (const DBusString *uid_str,
2803  dbus_uid_t *uid)
2804 {
2805  int end;
2806  long val;
2807 
2808  if (_dbus_string_get_length (uid_str) == 0)
2809  {
2810  _dbus_verbose ("UID string was zero length\n");
2811  return FALSE;
2812  }
2813 
2814  val = -1;
2815  end = 0;
2816  if (!_dbus_string_parse_int (uid_str, 0, &val,
2817  &end))
2818  {
2819  _dbus_verbose ("could not parse string as a UID\n");
2820  return FALSE;
2821  }
2822 
2823  if (end != _dbus_string_get_length (uid_str))
2824  {
2825  _dbus_verbose ("string contained trailing stuff after UID\n");
2826  return FALSE;
2827  }
2828 
2829  *uid = val;
2830 
2831  return TRUE;
2832 }
2833 
2834 #if !DBUS_USE_SYNC
2835 /* To be thread-safe by default on platforms that don't necessarily have
2836  * atomic operations (notably Debian armel, which is armv4t), we must
2837  * use a mutex that can be initialized statically, like this.
2838  * GLib >= 2.32 uses a similar system.
2839  */
2840 static pthread_mutex_t atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
2841 #endif
2842 
2851 {
2852 #if DBUS_USE_SYNC
2853  return __sync_add_and_fetch(&atomic->value, 1)-1;
2854 #else
2855  dbus_int32_t res;
2856 
2857  pthread_mutex_lock (&atomic_mutex);
2858  res = atomic->value;
2859  atomic->value += 1;
2860  pthread_mutex_unlock (&atomic_mutex);
2861 
2862  return res;
2863 #endif
2864 }
2865 
2874 {
2875 #if DBUS_USE_SYNC
2876  return __sync_sub_and_fetch(&atomic->value, 1)+1;
2877 #else
2878  dbus_int32_t res;
2879 
2880  pthread_mutex_lock (&atomic_mutex);
2881  res = atomic->value;
2882  atomic->value -= 1;
2883  pthread_mutex_unlock (&atomic_mutex);
2884 
2885  return res;
2886 #endif
2887 }
2888 
2898 {
2899 #if DBUS_USE_SYNC
2900  __sync_synchronize ();
2901  return atomic->value;
2902 #else
2903  dbus_int32_t res;
2904 
2905  pthread_mutex_lock (&atomic_mutex);
2906  res = atomic->value;
2907  pthread_mutex_unlock (&atomic_mutex);
2908 
2909  return res;
2910 #endif
2911 }
2912 
2921 int
2923  int n_fds,
2924  int timeout_milliseconds)
2925 {
2926 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
2927  /* DBusPollFD is a struct pollfd in this code path, so we can just poll() */
2928  if (timeout_milliseconds < -1)
2929  {
2930  timeout_milliseconds = -1;
2931  }
2932 
2933  return poll (fds,
2934  n_fds,
2935  timeout_milliseconds);
2936 #else /* ! HAVE_POLL */
2937  /* Emulate poll() in terms of select() */
2938  fd_set read_set, write_set, err_set;
2939  int max_fd = 0;
2940  int i;
2941  struct timeval tv;
2942  int ready;
2943 
2944  FD_ZERO (&read_set);
2945  FD_ZERO (&write_set);
2946  FD_ZERO (&err_set);
2947 
2948  for (i = 0; i < n_fds; i++)
2949  {
2950  DBusPollFD *fdp = &fds[i];
2951 
2952  if (fdp->events & _DBUS_POLLIN)
2953  FD_SET (fdp->fd, &read_set);
2954 
2955  if (fdp->events & _DBUS_POLLOUT)
2956  FD_SET (fdp->fd, &write_set);
2957 
2958  FD_SET (fdp->fd, &err_set);
2959 
2960  max_fd = MAX (max_fd, fdp->fd);
2961  }
2962 
2963  tv.tv_sec = timeout_milliseconds / 1000;
2964  tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
2965 
2966  ready = select (max_fd + 1, &read_set, &write_set, &err_set,
2967  timeout_milliseconds < 0 ? NULL : &tv);
2968 
2969  if (ready > 0)
2970  {
2971  for (i = 0; i < n_fds; i++)
2972  {
2973  DBusPollFD *fdp = &fds[i];
2974 
2975  fdp->revents = 0;
2976 
2977  if (FD_ISSET (fdp->fd, &read_set))
2978  fdp->revents |= _DBUS_POLLIN;
2979 
2980  if (FD_ISSET (fdp->fd, &write_set))
2981  fdp->revents |= _DBUS_POLLOUT;
2982 
2983  if (FD_ISSET (fdp->fd, &err_set))
2984  fdp->revents |= _DBUS_POLLERR;
2985  }
2986  }
2987 
2988  return ready;
2989 #endif
2990 }
2991 
2999 void
3001  long *tv_usec)
3002 {
3003 #ifdef HAVE_MONOTONIC_CLOCK
3004  struct timespec ts;
3005  clock_gettime (CLOCK_MONOTONIC, &ts);
3006 
3007  if (tv_sec)
3008  *tv_sec = ts.tv_sec;
3009  if (tv_usec)
3010  *tv_usec = ts.tv_nsec / 1000;
3011 #else
3012  struct timeval t;
3013 
3014  gettimeofday (&t, NULL);
3015 
3016  if (tv_sec)
3017  *tv_sec = t.tv_sec;
3018  if (tv_usec)
3019  *tv_usec = t.tv_usec;
3020 #endif
3021 }
3022 
3030 void
3031 _dbus_get_real_time (long *tv_sec,
3032  long *tv_usec)
3033 {
3034  struct timeval t;
3035 
3036  gettimeofday (&t, NULL);
3037 
3038  if (tv_sec)
3039  *tv_sec = t.tv_sec;
3040  if (tv_usec)
3041  *tv_usec = t.tv_usec;
3042 }
3043 
3054  DBusError *error)
3055 {
3056  const char *filename_c;
3057 
3058  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3059 
3060  filename_c = _dbus_string_get_const_data (filename);
3061 
3062  if (mkdir (filename_c, 0700) < 0)
3063  {
3064  if (errno == EEXIST)
3065  return TRUE;
3066 
3068  "Failed to create directory %s: %s\n",
3069  filename_c, _dbus_strerror (errno));
3070  return FALSE;
3071  }
3072  else
3073  return TRUE;
3074 }
3075 
3086  DBusError *error)
3087 {
3088  const char *filename_c;
3089 
3090  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3091 
3092  filename_c = _dbus_string_get_const_data (filename);
3093 
3094  if (mkdir (filename_c, 0700) < 0)
3095  {
3097  "Failed to create directory %s: %s\n",
3098  filename_c, _dbus_strerror (errno));
3099  return FALSE;
3100  }
3101  else
3102  return TRUE;
3103 }
3104 
3117  const DBusString *next_component)
3118 {
3119  dbus_bool_t dir_ends_in_slash;
3120  dbus_bool_t file_starts_with_slash;
3121 
3122  if (_dbus_string_get_length (dir) == 0 ||
3123  _dbus_string_get_length (next_component) == 0)
3124  return TRUE;
3125 
3126  dir_ends_in_slash = '/' == _dbus_string_get_byte (dir,
3127  _dbus_string_get_length (dir) - 1);
3128 
3129  file_starts_with_slash = '/' == _dbus_string_get_byte (next_component, 0);
3130 
3131  if (dir_ends_in_slash && file_starts_with_slash)
3132  {
3133  _dbus_string_shorten (dir, 1);
3134  }
3135  else if (!(dir_ends_in_slash || file_starts_with_slash))
3136  {
3137  if (!_dbus_string_append_byte (dir, '/'))
3138  return FALSE;
3139  }
3140 
3141  return _dbus_string_copy (next_component, 0, dir,
3142  _dbus_string_get_length (dir));
3143 }
3144 
3146 #define NANOSECONDS_PER_SECOND 1000000000
3147 
3148 #define MICROSECONDS_PER_SECOND 1000000
3149 
3150 #define MILLISECONDS_PER_SECOND 1000
3151 
3152 #define NANOSECONDS_PER_MILLISECOND 1000000
3153 
3154 #define MICROSECONDS_PER_MILLISECOND 1000
3155 
3160 void
3161 _dbus_sleep_milliseconds (int milliseconds)
3162 {
3163 #ifdef HAVE_NANOSLEEP
3164  struct timespec req;
3165  struct timespec rem;
3166 
3167  req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
3168  req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
3169  rem.tv_sec = 0;
3170  rem.tv_nsec = 0;
3171 
3172  while (nanosleep (&req, &rem) < 0 && errno == EINTR)
3173  req = rem;
3174 #elif defined (HAVE_USLEEP)
3175  usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
3176 #else /* ! HAVE_USLEEP */
3177  sleep (MAX (milliseconds / 1000, 1));
3178 #endif
3179 }
3180 
3192  int n_bytes,
3193  DBusError *error)
3194 {
3195  int old_len;
3196  int fd;
3197  int result;
3198 
3199  old_len = _dbus_string_get_length (str);
3200  fd = -1;
3201 
3202  /* note, urandom on linux will fall back to pseudorandom */
3203  fd = open ("/dev/urandom", O_RDONLY);
3204 
3205  if (fd < 0)
3206  {
3207  dbus_set_error (error, _dbus_error_from_errno (errno),
3208  "Could not open /dev/urandom: %s",
3209  _dbus_strerror (errno));
3210  return FALSE;
3211  }
3212 
3213  _dbus_verbose ("/dev/urandom fd %d opened\n", fd);
3214 
3215  result = _dbus_read (fd, str, n_bytes);
3216 
3217  if (result != n_bytes)
3218  {
3219  if (result < 0)
3220  dbus_set_error (error, _dbus_error_from_errno (errno),
3221  "Could not read /dev/urandom: %s",
3222  _dbus_strerror (errno));
3223  else
3225  "Short read from /dev/urandom");
3226 
3227  _dbus_close (fd, NULL);
3228  _dbus_string_set_length (str, old_len);
3229  return FALSE;
3230  }
3231 
3232  _dbus_verbose ("Read %d bytes from /dev/urandom\n",
3233  n_bytes);
3234 
3235  _dbus_close (fd, NULL);
3236 
3237  return TRUE;
3238 }
3239 
3245 void
3246 _dbus_exit (int code)
3247 {
3248  _exit (code);
3249 }
3250 
3259 const char*
3260 _dbus_strerror (int error_number)
3261 {
3262  const char *msg;
3263 
3264  msg = strerror (error_number);
3265  if (msg == NULL)
3266  msg = "unknown";
3267 
3268  return msg;
3269 }
3270 
3274 void
3276 {
3277  signal (SIGPIPE, SIG_IGN);
3278 }
3279 
3287 void
3289 {
3290  int val;
3291 
3292  val = fcntl (fd, F_GETFD, 0);
3293 
3294  if (val < 0)
3295  return;
3296 
3297  val |= FD_CLOEXEC;
3298 
3299  fcntl (fd, F_SETFD, val);
3300 }
3301 
3310 _dbus_close (int fd,
3311  DBusError *error)
3312 {
3313  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3314 
3315  again:
3316  if (close (fd) < 0)
3317  {
3318  if (errno == EINTR)
3319  goto again;
3320 
3321  dbus_set_error (error, _dbus_error_from_errno (errno),
3322  "Could not close fd %d", fd);
3323  return FALSE;
3324  }
3325 
3326  return TRUE;
3327 }
3328 
3337 int
3338 _dbus_dup(int fd,
3339  DBusError *error)
3340 {
3341  int new_fd;
3342 
3343 #ifdef F_DUPFD_CLOEXEC
3344  dbus_bool_t cloexec_done;
3345 
3346  new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
3347  cloexec_done = new_fd >= 0;
3348 
3349  if (new_fd < 0 && errno == EINVAL)
3350 #endif
3351  {
3352  new_fd = fcntl(fd, F_DUPFD, 3);
3353  }
3354 
3355  if (new_fd < 0) {
3356 
3357  dbus_set_error (error, _dbus_error_from_errno (errno),
3358  "Could not duplicate fd %d", fd);
3359  return -1;
3360  }
3361 
3362 #ifdef F_DUPFD_CLOEXEC
3363  if (!cloexec_done)
3364 #endif
3365  {
3367  }
3368 
3369  return new_fd;
3370 }
3371 
3381  DBusError *error)
3382 {
3383  return _dbus_set_fd_nonblocking (fd.fd, error);
3384 }
3385 
3386 static dbus_bool_t
3387 _dbus_set_fd_nonblocking (int fd,
3388  DBusError *error)
3389 {
3390  int val;
3391 
3392  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3393 
3394  val = fcntl (fd, F_GETFL, 0);
3395  if (val < 0)
3396  {
3397  dbus_set_error (error, _dbus_error_from_errno (errno),
3398  "Failed to get flags from file descriptor %d: %s",
3399  fd, _dbus_strerror (errno));
3400  _dbus_verbose ("Failed to get flags for fd %d: %s\n", fd,
3401  _dbus_strerror (errno));
3402  return FALSE;
3403  }
3404 
3405  if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
3406  {
3407  dbus_set_error (error, _dbus_error_from_errno (errno),
3408  "Failed to set nonblocking flag of file descriptor %d: %s",
3409  fd, _dbus_strerror (errno));
3410  _dbus_verbose ("Failed to set fd %d nonblocking: %s\n",
3411  fd, _dbus_strerror (errno));
3412 
3413  return FALSE;
3414  }
3415 
3416  return TRUE;
3417 }
3418 
3424 void
3426 {
3427 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
3428  void *bt[500];
3429  int bt_size;
3430  int i;
3431  char **syms;
3432 
3433  bt_size = backtrace (bt, 500);
3434 
3435  syms = backtrace_symbols (bt, bt_size);
3436 
3437  i = 0;
3438  while (i < bt_size)
3439  {
3440  /* don't use dbus_warn since it can _dbus_abort() */
3441  fprintf (stderr, " %s\n", syms[i]);
3442  ++i;
3443  }
3444  fflush (stderr);
3445 
3446  free (syms);
3447 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
3448  fprintf (stderr, " D-Bus not built with -rdynamic so unable to print a backtrace\n");
3449 #else
3450  fprintf (stderr, " D-Bus not compiled with backtrace support so unable to print a backtrace\n");
3451 #endif
3452 }
3453 
3468  DBusSocket *fd2,
3469  dbus_bool_t blocking,
3470  DBusError *error)
3471 {
3472 #ifdef HAVE_SOCKETPAIR
3473  int fds[2];
3474  int retval;
3475 
3476 #ifdef SOCK_CLOEXEC
3477  dbus_bool_t cloexec_done;
3478 
3479  retval = socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds);
3480  cloexec_done = retval >= 0;
3481 
3482  if (retval < 0 && (errno == EINVAL || errno == EPROTOTYPE))
3483 #endif
3484  {
3485  retval = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
3486  }
3487 
3488  if (retval < 0)
3489  {
3490  dbus_set_error (error, _dbus_error_from_errno (errno),
3491  "Could not create full-duplex pipe");
3492  return FALSE;
3493  }
3494 
3495  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3496 
3497 #ifdef SOCK_CLOEXEC
3498  if (!cloexec_done)
3499 #endif
3500  {
3501  _dbus_fd_set_close_on_exec (fds[0]);
3502  _dbus_fd_set_close_on_exec (fds[1]);
3503  }
3504 
3505  if (!blocking &&
3506  (!_dbus_set_fd_nonblocking (fds[0], NULL) ||
3507  !_dbus_set_fd_nonblocking (fds[1], NULL)))
3508  {
3509  dbus_set_error (error, _dbus_error_from_errno (errno),
3510  "Could not set full-duplex pipe nonblocking");
3511 
3512  _dbus_close (fds[0], NULL);
3513  _dbus_close (fds[1], NULL);
3514 
3515  return FALSE;
3516  }
3517 
3518  fd1->fd = fds[0];
3519  fd2->fd = fds[1];
3520 
3521  _dbus_verbose ("full-duplex pipe %d <-> %d\n",
3522  fd1->fd, fd2->fd);
3523 
3524  return TRUE;
3525 #else
3526  _dbus_warn ("_dbus_socketpair() not implemented on this OS");
3528  "_dbus_socketpair() not implemented on this OS");
3529  return FALSE;
3530 #endif
3531 }
3532 
3541 int
3543  va_list args)
3544 {
3545  char static_buf[1024];
3546  int bufsize = sizeof (static_buf);
3547  int len;
3548  va_list args_copy;
3549 
3550  DBUS_VA_COPY (args_copy, args);
3551  len = vsnprintf (static_buf, bufsize, format, args_copy);
3552  va_end (args_copy);
3553 
3554  /* If vsnprintf() returned non-negative, then either the string fits in
3555  * static_buf, or this OS has the POSIX and C99 behaviour where vsnprintf
3556  * returns the number of characters that were needed, or this OS returns the
3557  * truncated length.
3558  *
3559  * We ignore the possibility that snprintf might just ignore the length and
3560  * overrun the buffer (64-bit Solaris 7), because that's pathological.
3561  * If your libc is really that bad, come back when you have a better one. */
3562  if (len == bufsize)
3563  {
3564  /* This could be the truncated length (Tru64 and IRIX have this bug),
3565  * or the real length could be coincidentally the same. Which is it?
3566  * If vsnprintf returns the truncated length, we'll go to the slow
3567  * path. */
3568  DBUS_VA_COPY (args_copy, args);
3569 
3570  if (vsnprintf (static_buf, 1, format, args_copy) == 1)
3571  len = -1;
3572 
3573  va_end (args_copy);
3574  }
3575 
3576  /* If vsnprintf() returned negative, we have to do more work.
3577  * HP-UX returns negative. */
3578  while (len < 0)
3579  {
3580  char *buf;
3581 
3582  bufsize *= 2;
3583 
3584  buf = dbus_malloc (bufsize);
3585 
3586  if (buf == NULL)
3587  return -1;
3588 
3589  DBUS_VA_COPY (args_copy, args);
3590  len = vsnprintf (buf, bufsize, format, args_copy);
3591  va_end (args_copy);
3592 
3593  dbus_free (buf);
3594 
3595  /* If the reported length is exactly the buffer size, round up to the
3596  * next size, in case vsnprintf has been returning the truncated
3597  * length */
3598  if (len == bufsize)
3599  len = -1;
3600  }
3601 
3602  return len;
3603 }
3604 
3611 const char*
3613 {
3614  /* Protected by _DBUS_LOCK_sysdeps */
3615  static const char* tmpdir = NULL;
3616 
3617  if (!_DBUS_LOCK (sysdeps))
3618  return NULL;
3619 
3620  if (tmpdir == NULL)
3621  {
3622  /* TMPDIR is what glibc uses, then
3623  * glibc falls back to the P_tmpdir macro which
3624  * just expands to "/tmp"
3625  */
3626  if (tmpdir == NULL)
3627  tmpdir = getenv("TMPDIR");
3628 
3629  /* These two env variables are probably
3630  * broken, but maybe some OS uses them?
3631  */
3632  if (tmpdir == NULL)
3633  tmpdir = getenv("TMP");
3634  if (tmpdir == NULL)
3635  tmpdir = getenv("TEMP");
3636 
3637  /* And this is the sane fallback. */
3638  if (tmpdir == NULL)
3639  tmpdir = "/tmp";
3640  }
3641 
3642  _DBUS_UNLOCK (sysdeps);
3643 
3644  _dbus_assert(tmpdir != NULL);
3645 
3646  return tmpdir;
3647 }
3648 
3649 #if defined(DBUS_ENABLE_X11_AUTOLAUNCH) || defined(DBUS_ENABLE_LAUNCHD)
3650 
3669 static dbus_bool_t
3670 _read_subprocess_line_argv (const char *progpath,
3671  dbus_bool_t path_fallback,
3672  const char * const *argv,
3673  DBusString *result,
3674  DBusError *error)
3675 {
3676  int result_pipe[2] = { -1, -1 };
3677  int errors_pipe[2] = { -1, -1 };
3678  pid_t pid;
3679  int ret;
3680  int status;
3681  int orig_len;
3682 
3683  dbus_bool_t retval;
3684  sigset_t new_set, old_set;
3685 
3686  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3687  retval = FALSE;
3688 
3689  /* We need to block any existing handlers for SIGCHLD temporarily; they
3690  * will cause waitpid() below to fail.
3691  * https://bugs.freedesktop.org/show_bug.cgi?id=21347
3692  */
3693  sigemptyset (&new_set);
3694  sigaddset (&new_set, SIGCHLD);
3695  sigprocmask (SIG_BLOCK, &new_set, &old_set);
3696 
3697  orig_len = _dbus_string_get_length (result);
3698 
3699 #define READ_END 0
3700 #define WRITE_END 1
3701  if (pipe (result_pipe) < 0)
3702  {
3703  dbus_set_error (error, _dbus_error_from_errno (errno),
3704  "Failed to create a pipe to call %s: %s",
3705  progpath, _dbus_strerror (errno));
3706  _dbus_verbose ("Failed to create a pipe to call %s: %s\n",
3707  progpath, _dbus_strerror (errno));
3708  goto out;
3709  }
3710  if (pipe (errors_pipe) < 0)
3711  {
3712  dbus_set_error (error, _dbus_error_from_errno (errno),
3713  "Failed to create a pipe to call %s: %s",
3714  progpath, _dbus_strerror (errno));
3715  _dbus_verbose ("Failed to create a pipe to call %s: %s\n",
3716  progpath, _dbus_strerror (errno));
3717  goto out;
3718  }
3719 
3720  pid = fork ();
3721  if (pid < 0)
3722  {
3723  dbus_set_error (error, _dbus_error_from_errno (errno),
3724  "Failed to fork() to call %s: %s",
3725  progpath, _dbus_strerror (errno));
3726  _dbus_verbose ("Failed to fork() to call %s: %s\n",
3727  progpath, _dbus_strerror (errno));
3728  goto out;
3729  }
3730 
3731  if (pid == 0)
3732  {
3733  /* child process */
3734  const char *error_str;
3735 
3736  if (!_dbus_ensure_standard_fds (DBUS_FORCE_STDIN_NULL, &error_str))
3737  {
3738  int saved_errno = errno;
3739 
3740  /* Try to write details into the pipe, but don't bother
3741  * trying too hard (no retry loop). */
3742 
3743  if (write (errors_pipe[WRITE_END], error_str, strlen (error_str)) < 0 ||
3744  write (errors_pipe[WRITE_END], ": ", 2) < 0)
3745  {
3746  /* ignore, not much we can do */
3747  }
3748 
3749  error_str = _dbus_strerror (saved_errno);
3750 
3751  if (write (errors_pipe[WRITE_END], error_str, strlen (error_str)) < 0)
3752  {
3753  /* ignore, not much we can do */
3754  }
3755 
3756  _exit (1);
3757  }
3758 
3759  /* set-up stdXXX */
3760  close (result_pipe[READ_END]);
3761  close (errors_pipe[READ_END]);
3762 
3763  if (dup2 (result_pipe[WRITE_END], 1) == -1) /* setup stdout */
3764  _exit (1);
3765  if (dup2 (errors_pipe[WRITE_END], 2) == -1) /* setup stderr */
3766  _exit (1);
3767 
3768  _dbus_close_all ();
3769 
3770  sigprocmask (SIG_SETMASK, &old_set, NULL);
3771 
3772  /* If it looks fully-qualified, try execv first */
3773  if (progpath[0] == '/')
3774  {
3775  execv (progpath, (char * const *) argv);
3776  /* Ok, that failed. Now if path_fallback is given, let's
3777  * try unqualified. This is mostly a hack to work
3778  * around systems which ship dbus-launch in /usr/bin
3779  * but everything else in /bin (because dbus-launch
3780  * depends on X11).
3781  */
3782  if (path_fallback)
3783  /* We must have a slash, because we checked above */
3784  execvp (strrchr (progpath, '/')+1, (char * const *) argv);
3785  }
3786  else
3787  execvp (progpath, (char * const *) argv);
3788 
3789  /* still nothing, we failed */
3790  _exit (1);
3791  }
3792 
3793  /* parent process */
3794  close (result_pipe[WRITE_END]);
3795  close (errors_pipe[WRITE_END]);
3796  result_pipe[WRITE_END] = -1;
3797  errors_pipe[WRITE_END] = -1;
3798 
3799  ret = 0;
3800  do
3801  {
3802  ret = _dbus_read (result_pipe[READ_END], result, 1024);
3803  }
3804  while (ret > 0);
3805 
3806  /* reap the child process to avoid it lingering as zombie */
3807  do
3808  {
3809  ret = waitpid (pid, &status, 0);
3810  }
3811  while (ret == -1 && errno == EINTR);
3812 
3813  /* We succeeded if the process exited with status 0 and
3814  anything was read */
3815  if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 )
3816  {
3817  /* The process ended with error */
3818  DBusString error_message;
3819  if (!_dbus_string_init (&error_message))
3820  {
3821  _DBUS_SET_OOM (error);
3822  goto out;
3823  }
3824 
3825  ret = 0;
3826  do
3827  {
3828  ret = _dbus_read (errors_pipe[READ_END], &error_message, 1024);
3829  }
3830  while (ret > 0);
3831 
3832  _dbus_string_set_length (result, orig_len);
3833  if (_dbus_string_get_length (&error_message) > 0)
3835  "%s terminated abnormally with the following error: %s",
3836  progpath, _dbus_string_get_data (&error_message));
3837  else
3839  "%s terminated abnormally without any error message",
3840  progpath);
3841  goto out;
3842  }
3843 
3844  retval = TRUE;
3845 
3846  out:
3847  sigprocmask (SIG_SETMASK, &old_set, NULL);
3848 
3849  if (retval)
3850  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3851  else
3852  _DBUS_ASSERT_ERROR_IS_SET (error);
3853 
3854  if (result_pipe[0] != -1)
3855  close (result_pipe[0]);
3856  if (result_pipe[1] != -1)
3857  close (result_pipe[1]);
3858  if (errors_pipe[0] != -1)
3859  close (errors_pipe[0]);
3860  if (errors_pipe[1] != -1)
3861  close (errors_pipe[1]);
3862 
3863  return retval;
3864 }
3865 #endif
3866 
3880 _dbus_get_autolaunch_address (const char *scope,
3881  DBusString *address,
3882  DBusError *error)
3883 {
3884 #ifdef DBUS_ENABLE_X11_AUTOLAUNCH
3885  static const char arg_dbus_launch[] = "dbus-launch";
3886  static const char arg_autolaunch[] = "--autolaunch";
3887  static const char arg_binary_syntax[] = "--binary-syntax";
3888  static const char arg_close_stderr[] = "--close-stderr";
3889 
3890  /* Perform X11-based autolaunch. (We also support launchd-based autolaunch,
3891  * but that's done elsewhere, and if it worked, this function wouldn't
3892  * be called.) */
3893  const char *display;
3894  const char *progpath;
3895  const char *argv[6];
3896  int i;
3897  DBusString uuid;
3898  dbus_bool_t retval;
3899 
3900  if (_dbus_check_setuid ())
3901  {
3903  "Unable to autolaunch when setuid");
3904  return FALSE;
3905  }
3906 
3907  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3908  retval = FALSE;
3909 
3910  /* fd.o #19997: if $DISPLAY isn't set to something useful, then
3911  * dbus-launch-x11 is just going to fail. Rather than trying to
3912  * run it, we might as well bail out early with a nice error.
3913  *
3914  * This is not strictly true in a world where the user bus exists,
3915  * because dbus-launch --autolaunch knows how to connect to that -
3916  * but if we were going to connect to the user bus, we'd have done
3917  * so before trying autolaunch: in any case. */
3918  display = _dbus_getenv ("DISPLAY");
3919 
3920  if (display == NULL || display[0] == '\0')
3921  {
3923  "Unable to autolaunch a dbus-daemon without a $DISPLAY for X11");
3924  return FALSE;
3925  }
3926 
3927  if (!_dbus_string_init (&uuid))
3928  {
3929  _DBUS_SET_OOM (error);
3930  return FALSE;
3931  }
3932 
3933  if (!_dbus_get_local_machine_uuid_encoded (&uuid, error))
3934  {
3935  goto out;
3936  }
3937 
3938 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
3939  progpath = _dbus_getenv ("DBUS_TEST_DBUS_LAUNCH");
3940 
3941  if (progpath == NULL)
3942 #endif
3943  progpath = DBUS_BINDIR "/dbus-launch";
3944  /*
3945  * argv[0] is always dbus-launch, that's the name what we'll
3946  * get from /proc, or ps(1), regardless what the progpath is,
3947  * see fd.o#69716
3948  */
3949  i = 0;
3950  argv[i] = arg_dbus_launch;
3951  ++i;
3952  argv[i] = arg_autolaunch;
3953  ++i;
3954  argv[i] = _dbus_string_get_data (&uuid);
3955  ++i;
3956  argv[i] = arg_binary_syntax;
3957  ++i;
3958  argv[i] = arg_close_stderr;
3959  ++i;
3960  argv[i] = NULL;
3961  ++i;
3962 
3963  _dbus_assert (i == _DBUS_N_ELEMENTS (argv));
3964 
3965  retval = _read_subprocess_line_argv (progpath,
3966  TRUE,
3967  argv, address, error);
3968 
3969  out:
3970  _dbus_string_free (&uuid);
3971  return retval;
3972 #else
3974  "Using X11 for dbus-daemon autolaunch was disabled at compile time, "
3975  "set your DBUS_SESSION_BUS_ADDRESS instead");
3976  return FALSE;
3977 #endif
3978 }
3979 
4000  dbus_bool_t create_if_not_found,
4001  DBusError *error)
4002 {
4003  DBusError our_error = DBUS_ERROR_INIT;
4004  DBusError etc_error = DBUS_ERROR_INIT;
4005  DBusString filename;
4006  dbus_bool_t b;
4007 
4008  _dbus_string_init_const (&filename, DBUS_MACHINE_UUID_FILE);
4009 
4010  b = _dbus_read_uuid_file (&filename, machine_id, FALSE, &our_error);
4011  if (b)
4012  return TRUE;
4013 
4014  /* Fallback to the system machine ID */
4015  _dbus_string_init_const (&filename, "/etc/machine-id");
4016  b = _dbus_read_uuid_file (&filename, machine_id, FALSE, &etc_error);
4017 
4018  if (b)
4019  {
4020  if (create_if_not_found)
4021  {
4022  /* try to copy it to the DBUS_MACHINE_UUID_FILE, but do not
4023  * complain if that isn't possible for whatever reason */
4024  _dbus_string_init_const (&filename, DBUS_MACHINE_UUID_FILE);
4025  _dbus_write_uuid_file (&filename, machine_id, NULL);
4026  }
4027 
4028  dbus_error_free (&our_error);
4029  return TRUE;
4030  }
4031 
4032  if (!create_if_not_found)
4033  {
4034  dbus_set_error (error, etc_error.name,
4035  "D-Bus library appears to be incorrectly set up: "
4036  "see the manual page for dbus-uuidgen to correct "
4037  "this issue. (%s; %s)",
4038  our_error.message, etc_error.message);
4039  dbus_error_free (&our_error);
4040  dbus_error_free (&etc_error);
4041  return FALSE;
4042  }
4043 
4044  dbus_error_free (&our_error);
4045  dbus_error_free (&etc_error);
4046 
4047  /* if none found, try to make a new one */
4048  _dbus_string_init_const (&filename, DBUS_MACHINE_UUID_FILE);
4049 
4050  if (!_dbus_generate_uuid (machine_id, error))
4051  return FALSE;
4052 
4053  return _dbus_write_uuid_file (&filename, machine_id, error);
4054 }
4055 
4065  const char *launchd_env_var,
4066  DBusError *error)
4067 {
4068 #ifdef DBUS_ENABLE_LAUNCHD
4069  char *argv[4];
4070  int i;
4071 
4072  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4073 
4074  if (_dbus_check_setuid ())
4075  {
4077  "Unable to find launchd socket when setuid");
4078  return FALSE;
4079  }
4080 
4081  i = 0;
4082  argv[i] = "launchctl";
4083  ++i;
4084  argv[i] = "getenv";
4085  ++i;
4086  argv[i] = (char*)launchd_env_var;
4087  ++i;
4088  argv[i] = NULL;
4089  ++i;
4090 
4091  _dbus_assert (i == _DBUS_N_ELEMENTS (argv));
4092 
4093  if (!_read_subprocess_line_argv(argv[0], TRUE, argv, socket_path, error))
4094  {
4095  return FALSE;
4096  }
4097 
4098  /* no error, but no result either */
4099  if (_dbus_string_get_length(socket_path) == 0)
4100  {
4101  return FALSE;
4102  }
4103 
4104  /* strip the carriage-return */
4105  _dbus_string_shorten(socket_path, 1);
4106  return TRUE;
4107 #else /* DBUS_ENABLE_LAUNCHD */
4109  "can't lookup socket from launchd; launchd support not compiled in");
4110  return FALSE;
4111 #endif
4112 }
4113 
4114 #ifdef DBUS_ENABLE_LAUNCHD
4115 static dbus_bool_t
4116 _dbus_lookup_session_address_launchd (DBusString *address, DBusError *error)
4117 {
4118  dbus_bool_t valid_socket;
4119  DBusString socket_path;
4120 
4121  if (_dbus_check_setuid ())
4122  {
4124  "Unable to find launchd socket when setuid");
4125  return FALSE;
4126  }
4127 
4128  if (!_dbus_string_init (&socket_path))
4129  {
4130  _DBUS_SET_OOM (error);
4131  return FALSE;
4132  }
4133 
4134  valid_socket = _dbus_lookup_launchd_socket (&socket_path, "DBUS_LAUNCHD_SESSION_BUS_SOCKET", error);
4135 
4136  if (dbus_error_is_set(error))
4137  {
4138  _dbus_string_free(&socket_path);
4139  return FALSE;
4140  }
4141 
4142  if (!valid_socket)
4143  {
4144  dbus_set_error(error, "no socket path",
4145  "launchd did not provide a socket path, "
4146  "verify that org.freedesktop.dbus-session.plist is loaded!");
4147  _dbus_string_free(&socket_path);
4148  return FALSE;
4149  }
4150  if (!_dbus_string_append (address, "unix:path="))
4151  {
4152  _DBUS_SET_OOM (error);
4153  _dbus_string_free(&socket_path);
4154  return FALSE;
4155  }
4156  if (!_dbus_string_copy (&socket_path, 0, address,
4157  _dbus_string_get_length (address)))
4158  {
4159  _DBUS_SET_OOM (error);
4160  _dbus_string_free(&socket_path);
4161  return FALSE;
4162  }
4163 
4164  _dbus_string_free(&socket_path);
4165  return TRUE;
4166 }
4167 #endif
4168 
4170 _dbus_lookup_user_bus (dbus_bool_t *supported,
4171  DBusString *address,
4172  DBusError *error)
4173 {
4174  const char *runtime_dir = _dbus_getenv ("XDG_RUNTIME_DIR");
4175  dbus_bool_t ret = FALSE;
4176  struct stat stbuf;
4177  DBusString user_bus_path;
4178 
4179  if (runtime_dir == NULL)
4180  {
4181  _dbus_verbose ("XDG_RUNTIME_DIR not found in environment");
4182  *supported = FALSE;
4183  return TRUE; /* Cannot use it, but not an error */
4184  }
4185 
4186  if (!_dbus_string_init (&user_bus_path))
4187  {
4188  _DBUS_SET_OOM (error);
4189  return FALSE;
4190  }
4191 
4192  if (!_dbus_string_append_printf (&user_bus_path, "%s/bus", runtime_dir))
4193  {
4194  _DBUS_SET_OOM (error);
4195  goto out;
4196  }
4197 
4198  if (lstat (_dbus_string_get_const_data (&user_bus_path), &stbuf) == -1)
4199  {
4200  _dbus_verbose ("XDG_RUNTIME_DIR/bus not available: %s",
4201  _dbus_strerror (errno));
4202  *supported = FALSE;
4203  ret = TRUE; /* Cannot use it, but not an error */
4204  goto out;
4205  }
4206 
4207  if (stbuf.st_uid != getuid ())
4208  {
4209  _dbus_verbose ("XDG_RUNTIME_DIR/bus owned by uid %ld, not our uid %ld",
4210  (long) stbuf.st_uid, (long) getuid ());
4211  *supported = FALSE;
4212  ret = TRUE; /* Cannot use it, but not an error */
4213  goto out;
4214  }
4215 
4216  if ((stbuf.st_mode & S_IFMT) != S_IFSOCK)
4217  {
4218  _dbus_verbose ("XDG_RUNTIME_DIR/bus is not a socket: st_mode = 0o%lo",
4219  (long) stbuf.st_mode);
4220  *supported = FALSE;
4221  ret = TRUE; /* Cannot use it, but not an error */
4222  goto out;
4223  }
4224 
4225  if (!_dbus_string_append (address, "unix:path=") ||
4226  !_dbus_address_append_escaped (address, &user_bus_path))
4227  {
4228  _DBUS_SET_OOM (error);
4229  goto out;
4230  }
4231 
4232  *supported = TRUE;
4233  ret = TRUE;
4234 
4235 out:
4236  _dbus_string_free (&user_bus_path);
4237  return ret;
4238 }
4239 
4261  DBusString *address,
4262  DBusError *error)
4263 {
4264 #ifdef DBUS_ENABLE_LAUNCHD
4265  *supported = TRUE;
4266  return _dbus_lookup_session_address_launchd (address, error);
4267 #else
4268  *supported = FALSE;
4269 
4270  if (!_dbus_lookup_user_bus (supported, address, error))
4271  return FALSE;
4272  else if (*supported)
4273  return TRUE;
4274 
4275  /* On non-Mac Unix platforms, if the session address isn't already
4276  * set in DBUS_SESSION_BUS_ADDRESS environment variable and the
4277  * $XDG_RUNTIME_DIR/bus can't be used, we punt and fall back to the
4278  * autolaunch: global default; see init_session_address in
4279  * dbus/dbus-bus.c. */
4280  return TRUE;
4281 #endif
4282 }
4283 
4291 void
4293 {
4295 }
4296 
4312  DBusCredentials *credentials)
4313 {
4314  DBusString homedir;
4315  DBusString dotdir;
4316  dbus_uid_t uid;
4317 
4318  _dbus_assert (credentials != NULL);
4320 
4321  if (!_dbus_string_init (&homedir))
4322  return FALSE;
4323 
4324  uid = _dbus_credentials_get_unix_uid (credentials);
4325  _dbus_assert (uid != DBUS_UID_UNSET);
4326 
4327  if (!_dbus_homedir_from_uid (uid, &homedir))
4328  goto failed;
4329 
4330 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
4331  {
4332  const char *override;
4333 
4334  override = _dbus_getenv ("DBUS_TEST_HOMEDIR");
4335  if (override != NULL && *override != '\0')
4336  {
4337  _dbus_string_set_length (&homedir, 0);
4338  if (!_dbus_string_append (&homedir, override))
4339  goto failed;
4340 
4341  _dbus_verbose ("Using fake homedir for testing: %s\n",
4342  _dbus_string_get_const_data (&homedir));
4343  }
4344  else
4345  {
4346  /* Not strictly thread-safe, but if we fail at thread-safety here,
4347  * the worst that will happen is some extra warnings. */
4348  static dbus_bool_t already_warned = FALSE;
4349  if (!already_warned)
4350  {
4351  _dbus_warn ("Using %s for testing, set DBUS_TEST_HOMEDIR to avoid",
4352  _dbus_string_get_const_data (&homedir));
4353  already_warned = TRUE;
4354  }
4355  }
4356  }
4357 #endif
4358 
4359  _dbus_string_init_const (&dotdir, ".dbus-keyrings");
4360  if (!_dbus_concat_dir_and_file (&homedir,
4361  &dotdir))
4362  goto failed;
4363 
4364  if (!_dbus_string_copy (&homedir, 0,
4365  directory, _dbus_string_get_length (directory))) {
4366  goto failed;
4367  }
4368 
4369  _dbus_string_free (&homedir);
4370  return TRUE;
4371 
4372  failed:
4373  _dbus_string_free (&homedir);
4374  return FALSE;
4375 }
4376 
4377 //PENDING(kdab) docs
4379 _dbus_daemon_publish_session_bus_address (const char* addr,
4380  const char *scope)
4381 {
4382  return TRUE;
4383 }
4384 
4385 //PENDING(kdab) docs
4386 void
4387 _dbus_daemon_unpublish_session_bus_address (void)
4388 {
4389 
4390 }
4391 
4400 {
4401  /* Avoid the -Wlogical-op GCC warning, which can be triggered when EAGAIN and
4402  * EWOULDBLOCK are numerically equal, which is permitted as described by
4403  * errno(3).
4404  */
4405 #if EAGAIN == EWOULDBLOCK
4406  return e == EAGAIN;
4407 #else
4408  return e == EAGAIN || e == EWOULDBLOCK;
4409 #endif
4410 }
4411 
4421  DBusError *error)
4422 {
4423  const char *filename_c;
4424 
4425  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
4426 
4427  filename_c = _dbus_string_get_const_data (filename);
4428 
4429  if (rmdir (filename_c) != 0)
4430  {
4432  "Failed to remove directory %s: %s\n",
4433  filename_c, _dbus_strerror (errno));
4434  return FALSE;
4435  }
4436 
4437  return TRUE;
4438 }
4439 
4449 {
4450 #ifdef SCM_RIGHTS
4451  union {
4452  struct sockaddr sa;
4453  struct sockaddr_storage storage;
4454  struct sockaddr_un un;
4455  } sa_buf;
4456 
4457  socklen_t sa_len = sizeof(sa_buf);
4458 
4459  _DBUS_ZERO(sa_buf);
4460 
4461  if (getsockname(fd.fd, &sa_buf.sa, &sa_len) < 0)
4462  return FALSE;
4463 
4464  return sa_buf.sa.sa_family == AF_UNIX;
4465 
4466 #else
4467  return FALSE;
4468 
4469 #endif
4470 }
4471 
4476 void
4478 {
4479  int maxfds, i;
4480 
4481 #ifdef __linux__
4482  DIR *d;
4483 
4484  /* On Linux we can optimize this a bit if /proc is available. If it
4485  isn't available, fall back to the brute force way. */
4486 
4487  d = opendir ("/proc/self/fd");
4488  if (d)
4489  {
4490  for (;;)
4491  {
4492  struct dirent *de;
4493  int fd;
4494  long l;
4495  char *e = NULL;
4496 
4497  de = readdir (d);
4498  if (!de)
4499  break;
4500 
4501  if (de->d_name[0] == '.')
4502  continue;
4503 
4504  errno = 0;
4505  l = strtol (de->d_name, &e, 10);
4506  if (errno != 0 || e == NULL || *e != '\0')
4507  continue;
4508 
4509  fd = (int) l;
4510  if (fd < 3)
4511  continue;
4512 
4513  if (fd == dirfd (d))
4514  continue;
4515 
4516  close (fd);
4517  }
4518 
4519  closedir (d);
4520  return;
4521  }
4522 #endif
4523 
4524  maxfds = sysconf (_SC_OPEN_MAX);
4525 
4526  /* Pick something reasonable if for some reason sysconf says
4527  * unlimited.
4528  */
4529  if (maxfds < 0)
4530  maxfds = 1024;
4531 
4532  /* close all inherited fds */
4533  for (i = 3; i < maxfds; i++)
4534  close (i);
4535 }
4536 
4548 {
4549  /* TODO: get __libc_enable_secure exported from glibc.
4550  * See http://www.openwall.com/lists/owl-dev/2012/08/14/1
4551  */
4552 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE)
4553  {
4554  /* See glibc/include/unistd.h */
4555  extern int __libc_enable_secure;
4556  return __libc_enable_secure;
4557  }
4558 #elif defined(HAVE_ISSETUGID)
4559  /* BSD: http://www.freebsd.org/cgi/man.cgi?query=issetugid&sektion=2 */
4560  return issetugid ();
4561 #else
4562  uid_t ruid, euid, suid; /* Real, effective and saved user ID's */
4563  gid_t rgid, egid, sgid; /* Real, effective and saved group ID's */
4564 
4565  /* We call into this function from _dbus_threads_init_platform_specific()
4566  * to make sure these are initialized before we start threading. */
4567  static dbus_bool_t check_setuid_initialised;
4568  static dbus_bool_t is_setuid;
4569 
4570  if (_DBUS_UNLIKELY (!check_setuid_initialised))
4571  {
4572 #ifdef HAVE_GETRESUID
4573  if (getresuid (&ruid, &euid, &suid) != 0 ||
4574  getresgid (&rgid, &egid, &sgid) != 0)
4575 #endif /* HAVE_GETRESUID */
4576  {
4577  suid = ruid = getuid ();
4578  sgid = rgid = getgid ();
4579  euid = geteuid ();
4580  egid = getegid ();
4581  }
4582 
4583  check_setuid_initialised = TRUE;
4584  is_setuid = (ruid != euid || ruid != suid ||
4585  rgid != egid || rgid != sgid);
4586 
4587  }
4588  return is_setuid;
4589 #endif
4590 }
4591 
4601  DBusString *address,
4602  DBusError *error)
4603 {
4604  union {
4605  struct sockaddr sa;
4606  struct sockaddr_storage storage;
4607  struct sockaddr_un un;
4608  struct sockaddr_in ipv4;
4609  struct sockaddr_in6 ipv6;
4610  } socket;
4611  char hostip[INET6_ADDRSTRLEN];
4612  socklen_t size = sizeof (socket);
4613  DBusString path_str;
4614 
4615  if (getsockname (fd.fd, &socket.sa, &size))
4616  goto err;
4617 
4618  switch (socket.sa.sa_family)
4619  {
4620  case AF_UNIX:
4621  if (socket.un.sun_path[0]=='\0')
4622  {
4623  _dbus_string_init_const (&path_str, &(socket.un.sun_path[1]));
4624  if (_dbus_string_append (address, "unix:abstract=") &&
4625  _dbus_address_append_escaped (address, &path_str))
4626  return TRUE;
4627  }
4628  else
4629  {
4630  _dbus_string_init_const (&path_str, socket.un.sun_path);
4631  if (_dbus_string_append (address, "unix:path=") &&
4632  _dbus_address_append_escaped (address, &path_str))
4633  return TRUE;
4634  }
4635  break;
4636  case AF_INET:
4637  if (inet_ntop (AF_INET, &socket.ipv4.sin_addr, hostip, sizeof (hostip)))
4638  if (_dbus_string_append_printf (address, "tcp:family=ipv4,host=%s,port=%u",
4639  hostip, ntohs (socket.ipv4.sin_port)))
4640  return TRUE;
4641  break;
4642 #ifdef AF_INET6
4643  case AF_INET6:
4644  _dbus_string_init_const (&path_str, hostip);
4645  if (inet_ntop (AF_INET6, &socket.ipv6.sin6_addr, hostip, sizeof (hostip)))
4646  if (_dbus_string_append_printf (address, "tcp:family=ipv6,port=%u,host=",
4647  ntohs (socket.ipv6.sin6_port)) &&
4648  _dbus_address_append_escaped (address, &path_str))
4649  return TRUE;
4650  break;
4651 #endif
4652  default:
4653  dbus_set_error (error,
4654  _dbus_error_from_errno (EINVAL),
4655  "Failed to read address from socket: Unknown socket type.");
4656  return FALSE;
4657  }
4658  err:
4659  dbus_set_error (error,
4660  _dbus_error_from_errno (errno),
4661  "Failed to open socket: %s",
4662  _dbus_strerror (errno));
4663  return FALSE;
4664 }
4665 
4666 int
4667 _dbus_save_socket_errno (void)
4668 {
4669  return errno;
4670 }
4671 
4672 void
4673 _dbus_restore_socket_errno (int saved_errno)
4674 {
4675  errno = saved_errno;
4676 }
4677 
4678 static const char *syslog_tag = "dbus";
4679 #ifdef HAVE_SYSLOG_H
4680 static DBusLogFlags log_flags = DBUS_LOG_FLAGS_STDERR;
4681 #endif
4682 
4697 void
4698 _dbus_init_system_log (const char *tag,
4699  DBusLogFlags flags)
4700 {
4701  /* We never want to turn off logging completely */
4702  _dbus_assert (
4703  (flags & (DBUS_LOG_FLAGS_STDERR | DBUS_LOG_FLAGS_SYSTEM_LOG)) != 0);
4704 
4705  syslog_tag = tag;
4706 
4707 #ifdef HAVE_SYSLOG_H
4708  log_flags = flags;
4709 
4710  if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
4711  openlog (tag, LOG_PID, LOG_DAEMON);
4712 #endif
4713 }
4714 
4722 void
4723 _dbus_logv (DBusSystemLogSeverity severity,
4724  const char *msg,
4725  va_list args)
4726 {
4727  va_list tmp;
4728 #ifdef HAVE_SYSLOG_H
4729  if (log_flags & DBUS_LOG_FLAGS_SYSTEM_LOG)
4730  {
4731  int flags;
4732  switch (severity)
4733  {
4734  case DBUS_SYSTEM_LOG_INFO:
4735  flags = LOG_DAEMON | LOG_INFO;
4736  break;
4737  case DBUS_SYSTEM_LOG_WARNING:
4738  flags = LOG_DAEMON | LOG_WARNING;
4739  break;
4740  case DBUS_SYSTEM_LOG_SECURITY:
4741  flags = LOG_AUTH | LOG_NOTICE;
4742  break;
4743  case DBUS_SYSTEM_LOG_ERROR:
4744  flags = LOG_DAEMON|LOG_CRIT;
4745  break;
4746  default:
4747  _dbus_assert_not_reached ("invalid log severity");
4748  }
4749 
4750  DBUS_VA_COPY (tmp, args);
4751  vsyslog (flags, msg, tmp);
4752  va_end (tmp);
4753  }
4754 
4755  /* If we don't have syslog.h, we always behave as though stderr was in
4756  * the flags */
4757  if (log_flags & DBUS_LOG_FLAGS_STDERR)
4758 #endif
4759  {
4760  DBUS_VA_COPY (tmp, args);
4761  fprintf (stderr, "%s[" DBUS_PID_FORMAT "]: ", syslog_tag, _dbus_getpid ());
4762  vfprintf (stderr, msg, tmp);
4763  fputc ('\n', stderr);
4764  va_end (tmp);
4765  }
4766 }
4767 
4768 /* tests in dbus-sysdeps-util.c */
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
Definition: dbus-string.c:935
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.
Definition: dbus-sysdeps.c:437
An atomic integer safe to increment or decrement from multiple threads.
Definition: dbus-sysdeps.h:306
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&#39;t contain...
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_append_uint(DBusString *str, unsigned long value)
Appends an unsigned integer to a DBusString.
Definition: dbus-sysdeps.c:394
const char * message
public error message field
Definition: dbus-errors.h:51
char * username
Username.
#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.
Definition: dbus-sysdeps.h:311
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&#39;re running on from the dbus configuration.
void _dbus_close_all(void)
Closes all file descriptors except the first three (i.e.
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
Definition: dbus-string.c:760
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().
Definition: dbus-memory.c:702
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&#39;t supported (like ENOSYS on UNIX).
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
Definition: dbus-memory.h:57
#define DBUS_GID_FORMAT
an appropriate printf format for dbus_gid_t
Definition: dbus-sysdeps.h:150
#define DBUS_PID_FORMAT
an appropriate printf format for dbus_pid_t
Definition: dbus-sysdeps.h:146
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.
Definition: dbus-errors.h:62
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;.
Definition: dbus-userdb.c:386
void dbus_error_free(DBusError *error)
Frees an error that&#39;s been set (or just initialized), then reinitializes the error as in dbus_error_i...
Definition: dbus-errors.c:211
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.
Definition: dbus-sysdeps.h:405
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.
Definition: dbus-string.c:490
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.
Definition: dbus-string.c:175
#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.
Definition: dbus-string.c:780
short events
Events to poll for.
Definition: dbus-sysdeps.h:400
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&#39;s copied to the d...
Definition: dbus-string.c:1283
#define DBUS_PID_UNSET
an invalid PID used to represent an uninitialized dbus_pid_t field
Definition: dbus-sysdeps.h:139
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
Definition: dbus-sysdeps.h:141
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.
Definition: dbus-sysdeps.c:592
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.
Definition: dbus-userdb.c:498
unsigned long dbus_pid_t
A process ID.
Definition: dbus-sysdeps.h:132
Socket interface.
Definition: dbus-sysdeps.h:175
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().
Definition: dbus-memory.c:462
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.
Definition: dbus-types.h:35
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
Definition: dbus-string.c:190
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.
Definition: dbus-sysdeps.h:409
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...
Definition: dbus-string.c:132
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
dbus_uid_t uid
UID.
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.
Definition: dbus-string.c:1114
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.
Definition: dbus-errors.h:48
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...
Definition: dbus-address.c:104
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.
Definition: dbus-errors.c:354
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.
Definition: dbus-string.c:1157
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:259
#define DBUS_GID_UNSET
an invalid GID used to represent an uninitialized dbus_gid_t field
Definition: dbus-sysdeps.h:143
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.
Definition: dbus-sysdeps.h:399
#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
Definition: dbus-errors.h:50
#define READ_END
Helps remember which end of the pipe is which.
Definition: dbus-spawn.c:888
#define DBUS_UID_FORMAT
an appropriate printf format for dbus_uid_t
Definition: dbus-sysdeps.h:148
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.
Definition: dbus-errors.c:243
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
Definition: dbus-string.c:802
#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.
Definition: dbus-spawn.c:890
unsigned long dbus_gid_t
A group ID.
Definition: dbus-sysdeps.h:136
void * dbus_realloc(void *memory, size_t bytes)
Resizes a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:602
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().
Definition: dbus-sysdeps.c:187
unsigned long dbus_uid_t
A user ID.
Definition: dbus-sysdeps.h:134
int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll().
short revents
Events that occurred.
Definition: dbus-sysdeps.h:401
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).
Definition: dbus-errors.c:329
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.
Definition: dbus-sysdeps.h:411