/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* dbus-run-session.c - run a child process in its own session
 *
 * Copyright © 2003-2006 Red Hat, Inc.
 * Copyright © 2006 Thiago Macieira <thiago@kde.org>
 * Copyright © 2011-2012 Nokia Corporation
 *
 * Licensed under the Academic Free License version 2.1
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <config.h>

#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>

#define VERSION "0"

#define MAX_ADDR_LEN 512
#define PIPE_READ_END  0
#define PIPE_WRITE_END 1

/* PROCESSES
 *
 * If you are in a shell and run "dbus-run-session myapp", here is what
 * happens (compare and contrast with dbus-launch):
 *
 * shell
 *   \- dbus-run-session myapp
 *      \- dbus-daemon --nofork --print-address --session
 *      \- myapp
 *
 * All processes are long-running.
 *
 * When myapp exits, dbus-run-session kills dbus-daemon and terminates.
 *
 * If dbus-daemon exits, dbus-run-session warns and continues to run.
 *
 * PIPES
 *
 * dbus-daemon --print-address -> bus_address_pipe -> d-r-s
 */

static const char me[] = "dbus-run-session";

static void
usage (int ecode)
{
  fprintf (stderr,
      "%s [OPTIONS] [--] PROGRAM [ARGUMENTS]\n"
      "%s --version\n"
      "%s --help\n"
      "\n"
      "Options:\n"
      "--dbus-daemon=BINARY       run BINARY instead of dbus-daemon\n"
      "--config-file=FILENAME     pass to dbus-daemon instead of --session\n"
      "\n",
      me, me, me);
  exit (ecode);
}

static void
version (void)
{
  printf ("%s %s\n"
          "Copyright (C) 2003-2006 Red Hat, Inc.\n"
          "Copyright (C) 2006 Thiago Macieira\n"
          "Copyright © 2011-2012 Nokia Corporation\n"
          "\n"
          "This is free software; see the source for copying conditions.\n"
          "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
          me, VERSION);
  exit (0);
}

static void
oom (void)
{
  fprintf (stderr, "%s: out of memory\n", me);
  exit (1);
}

typedef enum
{
  READ_STATUS_OK,    /**< Read succeeded */
  READ_STATUS_ERROR, /**< Some kind of error */
  READ_STATUS_EOF    /**< EOF returned */
} ReadStatus;

static ReadStatus
read_line (int        fd,
           char      *buf,
           size_t     maxlen)
{
  size_t bytes = 0;
  ReadStatus retval;

  memset (buf, '\0', maxlen);
  maxlen -= 1; /* ensure nul term */

  retval = READ_STATUS_OK;

  while (1)
    {
      ssize_t chunk;
      size_t to_read;

    again:
      to_read = maxlen - bytes;

      if (to_read == 0)
        break;

      chunk = read (fd,
                    buf + bytes,
                    to_read);
      if (chunk < 0 && errno == EINTR)
        goto again;

      if (chunk < 0)
        {
          retval = READ_STATUS_ERROR;
          break;
        }
      else if (chunk == 0)
        {
          retval = READ_STATUS_EOF;
          break; /* EOF */
        }
      else /* chunk > 0 */
        bytes += chunk;
    }

  if (retval == READ_STATUS_EOF &&
      bytes > 0)
    retval = READ_STATUS_OK;

  /* whack newline */
  if (retval != READ_STATUS_ERROR &&
      bytes > 0 &&
      buf[bytes-1] == '\n')
    buf[bytes-1] = '\0';

  return retval;
}

static void
exec_dbus_daemon (const char *dbus_daemon,
                  int         bus_address_pipe[2],
                  const char *config_file)
{
  /* Child process, which execs dbus-daemon or dies trying */
#define MAX_FD_LEN 64
  char write_address_fd_as_string[MAX_FD_LEN];

  close (bus_address_pipe[PIPE_READ_END]);

  sprintf (write_address_fd_as_string, "%d", bus_address_pipe[PIPE_WRITE_END]);

  execlp (dbus_daemon,
          dbus_daemon,
          "--nofork",
          "--print-address", write_address_fd_as_string,
          config_file ? "--config-file" : "--session",
          config_file, /* has to be last in this varargs list */
          NULL);

  fprintf (stderr, "%s: failed to execute message bus daemon '%s': %s\n",
           me, dbus_daemon, strerror (errno));
}

static void
exec_app (int prog_arg, char **argv)
{
  execvp (argv[prog_arg], argv + prog_arg);

  fprintf (stderr, "%s: failed to exec '%s': %s\n", me, argv[prog_arg],
           strerror (errno));
  exit (1);
}

