Attachment 1477617 Details for Bug 1470310 – fix dbus-daemon --fork too

[patch] fix dbus-daemon --fork too

dbus-1.10.24-dbus-launch-chdir.patch (text/plain), 16.92 KB, created by Ray Strode [halfline] on 2018-08-21 15:29:42 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ray Strode [halfline]

Created: 2018-08-21 15:29:42 UTC

Size: 16.92 KB

patch

obsolete

>From dc2074588d3e7b5a216cb8c0b82094157c3cf773 Mon Sep 17 00:00:00 2001
>From: David King <dking@redhat.com>
>Date: Mon, 25 Jun 2018 14:46:14 -0400
>Subject: [PATCH] daemon: use HOME as the working directory
>
>Session buses started as part of a systemd --user session are launched
>with the current working directory being the home directory of the user.
>Applications which are launched via dbus activation inherit the working
>directory from the session bus dbus-daemon.
>
>When dbus-launch is used to start dbus-daemon, as is commonly the case
>with a session manager such as gnome-session, this leads to applications
>having a default working directory of "/", which is undesirable (as an
>example, the default directory in a GTK+ save dialog becomes "/").
>
>As an improvement, make dbus-launch use the value of the environment
>variable HOME, if it is set, as the current working directory.
>
>Signed-off-by: David King <dking@redhat.com>
>Bug: https://bugs.freedesktop.org/show_bug.cgi?id=106987
>Bug-RedHat: https://bugzilla.redhat.com/show_bug.cgi?id=1470310
>---
> bus/bus.c                     |  9 +++++++++
> dbus/dbus-sysdeps-util-unix.c |  8 +++++---
> dbus/dbus-sysdeps-util-win.c  |  2 ++
> dbus/dbus-sysdeps.h           |  1 +
> doc/dbus-launch.1.xml.in      |  4 ++++
> tools/dbus-launch.c           | 22 ++++++++++++++--------
> 6 files changed, 35 insertions(+), 11 deletions(-)
>
>diff --git a/bus/bus.c b/bus/bus.c
>index f788e677..da2b2c1f 100644
>--- a/bus/bus.c
>+++ b/bus/bus.c
>@@ -870,63 +870,72 @@ bus_context_new (const DBusString *config_file,
> 
>   context->matchmaker = bus_matchmaker_new ();
>   if (context->matchmaker == NULL)
>     {
>       BUS_SET_OOM (error);
>       goto failed;
>     }
> 
>   /* check user before we fork */
>   if (context->user != NULL)
>     {
>       if (!_dbus_verify_daemon_user (context->user))
>         {
>           dbus_set_error (error, DBUS_ERROR_FAILED,
>                           "Could not get UID and GID for username \"%s\"",
>                           context->user);
>           goto failed;
>         }
>     }
> 
>   /* Now become a daemon if appropriate and write out pid file in any case */
>   {
>     DBusString u;
> 
>     if (context->pidfile)
>       _dbus_string_init_const (&u, context->pidfile);
> 
>     if (((flags & BUS_CONTEXT_FLAG_FORK_NEVER) == 0 && context->fork) ||
>         (flags & BUS_CONTEXT_FLAG_FORK_ALWAYS))
>       {
>+        const char *working_dir = NULL;
>+
>         _dbus_verbose ("Forking and becoming daemon\n");
> 
>+        if (context->type != NULL && strcmp (context->type, "session") == 0)
>+          working_dir = _dbus_getenv ("HOME");
>+
>+        if (working_dir == NULL)
>+          working_dir = "/";
>+
>         if (!_dbus_become_daemon (context->pidfile ? &u : NULL,
>+                                  working_dir,
>                                   print_pid_pipe,
>                                   error,
>                                   context->keep_umask))
>           {
>             _DBUS_ASSERT_ERROR_IS_SET (error);
>             goto failed;
>           }
>       }
>     else
>       {
>         _dbus_verbose ("Fork not requested\n");
> 
>         /* Need to write PID file and to PID pipe for ourselves,
>          * not for the child process. This is a no-op if the pidfile
>          * is NULL and print_pid_pipe is NULL.
>          */
>         if (!_dbus_write_pid_to_file_and_pipe (context->pidfile ? &u : NULL,
>                                                print_pid_pipe,
>                                                _dbus_getpid (),
>                                                error))
>           {
>             _DBUS_ASSERT_ERROR_IS_SET (error);
>             goto failed;
>           }
>       }
>   }
> 
>   if (print_pid_pipe && _dbus_pipe_is_valid (print_pid_pipe) &&
>       !_dbus_pipe_is_stdout_or_stderr (print_pid_pipe))
>     _dbus_pipe_close (print_pid_pipe, NULL);
>diff --git a/dbus/dbus-sysdeps-util-unix.c b/dbus/dbus-sysdeps-util-unix.c
>index 9b724cc9..30bb1441 100644
>--- a/dbus/dbus-sysdeps-util-unix.c
>+++ b/dbus/dbus-sysdeps-util-unix.c
>@@ -49,82 +49,84 @@
> #include <sys/socket.h>
> #include <dirent.h>
> #include <sys/un.h>
> 
> #ifdef HAVE_SYSLOG_H
> #include <syslog.h>
> #endif
> 
> #ifdef HAVE_SYS_SYSLIMITS_H
> #include <sys/syslimits.h>
> #endif
> 
> #ifdef HAVE_SYSTEMD
> #include <systemd/sd-daemon.h>
> #endif
> 
> #ifndef O_BINARY
> #define O_BINARY 0
> #endif
> 
> /**
>  * @addtogroup DBusInternalsUtils
>  * @{
>  */
> 
> 
> /**
>  * Does the chdir, fork, setsid, etc. to become a daemon process.
>  *
>  * @param pidfile #NULL, or pidfile to create
>+ * @param working_dir directory to chdir to
>  * @param print_pid_pipe pipe to print daemon's pid to, or -1 for none
>  * @param error return location for errors
>  * @param keep_umask #TRUE to keep the original umask
>  * @returns #FALSE on failure
>  */
> dbus_bool_t
> _dbus_become_daemon (const DBusString *pidfile,
>+                     const char       *working_dir,
>                      DBusPipe         *print_pid_pipe,
>                      DBusError        *error,
>                      dbus_bool_t       keep_umask)
> {
>   const char *s;
>   pid_t child_pid;
>   int dev_null_fd;
> 
>   _dbus_verbose ("Becoming a daemon...\n");
> 
>-  _dbus_verbose ("chdir to /\n");
>-  if (chdir ("/") < 0)
>+  _dbus_verbose ("chdir to %s\n", working_dir);
>+  if (chdir (working_dir) < 0)
>     {
>       dbus_set_error (error, DBUS_ERROR_FAILED,
>-                      "Could not chdir() to root directory");
>+                      "Could not chdir() to working directory (%s)", working_dir);
>       return FALSE;
>     }
> 
>   _dbus_verbose ("forking...\n");
>   switch ((child_pid = fork ()))
>     {
>     case -1:
>       _dbus_verbose ("fork failed\n");
>       dbus_set_error (error, _dbus_error_from_errno (errno),
>                       "Failed to fork daemon: %s", _dbus_strerror (errno));
>       return FALSE;
>       break;
> 
>     case 0:
>       _dbus_verbose ("in child, closing std file descriptors\n");
> 
>       /* silently ignore failures here, if someone
>        * doesn't have /dev/null we may as well try
>        * to continue anyhow
>        */
>       
>       dev_null_fd = open ("/dev/null", O_RDWR);
>       if (dev_null_fd >= 0)
>         {
>           dup2 (dev_null_fd, 0);
>           dup2 (dev_null_fd, 1);
>           
>           s = _dbus_getenv ("DBUS_DEBUG_OUTPUT");
>           if (s == NULL || *s == '\0')
>             dup2 (dev_null_fd, 2);
>diff --git a/dbus/dbus-sysdeps-util-win.c b/dbus/dbus-sysdeps-util-win.c
>index 3b754dbf..bfc1cb90 100644
>--- a/dbus/dbus-sysdeps-util-win.c
>+++ b/dbus/dbus-sysdeps-util-win.c
>@@ -27,67 +27,69 @@
> #define STRSAFE_NO_DEPRECATE
> 
> #include "dbus-sysdeps.h"
> #include "dbus-internals.h"
> #include "dbus-protocol.h"
> #include "dbus-string.h"
> #include "dbus-sysdeps.h"
> #include "dbus-sysdeps-win.h"
> #include "dbus-sockets-win.h"
> #include "dbus-memory.h"
> #include "dbus-pipe.h"
> 
> #include <stdio.h>
> #include <stdlib.h>
> #if HAVE_ERRNO_H
> #include <errno.h>
> #endif
> #include <winsock2.h>   // WSA error codes
> 
> #ifndef DBUS_WINCE
> #include <io.h>
> #include <lm.h>
> #include <sys/stat.h>
> #endif
> 
> 
> /**
>  * Does the chdir, fork, setsid, etc. to become a daemon process.
>  *
>  * @param pidfile #NULL, or pidfile to create
>+ * @param working_dir directory to chdir to
>  * @param print_pid_pipe file descriptor to print daemon's pid to, or -1 for none
>  * @param error return location for errors
>  * @param keep_umask #TRUE to keep the original umask
>  * @returns #FALSE on failure
>  */
> dbus_bool_t
> _dbus_become_daemon (const DBusString *pidfile,
>+                     const char       *working_dir,
>                      DBusPipe         *print_pid_pipe,
>                      DBusError        *error,
>                      dbus_bool_t       keep_umask)
> {
>   dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
>                   "Cannot daemonize on Windows");
>   return FALSE;
> }
> 
> /**
>  * Creates a file containing the process ID.
>  *
>  * @param filename the filename to write to
>  * @param pid our process ID
>  * @param error return location for errors
>  * @returns #FALSE on failure
>  */
> static dbus_bool_t
> _dbus_write_pid_file (const DBusString *filename,
>                       unsigned long     pid,
>                       DBusError        *error)
> {
>   const char *cfilename;
>   HANDLE hnd;
>   char pidstr[20];
>   int total;
>   int bytes_to_write;
> 
>   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
> 
>diff --git a/dbus/dbus-sysdeps.h b/dbus/dbus-sysdeps.h
>index 0ee45c97..e569b545 100644
>--- a/dbus/dbus-sysdeps.h
>+++ b/dbus/dbus-sysdeps.h
>@@ -498,60 +498,61 @@ int _dbus_printf_string_upper_bound (const char *format,
>                                      va_list args);
> 
> 
> /**
>  * Portable struct with stat() results
>  */
> typedef struct
> {
>   unsigned long mode;  /**< File mode */
>   unsigned long nlink; /**< Number of hard links */
>   dbus_uid_t    uid;   /**< User owning file */
>   dbus_gid_t    gid;   /**< Group owning file */
>   unsigned long size;  /**< Size of file */
>   unsigned long atime; /**< Access time */
>   unsigned long mtime; /**< Modify time */
>   unsigned long ctime; /**< Creation time */
> } DBusStat;
> 
> dbus_bool_t _dbus_stat             (const DBusString *filename,
>                                     DBusStat         *statbuf,
>                                     DBusError        *error);
> DBUS_PRIVATE_EXPORT
> dbus_bool_t _dbus_socketpair (DBusSocket       *fd1,
>                               DBusSocket       *fd2,
>                               dbus_bool_t       blocking,
>                               DBusError        *error);
> 
> void        _dbus_print_backtrace  (void);
> 
> dbus_bool_t _dbus_become_daemon   (const DBusString *pidfile,
>+                                   const char       *working_dir,
>                                    DBusPipe         *print_pid_pipe,
>                                    DBusError        *error,
>                                    dbus_bool_t       keep_umask);
> 
> dbus_bool_t _dbus_verify_daemon_user    (const char *user);
> dbus_bool_t _dbus_change_to_daemon_user (const char *user,
>                                          DBusError  *error);
> 
> 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);
> 
> dbus_bool_t _dbus_command_for_pid (unsigned long  pid,
>                                    DBusString    *str,
>                                    int            max_len,
>                                    DBusError     *error);
> 
> /** A UNIX signal handler */
> typedef void (* DBusSignalHandler) (int sig);
> 
> void _dbus_set_signal_handler (int               sig,
>                                DBusSignalHandler handler);
> 
> dbus_bool_t _dbus_user_at_console (const char *username,
>                                    DBusError  *error);
> 
> void _dbus_init_system_log (dbus_bool_t is_daemon);
> 
> typedef enum {
>diff --git a/doc/dbus-launch.1.xml.in b/doc/dbus-launch.1.xml.in
>index 5135d9ca..606c65be 100644
>--- a/doc/dbus-launch.1.xml.in
>+++ b/doc/dbus-launch.1.xml.in
>@@ -23,60 +23,64 @@
>   <command>dbus-launch</command>
>     <arg choice='opt'>--version </arg>
>     <arg choice='opt'>--help </arg>
>     <arg choice='opt'>--sh-syntax </arg>
>     <arg choice='opt'>--csh-syntax </arg>
>     <arg choice='opt'>--auto-syntax </arg>
>     <arg choice='opt'>--binary-syntax </arg>
>     <arg choice='opt'>--close-stderr </arg>
>     <arg choice='opt'>--exit-with-session </arg>
>     <arg choice='opt'>--autolaunch=<replaceable>MACHINEID</replaceable></arg>
>     <arg choice='opt'>--config-file=<replaceable>FILENAME</replaceable></arg>
>     <arg choice='opt'><replaceable>PROGRAM</replaceable></arg>
>     <arg choice='opt' rep='repeat'><replaceable>ARGS</replaceable></arg>
>     <sbr/>
> </cmdsynopsis>
> </refsynopsisdiv>
> 
> 
> <refsect1 id='description'><title>DESCRIPTION</title>
> <para>The <command>dbus-launch</command> command is used to start a session bus
> instance of <emphasis remap='I'>dbus-daemon</emphasis> from a shell script.
> It would normally be called from a user's login
> scripts. Unlike the daemon itself, <command>dbus-launch</command> exits, so
> backticks or the $() construct can be used to read information from
> <command>dbus-launch</command>.</para>
> 
> <para>With no arguments, <command>dbus-launch</command> will launch a session bus
> instance and print the address and PID of that instance to standard
> output.</para>
> 
>+<para>If the environment variable HOME is set, it is used as the current
>+working directory. Otherwise, the root directory (<filename>/</filename>) is
>+used.</para>
>+
> <para>You may specify a program to be run; in this case, <command>dbus-launch</command>
> will launch a session bus instance, set the appropriate environment
> variables so the specified program can find the bus, and then execute the
> specified program, with the specified arguments.  See below for
> examples.</para>
> 
> <para>If you launch a program, <command>dbus-launch</command> will not print the
> information about the new bus to standard output.</para>
> 
> <para>When <command>dbus-launch</command> prints bus information to standard output, by
> default it is in a simple key-value pairs format. However, you may
> request several alternate syntaxes using the --sh-syntax, --csh-syntax,
> --binary-syntax, or
> --auto-syntax options. Several of these cause <command>dbus-launch</command> to emit shell code
> to set up the environment.</para>
> 
> <para>With the --auto-syntax option, <command>dbus-launch</command> looks at the value
> of the SHELL environment variable to determine which shell syntax
> should be used.  If SHELL ends in "csh", then csh-compatible code is
> emitted; otherwise Bourne shell code is emitted.  Instead of passing
> --auto-syntax, you may explicitly specify a particular one by using
> --sh-syntax for Bourne syntax, or --csh-syntax for csh syntax.
> In scripts, it's more robust to avoid --auto-syntax and you hopefully
> know which shell your script is written in.</para>
> 
> 
> <para>See <ulink url='http://www.freedesktop.org/software/dbus/'>http://www.freedesktop.org/software/dbus/</ulink> for more information
> about D-Bus. See also the man page for <emphasis remap='I'>dbus-daemon</emphasis>.</para>
> 
> </refsect1>
>diff --git a/tools/dbus-launch.c b/tools/dbus-launch.c
>index 80e4a241..a956684c 100644
>--- a/tools/dbus-launch.c
>+++ b/tools/dbus-launch.c
>@@ -592,71 +592,77 @@ kill_bus_when_session_ends (void)
>                   /* This shouldn't happen I don't think; to avoid
>                    * spinning on the fd forever we exit.
>                    */
>                   fprintf (stderr, "dbus-launch: error reading from stdin: %s\n",
>                            strerror (errno));
>                   kill_bus_and_exit (0);
>                 }
>             }
>           else if (FD_ISSET (tty_fd, &err_set))
>             {
>               verbose ("TTY has error condition\n");
>               
>               kill_bus_and_exit (0);
>             }
>         }
>     }
> }
> 
> static void
> babysit (int   exit_with_session,
>          pid_t child_pid,
>          int   read_bus_pid_fd)  /* read pid from here */
> {
>   int ret;
>   int dev_null_fd;
>   const char *s;
> 
>   verbose ("babysitting, exit_with_session = %d, child_pid = %ld, read_bus_pid_fd = %d\n",
>            exit_with_session, (long) child_pid, read_bus_pid_fd);
>   
>-  /* We chdir ("/") since we are persistent and daemon-like, and fork
>-   * again so dbus-launch can reap the parent.  However, we don't
>-   * setsid() or close fd 0 because the idea is to remain attached
>-   * to the tty and the X server in order to kill the message bus
>-   * when the session ends.
>+  /* We chdir () since we are persistent and daemon-like, either to $HOME
>+   * to match the behaviour of a session bus started by systemd --user, or
>+   * otherwise "/". We fork again so dbus-launch can reap the parent.
>+   * However, we don't setsid() or close fd 0 because the idea is to
>+   * remain attached to the tty and the X server in order to kill the
>+   * message bus when the session ends.
>    */
> 
>-  if (chdir ("/") < 0)
>+  s = getenv ("HOME");
>+
>+  if (s == NULL || *s == '\0')
>+    s = "/";
>+
>+  if (chdir (s) < 0)
>     {
>-      fprintf (stderr, "Could not change to root directory: %s\n",
>-               strerror (errno));
>+      fprintf (stderr, "Could not change to working directory \"%s\": %s\n",
>+               s, strerror (errno));
>       exit (1);
>     }
> 
>   /* Close stdout/stderr so we don't block an "eval" or otherwise
>    * lock up. stdout is still chaining through to dbus-launch
>    * and in turn to the parent shell.
>    */
>   dev_null_fd = open ("/dev/null", O_RDWR);
>   if (dev_null_fd >= 0)
>     {
>       if (!exit_with_session)
>         dup2 (dev_null_fd, 0);
>       dup2 (dev_null_fd, 1);
>       s = getenv ("DBUS_DEBUG_OUTPUT");
>       if (s == NULL || *s == '\0')
>         dup2 (dev_null_fd, 2);
>       close (dev_null_fd);
>     }
>   else
>     {
>       fprintf (stderr, "Failed to open /dev/null: %s\n",
>                strerror (errno));
>       /* continue, why not */
>     }
>   
>   ret = fork ();
> 
>   if (ret < 0)
>     {
>       fprintf (stderr, "fork() failed in babysitter: %s\n",
>-- 
>2.17.1
>

Actions: View | Diff

Attachments on bug 1470310: 1453778 | 1477617