Re: [systemd-devel] Questions regarding dbus started via systemd --user

#include <errno.h>
#include <error.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sysexits.h>
#include <unistd.h>

#include <dbus/dbus.h>

#define THIS "debian-dbus-upload-environment"

extern char **environ;

static void oom (void) __attribute__ ((__noreturn__));

static void
oom (void)
{
  fprintf (stderr, "%s: out of memory\n", THIS);
  _exit (EX_UNAVAILABLE);
}

static dbus_bool_t
systemd_user_running (void)
{
  char *xdg_runtime_dir = getenv ("XDG_RUNTIME_DIR");
  char *path;
  struct stat buf;

  if (xdg_runtime_dir == NULL)
    return FALSE;

  /* assume that XDG_RUNTIME_DIR/systemd exists if and only if
   * "systemd --user" is running */
  if (asprintf (&path, "%s/systemd", xdg_runtime_dir) < 0)
    oom ();

  if (stat (path, &buf) < 0)
    return FALSE;

  free (path);

  return TRUE;
}

int
main (int argc, char **argv)
{
  char **next = NULL;
  char **envp;
  DBusConnection *conn;
  DBusMessage *msg;
  DBusMessage *sd_msg;
  DBusMessage *reply;
  DBusError error = DBUS_ERROR_INIT;
  DBusMessageIter msg_iter;
  DBusMessageIter sd_msg_iter;
  DBusMessageIter array_iter;
  DBusMessageIter sd_array_iter;
  int i;
  struct stat stat_buf;

  for (i = 1; i < argc; i++)
    {
      if (strcmp (argv[i], "--") == 0 && (i + 1) < argc)
        {
          next = argv + i + 1;
          break;
        }
      else
        {
          fprintf (stderr,
              "%s: usage:\n"
              "%s [-- next-executable [arguments...]]\n",
              THIS, THIS);
          return EX_USAGE;
        }
    }

  conn = dbus_bus_get (DBUS_BUS_SESSION, &error);

  if (conn == NULL)
    {
      fprintf (stderr,
          "%s: error: unable to connect to D-Bus: %s\n", THIS, error.message);
      return EX_OSERR;
    }

  msg = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
      DBUS_INTERFACE_DBUS, "UpdateActivationEnvironment");

  if (msg == NULL)
    oom ();

  sd_msg = dbus_message_new_method_call ("org.freedesktop.systemd1",
      "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager",
      "SetEnvironment");

  if (sd_msg == NULL)
    oom ();

  dbus_message_iter_init_append (msg, &msg_iter);
  dbus_message_iter_open_container (&msg_iter, DBUS_TYPE_ARRAY,
      "{ss}", &array_iter);

  dbus_message_iter_open_container (&sd_msg_iter, DBUS_TYPE_ARRAY,
      "{ss}", &sd_array_iter);

  for (envp = environ; *envp != NULL; envp++)
    {
      char *copy;
      char *eq;
      char *val;
      DBusMessageIter pair_iter;

      if (!dbus_validate_utf8 (*envp, NULL))
        {
          fprintf (stderr,
              "%s: warning: environment variable not UTF-8: %s\n",
              THIS, *envp);
          continue;
        }

      copy = strdup (*envp);

      if (copy == NULL)
        oom ();

      eq = strchr (copy, '=');

      if (eq == NULL)
        {
          fprintf (stderr,
              "%s: warning: environment variable without '=': %s\n",
              THIS, copy);
          free (copy);
          continue;
        }

      *eq = '\0';
      val = eq + 1;

      if (!dbus_message_iter_append_basic (&sd_array_iter, DBUS_TYPE_STRING,
              envp))
        oom ();

      if (!dbus_message_iter_open_container (&array_iter,
              DBUS_TYPE_DICT_ENTRY, NULL, &pair_iter))
        oom ();

      if (!dbus_message_iter_append_basic (&pair_iter, DBUS_TYPE_STRING,
              &copy))
        oom ();

      if (!dbus_message_iter_append_basic (&pair_iter, DBUS_TYPE_STRING,
              &val))
        oom ();

      if (!dbus_message_iter_close_container (&array_iter, &pair_iter))
        oom ();

      free (copy);
    }

  if (!dbus_message_iter_close_container (&msg_iter, &array_iter))
    oom ();

  if (!dbus_message_iter_close_container (&sd_msg_iter, &sd_array_iter))
    oom ();

  reply = dbus_connection_send_with_reply_and_block (conn, msg, -1, &error);

  if (reply == NULL)
    {
      fprintf (stderr,
          "%s: error sending to dbus-daemon: %s: %s\n",
          THIS, error.name, error.message);
      return EX_UNAVAILABLE;
    }

  if (!dbus_message_get_args (msg, &error, DBUS_TYPE_INVALID))
    {
      fprintf (stderr,
          "%s: error from dbus-daemon: %s: %s\n",
          THIS, error.name, error.message);
      return EX_UNAVAILABLE;
    }

  dbus_message_unref (reply);

  if (systemd_user_running ())
    {
      reply = dbus_connection_send_with_reply_and_block (conn, sd_msg, -1,
          &error);

      /* non-fatal, the main purpose of this thing is to communicate
       * with dbus-daemon */
      if (reply == NULL)
        {
          fprintf (stderr,
              "%s: error sending to systemd: %s: %s\n",
              THIS, error.name, error.message);
        }
      else if (!dbus_message_get_args (msg, &error, DBUS_TYPE_INVALID))
        {
          fprintf (stderr,
              "%s: error from systemd: %s: %s\n",
              THIS, error.name, error.message);
        }
    }

  if (next != NULL)
    {
      execvp (next[0], next);

      fprintf (stderr,
          "%s: error: cannot execute %s: %s\n",
          THIS, next[0], strerror (errno));
      return EX_UNAVAILABLE;
    }

  return 0;
}