D-Bus  1.13.7
dbus-sysdeps-util-unix.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-sysdeps-util-unix.c Would be in dbus-sysdeps-unix.c, but not used in libdbus
3  *
4  * Copyright (C) 2002, 2003, 2004, 2005 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 #include "dbus-sysdeps.h"
27 #include "dbus-sysdeps-unix.h"
28 #include "dbus-internals.h"
29 #include "dbus-list.h"
30 #include "dbus-pipe.h"
31 #include "dbus-protocol.h"
32 #include "dbus-string.h"
33 #define DBUS_USERDB_INCLUDES_PRIVATE 1
34 #include "dbus-userdb.h"
35 #include "dbus-test.h"
36 
37 #include <sys/types.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <signal.h>
42 #include <unistd.h>
43 #include <stdio.h>
44 #include <errno.h>
45 #include <fcntl.h>
46 #include <sys/stat.h>
47 #ifdef HAVE_SYS_RESOURCE_H
48 #include <sys/resource.h>
49 #endif
50 #include <grp.h>
51 #include <sys/socket.h>
52 #include <dirent.h>
53 #include <sys/un.h>
54 
55 #ifdef HAVE_SYS_PRCTL_H
56 #include <sys/prctl.h>
57 #endif
58 
59 #ifdef HAVE_SYS_SYSLIMITS_H
60 #include <sys/syslimits.h>
61 #endif
62 
63 #ifdef HAVE_SYSTEMD
64 #include <systemd/sd-daemon.h>
65 #endif
66 
67 #ifndef O_BINARY
68 #define O_BINARY 0
69 #endif
70 
88  DBusPipe *print_pid_pipe,
89  DBusError *error,
90  dbus_bool_t keep_umask)
91 {
92  const char *s;
93  pid_t child_pid;
94  DBusEnsureStandardFdsFlags flags;
95 
96  _dbus_verbose ("Becoming a daemon...\n");
97 
98  _dbus_verbose ("chdir to /\n");
99  if (chdir ("/") < 0)
100  {
102  "Could not chdir() to root directory");
103  return FALSE;
104  }
105 
106  _dbus_verbose ("forking...\n");
107 
108  /* Make sure our output buffers aren't redundantly printed by both the
109  * parent and the child */
110  fflush (stdout);
111  fflush (stderr);
112 
113  switch ((child_pid = fork ()))
114  {
115  case -1:
116  _dbus_verbose ("fork failed\n");
117  dbus_set_error (error, _dbus_error_from_errno (errno),
118  "Failed to fork daemon: %s", _dbus_strerror (errno));
119  return FALSE;
120  break;
121 
122  case 0:
123  _dbus_verbose ("in child, closing std file descriptors\n");
124 
125  flags = DBUS_FORCE_STDIN_NULL | DBUS_FORCE_STDOUT_NULL;
126  s = _dbus_getenv ("DBUS_DEBUG_OUTPUT");
127 
128  if (s == NULL || *s == '\0')
129  flags |= DBUS_FORCE_STDERR_NULL;
130  else
131  _dbus_verbose ("keeping stderr open due to DBUS_DEBUG_OUTPUT\n");
132 
133  if (!_dbus_ensure_standard_fds (flags, &s))
134  {
135  _dbus_warn ("%s: %s", s, _dbus_strerror (errno));
136  _exit (1);
137  }
138 
139  if (!keep_umask)
140  {
141  /* Get a predictable umask */
142  _dbus_verbose ("setting umask\n");
143  umask (022);
144  }
145 
146  _dbus_verbose ("calling setsid()\n");
147  if (setsid () == -1)
148  _dbus_assert_not_reached ("setsid() failed");
149 
150  break;
151 
152  default:
153  if (!_dbus_write_pid_to_file_and_pipe (pidfile, print_pid_pipe,
154  child_pid, error))
155  {
156  _dbus_verbose ("pid file or pipe write failed: %s\n",
157  error->message);
158  kill (child_pid, SIGTERM);
159  return FALSE;
160  }
161 
162  _dbus_verbose ("parent exiting\n");
163  _exit (0);
164  break;
165  }
166 
167  return TRUE;
168 }
169 
170 
179 static dbus_bool_t
180 _dbus_write_pid_file (const DBusString *filename,
181  unsigned long pid,
182  DBusError *error)
183 {
184  const char *cfilename;
185  int fd;
186  FILE *f;
187 
188  cfilename = _dbus_string_get_const_data (filename);
189 
190  fd = open (cfilename, O_WRONLY|O_CREAT|O_EXCL|O_BINARY, 0644);
191 
192  if (fd < 0)
193  {
194  dbus_set_error (error, _dbus_error_from_errno (errno),
195  "Failed to open \"%s\": %s", cfilename,
196  _dbus_strerror (errno));
197  return FALSE;
198  }
199 
200  if ((f = fdopen (fd, "w")) == NULL)
201  {
202  dbus_set_error (error, _dbus_error_from_errno (errno),
203  "Failed to fdopen fd %d: %s", fd, _dbus_strerror (errno));
204  _dbus_close (fd, NULL);
205  return FALSE;
206  }
207 
208  if (fprintf (f, "%lu\n", pid) < 0)
209  {
210  dbus_set_error (error, _dbus_error_from_errno (errno),
211  "Failed to write to \"%s\": %s", cfilename,
212  _dbus_strerror (errno));
213 
214  fclose (f);
215  return FALSE;
216  }
217 
218  if (fclose (f) == EOF)
219  {
220  dbus_set_error (error, _dbus_error_from_errno (errno),
221  "Failed to close \"%s\": %s", cfilename,
222  _dbus_strerror (errno));
223  return FALSE;
224  }
225 
226  return TRUE;
227 }
228 
242  DBusPipe *print_pid_pipe,
243  dbus_pid_t pid_to_write,
244  DBusError *error)
245 {
246  if (pidfile)
247  {
248  _dbus_verbose ("writing pid file %s\n", _dbus_string_get_const_data (pidfile));
249  if (!_dbus_write_pid_file (pidfile,
250  pid_to_write,
251  error))
252  {
253  _dbus_verbose ("pid file write failed\n");
254  _DBUS_ASSERT_ERROR_IS_SET(error);
255  return FALSE;
256  }
257  }
258  else
259  {
260  _dbus_verbose ("No pid file requested\n");
261  }
262 
263  if (print_pid_pipe != NULL && _dbus_pipe_is_valid (print_pid_pipe))
264  {
265  DBusString pid;
266  int bytes;
267 
268  _dbus_verbose ("writing our pid to pipe %d\n",
269  print_pid_pipe->fd);
270 
271  if (!_dbus_string_init (&pid))
272  {
273  _DBUS_SET_OOM (error);
274  return FALSE;
275  }
276 
277  if (!_dbus_string_append_int (&pid, pid_to_write) ||
278  !_dbus_string_append (&pid, "\n"))
279  {
280  _dbus_string_free (&pid);
281  _DBUS_SET_OOM (error);
282  return FALSE;
283  }
284 
285  bytes = _dbus_string_get_length (&pid);
286  if (_dbus_pipe_write (print_pid_pipe, &pid, 0, bytes, error) != bytes)
287  {
288  /* _dbus_pipe_write sets error only on failure, not short write */
289  if (error != NULL && !dbus_error_is_set(error))
290  {
292  "Printing message bus PID: did not write enough bytes\n");
293  }
294  _dbus_string_free (&pid);
295  return FALSE;
296  }
297 
298  _dbus_string_free (&pid);
299  }
300  else
301  {
302  _dbus_verbose ("No pid pipe to write to\n");
303  }
304 
305  return TRUE;
306 }
307 
315 _dbus_verify_daemon_user (const char *user)
316 {
317  DBusString u;
318 
319  _dbus_string_init_const (&u, user);
320 
322 }
323 
324 
325 /* The HAVE_LIBAUDIT case lives in selinux.c */
326 #ifndef HAVE_LIBAUDIT
327 
335 _dbus_change_to_daemon_user (const char *user,
336  DBusError *error)
337 {
338  dbus_uid_t uid;
339  dbus_gid_t gid;
340  DBusString u;
341 
342  _dbus_string_init_const (&u, user);
343 
344  if (!_dbus_get_user_id_and_primary_group (&u, &uid, &gid))
345  {
347  "User '%s' does not appear to exist?",
348  user);
349  return FALSE;
350  }
351 
352  /* setgroups() only works if we are a privileged process,
353  * so we don't return error on failure; the only possible
354  * failure is that we don't have perms to do it.
355  *
356  * not sure this is right, maybe if setuid()
357  * is going to work then setgroups() should also work.
358  */
359  if (setgroups (0, NULL) < 0)
360  _dbus_warn ("Failed to drop supplementary groups: %s",
361  _dbus_strerror (errno));
362 
363  /* Set GID first, or the setuid may remove our permission
364  * to change the GID
365  */
366  if (setgid (gid) < 0)
367  {
368  dbus_set_error (error, _dbus_error_from_errno (errno),
369  "Failed to set GID to %lu: %s", gid,
370  _dbus_strerror (errno));
371  return FALSE;
372  }
373 
374  if (setuid (uid) < 0)
375  {
376  dbus_set_error (error, _dbus_error_from_errno (errno),
377  "Failed to set UID to %lu: %s", uid,
378  _dbus_strerror (errno));
379  return FALSE;
380  }
381 
382  return TRUE;
383 }
384 #endif /* !HAVE_LIBAUDIT */
385 
386 #ifdef HAVE_SETRLIMIT
387 
388 /* We assume that if we have setrlimit, we also have getrlimit and
389  * struct rlimit.
390  */
391 
392 struct DBusRLimit {
393  struct rlimit lim;
394 };
395 
396 DBusRLimit *
397 _dbus_rlimit_save_fd_limit (DBusError *error)
398 {
399  DBusRLimit *self;
400 
401  self = dbus_new0 (DBusRLimit, 1);
402 
403  if (self == NULL)
404  {
405  _DBUS_SET_OOM (error);
406  return NULL;
407  }
408 
409  if (getrlimit (RLIMIT_NOFILE, &self->lim) < 0)
410  {
411  dbus_set_error (error, _dbus_error_from_errno (errno),
412  "Failed to get fd limit: %s", _dbus_strerror (errno));
413  dbus_free (self);
414  return NULL;
415  }
416 
417  return self;
418 }
419 
421 _dbus_rlimit_raise_fd_limit_if_privileged (unsigned int desired,
422  DBusError *error)
423 {
424  struct rlimit lim;
425 
426  /* No point to doing this practically speaking
427  * if we're not uid 0. We expect the system
428  * bus to use this before we change UID, and
429  * the session bus takes the Linux default,
430  * currently 1024 for cur and 4096 for max.
431  */
432  if (getuid () != 0)
433  {
434  /* not an error, we're probably the session bus */
435  return TRUE;
436  }
437 
438  if (getrlimit (RLIMIT_NOFILE, &lim) < 0)
439  {
440  dbus_set_error (error, _dbus_error_from_errno (errno),
441  "Failed to get fd limit: %s", _dbus_strerror (errno));
442  return FALSE;
443  }
444 
445  if (lim.rlim_cur == RLIM_INFINITY || lim.rlim_cur >= desired)
446  {
447  /* not an error, everything is fine */
448  return TRUE;
449  }
450 
451  /* Ignore "maximum limit", assume we have the "superuser"
452  * privileges. On Linux this is CAP_SYS_RESOURCE.
453  */
454  lim.rlim_cur = lim.rlim_max = desired;
455 
456  if (setrlimit (RLIMIT_NOFILE, &lim) < 0)
457  {
458  dbus_set_error (error, _dbus_error_from_errno (errno),
459  "Failed to set fd limit to %u: %s",
460  desired, _dbus_strerror (errno));
461  return FALSE;
462  }
463 
464  return TRUE;
465 }
466 
468 _dbus_rlimit_restore_fd_limit (DBusRLimit *saved,
469  DBusError *error)
470 {
471  if (setrlimit (RLIMIT_NOFILE, &saved->lim) < 0)
472  {
473  dbus_set_error (error, _dbus_error_from_errno (errno),
474  "Failed to restore old fd limit: %s",
475  _dbus_strerror (errno));
476  return FALSE;
477  }
478 
479  return TRUE;
480 }
481 
482 #else /* !HAVE_SETRLIMIT */
483 
484 static void
485 fd_limit_not_supported (DBusError *error)
486 {
488  "cannot change fd limit on this platform");
489 }
490 
491 DBusRLimit *
492 _dbus_rlimit_save_fd_limit (DBusError *error)
493 {
494  fd_limit_not_supported (error);
495  return NULL;
496 }
497 
499 _dbus_rlimit_raise_fd_limit_if_privileged (unsigned int desired,
500  DBusError *error)
501 {
502  fd_limit_not_supported (error);
503  return FALSE;
504 }
505 
507 _dbus_rlimit_restore_fd_limit (DBusRLimit *saved,
508  DBusError *error)
509 {
510  fd_limit_not_supported (error);
511  return FALSE;
512 }
513 
514 #endif
515 
516 void
517 _dbus_rlimit_free (DBusRLimit *lim)
518 {
519  dbus_free (lim);
520 }
521 
527 void
529  DBusSignalHandler handler)
530 {
531  struct sigaction act;
532  sigset_t empty_mask;
533 
534  sigemptyset (&empty_mask);
535  act.sa_handler = handler;
536  act.sa_mask = empty_mask;
537  act.sa_flags = 0;
538  sigaction (sig, &act, NULL);
539 }
540 
547 _dbus_file_exists (const char *file)
548 {
549  return (access (file, F_OK) == 0);
550 }
551 
559 _dbus_user_at_console (const char *username,
560  DBusError *error)
561 {
562 #ifdef DBUS_CONSOLE_AUTH_DIR
563  DBusString u, f;
564  dbus_bool_t result;
565 
566  result = FALSE;
567  if (!_dbus_string_init (&f))
568  {
569  _DBUS_SET_OOM (error);
570  return FALSE;
571  }
572 
573  if (!_dbus_string_append (&f, DBUS_CONSOLE_AUTH_DIR))
574  {
575  _DBUS_SET_OOM (error);
576  goto out;
577  }
578 
579  _dbus_string_init_const (&u, username);
580 
581  if (!_dbus_concat_dir_and_file (&f, &u))
582  {
583  _DBUS_SET_OOM (error);
584  goto out;
585  }
586 
587  result = _dbus_file_exists (_dbus_string_get_const_data (&f));
588 
589  out:
590  _dbus_string_free (&f);
591 
592  return result;
593 #else
594  return FALSE;
595 #endif
596 }
597 
598 
607 {
608  if (_dbus_string_get_length (filename) > 0)
609  return _dbus_string_get_byte (filename, 0) == '/';
610  else
611  return FALSE;
612 }
613 
623 _dbus_stat (const DBusString *filename,
624  DBusStat *statbuf,
625  DBusError *error)
626 {
627  const char *filename_c;
628  struct stat sb;
629 
630  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
631 
632  filename_c = _dbus_string_get_const_data (filename);
633 
634  if (stat (filename_c, &sb) < 0)
635  {
636  dbus_set_error (error, _dbus_error_from_errno (errno),
637  "%s", _dbus_strerror (errno));
638  return FALSE;
639  }
640 
641  statbuf->mode = sb.st_mode;
642  statbuf->nlink = sb.st_nlink;
643  statbuf->uid = sb.st_uid;
644  statbuf->gid = sb.st_gid;
645  statbuf->size = sb.st_size;
646  statbuf->atime = sb.st_atime;
647  statbuf->mtime = sb.st_mtime;
648  statbuf->ctime = sb.st_ctime;
649 
650  return TRUE;
651 }
652 
653 
658 {
659  DIR *d;
661 };
662 
672  DBusError *error)
673 {
674  DIR *d;
675  DBusDirIter *iter;
676  const char *filename_c;
677 
678  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
679 
680  filename_c = _dbus_string_get_const_data (filename);
681 
682  d = opendir (filename_c);
683  if (d == NULL)
684  {
685  dbus_set_error (error, _dbus_error_from_errno (errno),
686  "Failed to read directory \"%s\": %s",
687  filename_c,
688  _dbus_strerror (errno));
689  return NULL;
690  }
691  iter = dbus_new0 (DBusDirIter, 1);
692  if (iter == NULL)
693  {
694  closedir (d);
696  "Could not allocate memory for directory iterator");
697  return NULL;
698  }
699 
700  iter->d = d;
701 
702  return iter;
703 }
704 
720  DBusString *filename,
721  DBusError *error)
722 {
723  struct dirent *ent;
724  int err;
725 
726  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
727 
728  again:
729  errno = 0;
730  ent = readdir (iter->d);
731 
732  if (!ent)
733  {
734  err = errno;
735 
736  if (err != 0)
737  dbus_set_error (error,
739  "%s", _dbus_strerror (err));
740 
741  return FALSE;
742  }
743  else if (ent->d_name[0] == '.' &&
744  (ent->d_name[1] == '\0' ||
745  (ent->d_name[1] == '.' && ent->d_name[2] == '\0')))
746  goto again;
747  else
748  {
749  _dbus_string_set_length (filename, 0);
750  if (!_dbus_string_append (filename, ent->d_name))
751  {
753  "No memory to read directory entry");
754  return FALSE;
755  }
756  else
757  {
758  return TRUE;
759  }
760  }
761 }
762 
766 void
768 {
769  closedir (iter->d);
770  dbus_free (iter);
771 }
772 
773 static dbus_bool_t
774 fill_user_info_from_group (struct group *g,
775  DBusGroupInfo *info,
776  DBusError *error)
777 {
778  _dbus_assert (g->gr_name != NULL);
779 
780  info->gid = g->gr_gid;
781  info->groupname = _dbus_strdup (g->gr_name);
782 
783  /* info->members = dbus_strdupv (g->gr_mem) */
784 
785  if (info->groupname == NULL)
786  {
788  return FALSE;
789  }
790 
791  return TRUE;
792 }
793 
794 static dbus_bool_t
795 fill_group_info (DBusGroupInfo *info,
796  dbus_gid_t gid,
797  const DBusString *groupname,
798  DBusError *error)
799 {
800  const char *group_c_str;
801 
802  _dbus_assert (groupname != NULL || gid != DBUS_GID_UNSET);
803  _dbus_assert (groupname == NULL || gid == DBUS_GID_UNSET);
804 
805  if (groupname)
806  group_c_str = _dbus_string_get_const_data (groupname);
807  else
808  group_c_str = NULL;
809 
810  /* For now assuming that the getgrnam() and getgrgid() flavors
811  * always correspond to the pwnam flavors, if not we have
812  * to add more configure checks.
813  */
814 
815 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
816  {
817  struct group *g;
818  int result;
819  size_t buflen;
820  char *buf;
821  struct group g_str;
822  dbus_bool_t b;
823 
824  /* retrieve maximum needed size for buf */
825  buflen = sysconf (_SC_GETGR_R_SIZE_MAX);
826 
827  /* sysconf actually returns a long, but everything else expects size_t,
828  * so just recast here.
829  * https://bugs.freedesktop.org/show_bug.cgi?id=17061
830  */
831  if ((long) buflen <= 0)
832  buflen = 1024;
833 
834  result = -1;
835  while (1)
836  {
837  buf = dbus_malloc (buflen);
838  if (buf == NULL)
839  {
841  return FALSE;
842  }
843 
844  g = NULL;
845 #ifdef HAVE_POSIX_GETPWNAM_R
846  if (group_c_str)
847  result = getgrnam_r (group_c_str, &g_str, buf, buflen,
848  &g);
849  else
850  result = getgrgid_r (gid, &g_str, buf, buflen,
851  &g);
852 #else
853  g = getgrnam_r (group_c_str, &g_str, buf, buflen);
854  result = 0;
855 #endif /* !HAVE_POSIX_GETPWNAM_R */
856  /* Try a bigger buffer if ERANGE was returned:
857  https://bugs.freedesktop.org/show_bug.cgi?id=16727
858  */
859  if (result == ERANGE && buflen < 512 * 1024)
860  {
861  dbus_free (buf);
862  buflen *= 2;
863  }
864  else
865  {
866  break;
867  }
868  }
869 
870  if (result == 0 && g == &g_str)
871  {
872  b = fill_user_info_from_group (g, info, error);
873  dbus_free (buf);
874  return b;
875  }
876  else
877  {
878  dbus_set_error (error, _dbus_error_from_errno (errno),
879  "Group %s unknown or failed to look it up\n",
880  group_c_str ? group_c_str : "???");
881  dbus_free (buf);
882  return FALSE;
883  }
884  }
885 #else /* ! HAVE_GETPWNAM_R */
886  {
887  /* I guess we're screwed on thread safety here */
888  struct group *g;
889 
890  g = getgrnam (group_c_str);
891 
892  if (g != NULL)
893  {
894  return fill_user_info_from_group (g, info, error);
895  }
896  else
897  {
898  dbus_set_error (error, _dbus_error_from_errno (errno),
899  "Group %s unknown or failed to look it up\n",
900  group_c_str ? group_c_str : "???");
901  return FALSE;
902  }
903  }
904 #endif /* ! HAVE_GETPWNAM_R */
905 }
906 
918  const DBusString *groupname,
919  DBusError *error)
920 {
921  return fill_group_info (info, DBUS_GID_UNSET,
922  groupname, error);
923 
924 }
925 
937  dbus_gid_t gid,
938  DBusError *error)
939 {
940  return fill_group_info (info, gid, NULL, error);
941 }
942 
953  dbus_uid_t *uid_p)
954 {
955  return _dbus_get_user_id (username, uid_p);
956 
957 }
958 
969  dbus_gid_t *gid_p)
970 {
971  return _dbus_get_group_id (groupname, gid_p);
972 }
973 
986  dbus_gid_t **group_ids,
987  int *n_group_ids)
988 {
989  return _dbus_groups_from_uid (uid, group_ids, n_group_ids);
990 }
991 
1003  DBusError *error)
1004 {
1005  return _dbus_is_console_user (uid, error);
1006 
1007 }
1008 
1018 {
1019  return uid == _dbus_geteuid ();
1020 }
1021 
1030 _dbus_windows_user_is_process_owner (const char *windows_sid)
1031 {
1032  return FALSE;
1033 }
1034  /* End of DBusInternalsUtils functions */
1036 
1050  DBusString *dirname)
1051 {
1052  int sep;
1053 
1054  _dbus_assert (filename != dirname);
1055  _dbus_assert (filename != NULL);
1056  _dbus_assert (dirname != NULL);
1057 
1058  /* Ignore any separators on the end */
1059  sep = _dbus_string_get_length (filename);
1060  if (sep == 0)
1061  return _dbus_string_append (dirname, "."); /* empty string passed in */
1062 
1063  while (sep > 0 && _dbus_string_get_byte (filename, sep - 1) == '/')
1064  --sep;
1065 
1066  _dbus_assert (sep >= 0);
1067 
1068  if (sep == 0)
1069  return _dbus_string_append (dirname, "/");
1070 
1071  /* Now find the previous separator */
1072  _dbus_string_find_byte_backward (filename, sep, '/', &sep);
1073  if (sep < 0)
1074  return _dbus_string_append (dirname, ".");
1075 
1076  /* skip multiple separators */
1077  while (sep > 0 && _dbus_string_get_byte (filename, sep - 1) == '/')
1078  --sep;
1079 
1080  _dbus_assert (sep >= 0);
1081 
1082  if (sep == 0 &&
1083  _dbus_string_get_byte (filename, 0) == '/')
1084  return _dbus_string_append (dirname, "/");
1085  else
1086  return _dbus_string_copy_len (filename, 0, sep - 0,
1087  dirname, _dbus_string_get_length (dirname));
1088 } /* DBusString stuff */
1090 
1091 static void
1092 string_squash_nonprintable (DBusString *str)
1093 {
1094  unsigned char *buf;
1095  int i, len;
1096 
1097  buf = _dbus_string_get_udata (str);
1098  len = _dbus_string_get_length (str);
1099 
1100  /* /proc/$pid/cmdline is a sequence of \0-terminated words, but we
1101  * want a sequence of space-separated words, with no extra trailing
1102  * space:
1103  * "/bin/sleep" "\0" "60" "\0"
1104  * -> "/bin/sleep" "\0" "60"
1105  * -> "/bin/sleep" " " "60"
1106  *
1107  * so chop off the trailing NUL before cleaning up unprintable
1108  * characters. */
1109  if (len > 0 && buf[len - 1] == '\0')
1110  {
1111  _dbus_string_shorten (str, 1);
1112  len--;
1113  }
1114 
1115  for (i = 0; i < len; i++)
1116  {
1117  unsigned char c = (unsigned char) buf[i];
1118  if (c == '\0')
1119  buf[i] = ' ';
1120  else if (c < 0x20 || c > 127)
1121  buf[i] = '?';
1122  }
1123 }
1124 
1139 dbus_bool_t
1140 _dbus_command_for_pid (unsigned long pid,
1141  DBusString *str,
1142  int max_len,
1143  DBusError *error)
1144 {
1145  /* This is all Linux-specific for now */
1146  DBusString path;
1147  DBusString cmdline;
1148  int fd;
1149 
1150  if (!_dbus_string_init (&path))
1151  {
1152  _DBUS_SET_OOM (error);
1153  return FALSE;
1154  }
1155 
1156  if (!_dbus_string_init (&cmdline))
1157  {
1158  _DBUS_SET_OOM (error);
1159  _dbus_string_free (&path);
1160  return FALSE;
1161  }
1162 
1163  if (!_dbus_string_append_printf (&path, "/proc/%ld/cmdline", pid))
1164  goto oom;
1165 
1166  fd = open (_dbus_string_get_const_data (&path), O_RDONLY);
1167  if (fd < 0)
1168  {
1169  dbus_set_error (error,
1170  _dbus_error_from_errno (errno),
1171  "Failed to open \"%s\": %s",
1172  _dbus_string_get_const_data (&path),
1173  _dbus_strerror (errno));
1174  goto fail;
1175  }
1176 
1177  if (!_dbus_read (fd, &cmdline, max_len))
1178  {
1179  dbus_set_error (error,
1180  _dbus_error_from_errno (errno),
1181  "Failed to read from \"%s\": %s",
1182  _dbus_string_get_const_data (&path),
1183  _dbus_strerror (errno));
1184  _dbus_close (fd, NULL);
1185  goto fail;
1186  }
1187 
1188  if (!_dbus_close (fd, error))
1189  goto fail;
1190 
1191  string_squash_nonprintable (&cmdline);
1192 
1193  if (!_dbus_string_copy (&cmdline, 0, str, _dbus_string_get_length (str)))
1194  goto oom;
1195 
1196  _dbus_string_free (&cmdline);
1197  _dbus_string_free (&path);
1198  return TRUE;
1199 oom:
1200  _DBUS_SET_OOM (error);
1201 fail:
1202  _dbus_string_free (&cmdline);
1203  _dbus_string_free (&path);
1204  return FALSE;
1205 }
1206 
1217 {
1218  return TRUE;
1219 }
1220 
1221 static dbus_bool_t
1222 ensure_owned_directory (const char *label,
1223  const DBusString *string,
1224  dbus_bool_t create,
1225  DBusError *error)
1226 {
1227  const char *dir = _dbus_string_get_const_data (string);
1228  struct stat buf;
1229 
1230  if (create && !_dbus_ensure_directory (string, error))
1231  return FALSE;
1232 
1233  /*
1234  * The stat()-based checks in this function are to protect against
1235  * mistakes, not malice. We are working in a directory that is meant
1236  * to be trusted; but if a user has used `su` or similar to escalate
1237  * their privileges without correctly clearing the environment, the
1238  * XDG_RUNTIME_DIR in the environment might still be the user's
1239  * and not root's. We don't want to write root-owned files into that
1240  * directory, so just warn and don't provide support for transient
1241  * services in that case.
1242  *
1243  * In particular, we use stat() and not lstat() so that if we later
1244  * decide to use a different directory name for transient services,
1245  * we can drop in a compatibility symlink without breaking older
1246  * libdbus.
1247  */
1248 
1249  if (stat (dir, &buf) != 0)
1250  {
1251  int saved_errno = errno;
1252 
1253  dbus_set_error (error, _dbus_error_from_errno (saved_errno),
1254  "%s \"%s\" not available: %s", label, dir,
1255  _dbus_strerror (saved_errno));
1256  return FALSE;
1257  }
1258 
1259  if (!S_ISDIR (buf.st_mode))
1260  {
1261  dbus_set_error (error, DBUS_ERROR_FAILED, "%s \"%s\" is not a directory",
1262  label, dir);
1263  return FALSE;
1264  }
1265 
1266  if (buf.st_uid != geteuid ())
1267  {
1269  "%s \"%s\" is owned by uid %ld, not our uid %ld",
1270  label, dir, (long) buf.st_uid, (long) geteuid ());
1271  return FALSE;
1272  }
1273 
1274  /* This is just because we have the stat() results already, so we might
1275  * as well check opportunistically. */
1276  if ((S_IWOTH | S_IWGRP) & buf.st_mode)
1277  {
1279  "%s \"%s\" can be written by others (mode 0%o)",
1280  label, dir, buf.st_mode);
1281  return FALSE;
1282  }
1283 
1284  return TRUE;
1285 }
1286 
1287 #define DBUS_UNIX_STANDARD_SESSION_SERVICEDIR "/dbus-1/services"
1288 #define DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR "/dbus-1/system-services"
1289 
1299  DBusError *error)
1300 {
1301  const char *xdg_runtime_dir;
1302  DBusString services;
1303  DBusString dbus1;
1304  DBusString xrd;
1305  dbus_bool_t ret = FALSE;
1306  char *data = NULL;
1307 
1308  if (!_dbus_string_init (&dbus1))
1309  {
1310  _DBUS_SET_OOM (error);
1311  return FALSE;
1312  }
1313 
1314  if (!_dbus_string_init (&services))
1315  {
1316  _dbus_string_free (&dbus1);
1317  _DBUS_SET_OOM (error);
1318  return FALSE;
1319  }
1320 
1321  if (!_dbus_string_init (&xrd))
1322  {
1323  _dbus_string_free (&dbus1);
1324  _dbus_string_free (&services);
1325  _DBUS_SET_OOM (error);
1326  return FALSE;
1327  }
1328 
1329  xdg_runtime_dir = _dbus_getenv ("XDG_RUNTIME_DIR");
1330 
1331  /* Not an error, we just can't have transient session services */
1332  if (xdg_runtime_dir == NULL)
1333  {
1334  _dbus_verbose ("XDG_RUNTIME_DIR is unset: transient session services "
1335  "not available here\n");
1336  ret = TRUE;
1337  goto out;
1338  }
1339 
1340  if (!_dbus_string_append (&xrd, xdg_runtime_dir) ||
1341  !_dbus_string_append_printf (&dbus1, "%s/dbus-1",
1342  xdg_runtime_dir) ||
1343  !_dbus_string_append_printf (&services, "%s/dbus-1/services",
1344  xdg_runtime_dir))
1345  {
1346  _DBUS_SET_OOM (error);
1347  goto out;
1348  }
1349 
1350  if (!ensure_owned_directory ("XDG_RUNTIME_DIR", &xrd, FALSE, error) ||
1351  !ensure_owned_directory ("XDG_RUNTIME_DIR subdirectory", &dbus1, TRUE,
1352  error) ||
1353  !ensure_owned_directory ("XDG_RUNTIME_DIR subdirectory", &services,
1354  TRUE, error))
1355  goto out;
1356 
1357  if (!_dbus_string_steal_data (&services, &data) ||
1358  !_dbus_list_append (dirs, data))
1359  {
1360  _DBUS_SET_OOM (error);
1361  goto out;
1362  }
1363 
1364  _dbus_verbose ("Transient service directory is %s\n", data);
1365  /* Ownership was transferred to @dirs */
1366  data = NULL;
1367  ret = TRUE;
1368 
1369 out:
1370  _dbus_string_free (&dbus1);
1371  _dbus_string_free (&services);
1372  _dbus_string_free (&xrd);
1373  dbus_free (data);
1374  return ret;
1375 }
1376 
1396 {
1397  const char *xdg_data_home;
1398  const char *xdg_data_dirs;
1399  DBusString servicedir_path;
1400 
1401  if (!_dbus_string_init (&servicedir_path))
1402  return FALSE;
1403 
1404  xdg_data_home = _dbus_getenv ("XDG_DATA_HOME");
1405  xdg_data_dirs = _dbus_getenv ("XDG_DATA_DIRS");
1406 
1407  if (xdg_data_home != NULL)
1408  {
1409  if (!_dbus_string_append (&servicedir_path, xdg_data_home))
1410  goto oom;
1411  }
1412  else
1413  {
1414  const DBusString *homedir;
1415  DBusString local_share;
1416 
1417  if (!_dbus_homedir_from_current_process (&homedir))
1418  goto oom;
1419 
1420  if (!_dbus_string_append (&servicedir_path, _dbus_string_get_const_data (homedir)))
1421  goto oom;
1422 
1423  _dbus_string_init_const (&local_share, "/.local/share");
1424  if (!_dbus_concat_dir_and_file (&servicedir_path, &local_share))
1425  goto oom;
1426  }
1427 
1428  if (!_dbus_string_append (&servicedir_path, ":"))
1429  goto oom;
1430 
1431  if (xdg_data_dirs != NULL)
1432  {
1433  if (!_dbus_string_append (&servicedir_path, xdg_data_dirs))
1434  goto oom;
1435 
1436  if (!_dbus_string_append (&servicedir_path, ":"))
1437  goto oom;
1438  }
1439  else
1440  {
1441  if (!_dbus_string_append (&servicedir_path, "/usr/local/share:/usr/share:"))
1442  goto oom;
1443  }
1444 
1445  /*
1446  * add configured datadir to defaults
1447  * this may be the same as an xdg dir
1448  * however the config parser should take
1449  * care of duplicates
1450  */
1451  if (!_dbus_string_append (&servicedir_path, DBUS_DATADIR))
1452  goto oom;
1453 
1454  if (!_dbus_split_paths_and_append (&servicedir_path,
1455  DBUS_UNIX_STANDARD_SESSION_SERVICEDIR,
1456  dirs))
1457  goto oom;
1458 
1459  _dbus_string_free (&servicedir_path);
1460  return TRUE;
1461 
1462  oom:
1463  _dbus_string_free (&servicedir_path);
1464  return FALSE;
1465 }
1466 
1467 
1488 {
1489  /*
1490  * DBUS_DATADIR may be the same as one of the standard directories. However,
1491  * the config parser should take care of the duplicates.
1492  *
1493  * Also, append /lib as counterpart of /usr/share on the root
1494  * directory (the root directory does not know /share), in order to
1495  * facilitate early boot system bus activation where /usr might not
1496  * be available.
1497  */
1498  static const char standard_search_path[] =
1499  "/usr/local/share:"
1500  "/usr/share:"
1501  DBUS_DATADIR ":"
1502  "/lib";
1503  DBusString servicedir_path;
1504 
1505  _dbus_string_init_const (&servicedir_path, standard_search_path);
1506 
1507  return _dbus_split_paths_and_append (&servicedir_path,
1508  DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR,
1509  dirs);
1510 }
1511 
1522 {
1523  _dbus_assert (_dbus_string_get_length (str) == 0);
1524 
1525  return _dbus_string_append (str, DBUS_SYSTEM_CONFIG_FILE);
1526 }
1527 
1536 {
1537  _dbus_assert (_dbus_string_get_length (str) == 0);
1538 
1539  return _dbus_string_append (str, DBUS_SESSION_CONFIG_FILE);
1540 }
1541 
1546 void
1548 {
1549 #ifdef HAVE_SYSTEMD
1550  sd_notify (0, "READY=1");
1551 #endif
1552 }
1553 
1558 void
1560 {
1561 #ifdef HAVE_SYSTEMD
1562  sd_notify (0, "RELOADING=1");
1563 #endif
1564 }
1565 
1570 void
1572 {
1573 #ifdef HAVE_SYSTEMD
1574  /* For systemd, this is the same code */
1576 #endif
1577 }
1578 
1583 void
1585 {
1586 #ifdef HAVE_SYSTEMD
1587  sd_notify (0, "STOPPING=1");
1588 #endif
1589 }
1590 
1594 void
1596 {
1597 #ifdef HAVE_SETRLIMIT
1598  /* No core dumps please, we know we crashed. */
1599  struct rlimit r = { 0, };
1600 
1601  getrlimit (RLIMIT_CORE, &r);
1602  r.rlim_cur = 0;
1603  setrlimit (RLIMIT_CORE, &r);
1604 #endif
1605 
1606 #if defined(HAVE_PRCTL) && defined(PR_SET_DUMPABLE)
1607  /* Really, no core dumps please. On Linux, if core_pattern is
1608  * set to a pipe (for abrt/apport/corekeeper/etc.), RLIMIT_CORE of 0
1609  * is ignored (deliberately, so people can debug init(8) and other
1610  * early stuff); but Linux has PR_SET_DUMPABLE, so we can avoid core
1611  * dumps anyway. */
1612  prctl (PR_SET_DUMPABLE, 0, 0, 0, 0);
1613 #endif
1614 }
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:952
dbus_bool_t _dbus_split_paths_and_append(DBusString *dirs, const char *suffix, DBusList **dir_list)
Split paths into a list of char strings.
Definition: dbus-sysdeps.c:236
const char * message
public error message field
Definition: dbus-errors.h:51
#define NULL
A null pointer, defined appropriately for C or C++.
dbus_bool_t _dbus_become_daemon(const DBusString *pidfile, DBusPipe *print_pid_pipe, DBusError *error, dbus_bool_t keep_umask)
Does the chdir, fork, setsid, etc.
dbus_bool_t _dbus_unix_user_is_at_console(dbus_uid_t uid, DBusError *error)
Checks to see if the UNIX user ID is at the console.
dbus_bool_t _dbus_group_info_fill_gid(DBusGroupInfo *info, dbus_gid_t gid, DBusError *error)
Initializes the given DBusGroupInfo struct with information about the given group ID...
dbus_bool_t _dbus_string_get_dirname(const DBusString *filename, DBusString *dirname)
Get the directory name from a complete filename.
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:703
dbus_bool_t _dbus_path_is_absolute(const DBusString *filename)
Checks whether the filename is an absolute path.
Portable struct with stat() results.
Definition: dbus-sysdeps.h:546
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).
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_append_int(DBusString *str, long value)
Appends an integer to a DBusString.
Definition: dbus-sysdeps.c:363
dbus_bool_t _dbus_groups_from_uid(dbus_uid_t uid, dbus_gid_t **group_ids, int *n_group_ids)
Gets all groups corresponding to the given UID.
dbus_bool_t _dbus_parse_unix_group_from_config(const DBusString *groupname, dbus_gid_t *gid_p)
Parse a UNIX group from the bus config file.
void _dbus_directory_close(DBusDirIter *iter)
Closes a directory iteration.
dbus_bool_t _dbus_is_console_user(dbus_uid_t uid, DBusError *error)
Checks to see if the UID sent in is the console user.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
dbus_bool_t _dbus_directory_get_next_file(DBusDirIter *iter, DBusString *filename, DBusError *error)
Get next file in the directory.
unsigned long atime
Access time.
Definition: dbus-sysdeps.h:553
dbus_bool_t _dbus_get_standard_session_servicedirs(DBusList **dirs)
Returns the standard directories for a session bus to look for service activation files...
dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory.
DBusDirIter * _dbus_directory_open(const DBusString *filename, DBusError *error)
Open a directory to iterate over.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
dbus_bool_t _dbus_command_for_pid(unsigned long pid, DBusString *str, int max_len, DBusError *error)
Get a printable string describing the command used to execute the process with pid.
dbus_bool_t _dbus_get_system_config_file(DBusString *str)
Get the absolute path of the system.conf file (there is no system bus on Windows so this can just ret...
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
Definition: dbus-string.c:797
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:1300
char * groupname
Group name.
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:599
Internals of directory iterator.
unsigned long mode
File mode.
Definition: dbus-sysdeps.h:548
unsigned long dbus_pid_t
A process ID.
Definition: dbus-sysdeps.h:132
dbus_bool_t _dbus_get_user_id_and_primary_group(const DBusString *username, dbus_uid_t *uid_p, dbus_gid_t *gid_p)
Gets user ID and primary group given username.
dbus_bool_t _dbus_change_to_daemon_user(const char *user, DBusError *error)
Changes the user and group the bus is running as.
DIR * d
The DIR* from opendir()
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
Definition: dbus-memory.c:463
dbus_gid_t gid
Group owning file.
Definition: dbus-sysdeps.h:551
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
Definition: dbus-memory.h:58
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
dbus_bool_t _dbus_get_session_config_file(DBusString *str)
Get the absolute path of the session.conf file.
void _dbus_daemon_report_stopping(void)
Report to a service manager that the daemon calling this function is shutting down.
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
dbus_bool_t _dbus_list_append(DBusList **list, void *data)
Appends a value to the list.
Definition: dbus-list.c:271
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:1131
dbus_bool_t _dbus_group_info_fill(DBusGroupInfo *info, const DBusString *groupname, DBusError *error)
Initializes the given DBusGroupInfo struct with information about the given group name...
dbus_bool_t _dbus_get_group_id(const DBusString *groupname, dbus_gid_t *gid)
Gets group ID given groupname.
Object representing an exception.
Definition: dbus-errors.h:48
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_unix_groups_from_uid(dbus_uid_t uid, dbus_gid_t **group_ids, int *n_group_ids)
Gets all groups corresponding to the given UNIX user ID.
unsigned long ctime
Creation time.
Definition: dbus-sysdeps.h:555
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(), and fills it with the same contents as #_DBUS_STRING_I...
Definition: dbus-string.c:264
#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_file_exists(const char *file)
Checks if a file exists.
#define TRUE
Expands to "1".
unsigned long nlink
Number of hard links.
Definition: dbus-sysdeps.h:549
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
dbus_bool_t _dbus_write_pid_to_file_and_pipe(const DBusString *pidfile, DBusPipe *print_pid_pipe, dbus_pid_t pid_to_write, DBusError *error)
Writes the given pid_to_write to a pidfile (if non-NULL) and/or to a pipe (if non-NULL).
dbus_uid_t uid
User owning file.
Definition: dbus-sysdeps.h:550
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
dbus_bool_t _dbus_verify_daemon_user(const char *user)
Verify that after the fork we can successfully change to this user.
dbus_bool_t _dbus_string_find_byte_backward(const DBusString *str, int start, unsigned char byte, int *found)
Find the given byte scanning backward from the given start.
dbus_bool_t _dbus_homedir_from_current_process(const DBusString **homedir)
Gets homedir of user owning current process.
Definition: dbus-userdb.c:402
Information about a UNIX group.
dbus_bool_t _dbus_stat(const DBusString *filename, DBusStat *statbuf, DBusError *error)
stat() wrapper.
dbus_bool_t _dbus_get_user_id(const DBusString *username, dbus_uid_t *uid)
Gets user ID given username.
void _dbus_set_signal_handler(int sig, DBusSignalHandler handler)
Installs a UNIX signal handler.
A node in a linked list.
Definition: dbus-list.h:34
dbus_bool_t _dbus_unix_user_is_process_owner(dbus_uid_t uid)
Checks to see if the UNIX user ID matches the UID of the process.
void _dbus_daemon_report_ready(void)
Report to a service manager that the daemon calling this function is ready for use.
dbus_bool_t _dbus_replace_install_prefix(DBusString *path)
Replace the DBUS_PREFIX in the given path, in-place, by the current D-Bus installation directory...
dbus_bool_t _dbus_user_at_console(const char *username, DBusError *error)
Checks if user is at the console.
void _dbus_daemon_report_reloaded(void)
Report to a service manager that the daemon calling this function is reloading configuration.
dbus_bool_t _dbus_windows_user_is_process_owner(const char *windows_sid)
Checks to see if the Windows user SID matches the owner of the process.
dbus_bool_t _dbus_set_up_transient_session_servicedirs(DBusList **dirs, DBusError *error)
Returns the standard directories for a session bus to look for transient service activation files...
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
dbus_bool_t _dbus_close(int fd, DBusError *error)
Closes a file descriptor.
#define FALSE
Expands to "0".
unsigned long mtime
Modify time.
Definition: dbus-sysdeps.h:554
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
Definition: dbus-string.c:819
void _dbus_daemon_report_reloading(void)
Report to a service manager that the daemon calling this function is reloading configuration.
dbus_bool_t _dbus_string_copy_len(const DBusString *source, int start, int len, DBusString *dest, int insert_at)
Like _dbus_string_copy(), but can copy a segment from the middle of the source string.
Definition: dbus-string.c:1392
dbus_bool_t _dbus_string_steal_data(DBusString *str, char **data_return)
Like _dbus_string_get_data(), but removes the gotten data from the original string.
Definition: dbus-string.c:658
dbus_gid_t gid
GID.
void(* DBusSignalHandler)(int sig)
A UNIX signal handler.
unsigned long dbus_gid_t
A group ID.
Definition: dbus-sysdeps.h:136
unsigned long size
Size of file.
Definition: dbus-sysdeps.h:552
dbus_bool_t _dbus_parse_unix_user_from_config(const DBusString *username, dbus_uid_t *uid_p)
Parse a UNIX user from the bus config file.
char * _dbus_strdup(const char *str)
Duplicates a string.
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
Definition: dbus-sysdeps.c:195
unsigned long dbus_uid_t
A user ID.
Definition: dbus-sysdeps.h:134
dbus_bool_t _dbus_get_standard_system_servicedirs(DBusList **dirs)
Returns the standard directories for a system bus to look for service activation files.
dbus_bool_t dbus_error_is_set(const DBusError *error)
Checks whether an error occurred (the error is set).
Definition: dbus-errors.c:329
void _dbus_disable_crash_handling(void)
Try to disable core dumps and similar special crash handling.