int
main (int argc, char **argv)
{
  int prog_arg = 0;
  int bus_address_pipe[2] = { 0, 0 };
  const char *config_file = NULL;
  const char *dbus_daemon = NULL;
  char bus_address[MAX_ADDR_LEN] = { 0 };
  const char *prev_arg = NULL;
  int i = 1;
  int requires_arg = 0;
  pid_t bus_pid;
  pid_t app_pid;

  while (i < argc)
    {
      const char *arg = argv[i];

      if (requires_arg)
        {
          const char **arg_dest;

          assert (prev_arg != NULL);

          if (strcmp (prev_arg, "--config-file") == 0)
            {
              arg_dest = &config_file;
            }
          else if (strcmp (prev_arg, "--dbus-daemon") == 0)
            {
              arg_dest = &dbus_daemon;
            }
          else
            {
              /* shouldn't happen */
              fprintf (stderr, "%s: internal error: %s not fully implemented\n",
                       me, prev_arg);
              return 127;
            }

          if (*arg_dest != NULL)
            {
              fprintf (stderr, "%s: %s given twice\n", me, prev_arg);
              return 127;
            }

          *arg_dest = arg;
          requires_arg = 0;
          prev_arg = arg;
          ++i;
          continue;
        }

      if (strcmp (arg, "--help") == 0 ||
          strcmp (arg, "-h") == 0 ||
          strcmp (arg, "-?") == 0)
        {
          usage (0);
        }
      else if (strcmp (arg, "--version") == 0)
        {
          version ();
        }
      else if (strstr (arg, "--config-file=") == arg)
        {
          const char *file;

          if (config_file != NULL)
            {
              fprintf (stderr, "%s: --config-file given twice\n", me);
              return 127;
            }

          file = strchr (arg, '=');
          ++file;

          config_file = file;
        }
      else if (strstr (arg, "--dbus-daemon=") == arg)
        {
          const char *file;

          if (dbus_daemon != NULL)
            {
              fprintf (stderr, "%s: --dbus-daemon given twice\n", me);
              return 127;
            }

          file = strchr (arg, '=');
          ++file;

          dbus_daemon = file;
        }
      else if (strcmp (arg, "--config-file") == 0 ||
               strcmp (arg, "--dbus-daemon") == 0)
        {
          requires_arg = 1;
        }
      else if (arg[0] == '-')
        {
          if (strcmp (arg, "--") != 0)
            {
              fprintf (stderr, "%s: option '%s' is unknown\n", me, arg);
              return 127;
            }
          else
            {
              prog_arg = i + 1;
              break;
            }
        }
      else
        {
          prog_arg = i;
          break;
        }

      prev_arg = arg;
      ++i;
    }

  /* "dbus-run-session" and "dbus-run-session ... --" are not allowed:
   * there must be something to run */
  if (prog_arg < 1 || prog_arg >= argc)
    {
      fprintf (stderr, "%s: a non-option argument is required\n", me);
      return 127;
    }

  if (requires_arg)
    {
      fprintf (stderr, "%s: option '%s' requires an argument\n", me, prev_arg);
      return 127;
    }

  if (dbus_daemon == NULL)
    dbus_daemon = "dbus-daemon";

  if (pipe (bus_address_pipe) < 0)
    {
      fprintf (stderr, "%s: failed to create pipe: %s\n", me, strerror (errno));
      return 127;
    }

  bus_pid = fork ();

  if (bus_pid < 0)
    {
      fprintf (stderr, "%s: failed to fork: %s\n", me, strerror (errno));
      return 127;
    }

  if (bus_pid == 0)
    {
      /* child */
      exec_dbus_daemon (dbus_daemon, bus_address_pipe, config_file);
      /* not reached */
      return 127;
    }

  close (bus_address_pipe[PIPE_WRITE_END]);

  switch (read_line (bus_address_pipe[PIPE_READ_END], bus_address, MAX_ADDR_LEN))
    {
    case READ_STATUS_OK:
      break;

    case READ_STATUS_EOF:
      fprintf (stderr, "%s: EOF reading address from bus daemon\n", me);
      return 127;
      break;

    case READ_STATUS_ERROR:
      fprintf (stderr, "%s: error reading address from bus daemon: %s\n",
               me, strerror (errno));
      return 127;
      break;
    }

  close (bus_address_pipe[PIPE_READ_END]);

  if (setenv ("DBUS_SESSION_BUS_ADDRESS", bus_address, 1) < 0 ||
      unsetenv ("DBUS_SESSION_BUS_PID") < 0 ||
      unsetenv ("DBUS_SESSION_BUS_WINDOWID") < 0 ||
      unsetenv ("DBUS_STARTER_ADDRESS") < 0 ||
      unsetenv ("DBUS_STARTER_BUS_TYPE") < 0)
    oom ();

  app_pid = fork ();

  if (app_pid < 0)
    {
      fprintf (stderr, "%s: failed to fork: %s\n", me, strerror (errno));
      return 127;
    }

  if (app_pid == 0)
    {
      /* child */
      exec_app (prog_arg, argv);
      /* not reached */
      return 127;
    }

  while (1)
    {
      int child_status;
      pid_t child_pid = waitpid (-1, &child_status, 0);

      if (child_pid == (pid_t) -1)
        {
          int errsv = errno;

          if (errsv == EINTR)
            continue;

          /* shouldn't happen: the only other documented errors are ECHILD,
           * which shouldn't happen because we terminate when all our children
           * have died, and EINVAL, which would indicate programming error */
          fprintf (stderr, "%s: waitpid() failed: %s\n", me, strerror (errsv));
          return 127;
        }
      else if (child_pid == bus_pid)
        {
          /* no need to kill it, now */
          bus_pid = 0;

          if (WIFEXITED (child_status))
            fprintf (stderr, "%s: dbus-daemon exited with code %d\n",
                me, WEXITSTATUS (child_status));
          else if (WIFSIGNALED (child_status))
            fprintf (stderr, "%s: dbus-daemon terminated by signal %d\n",
                me, WTERMSIG (child_status));
          else
            fprintf (stderr, "%s: dbus-daemon died or something\n", me);
        }
      else if (child_pid == app_pid)
        {
          if (bus_pid != 0)
            kill (bus_pid, SIGTERM);

          if (WIFEXITED (child_status))
            return WEXITSTATUS (child_status);

          /* if it died from a signal, behave like sh(1) */
          if (WIFSIGNALED (child_status))
            return 128 + WTERMSIG (child_status);

          /* I give up (this should never be reached) */
          fprintf (stderr, "%s: child process died or something\n", me);
          return 127;
        }
      else
        {
          fprintf (stderr, "%s: ignoring unknown child process %ld\n", me,
              (long) child_pid);
        }
    }

  return 0;
}