path: root/driver/xscreensaver-systemd.c

/* xscreensaver-systemd, Copyright (c) 2019-2021
 * Martin Lucina <martin@lucina.net> and Jamie Zawinski <jwz@jwz.org>
 *
 * ISC License
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose with or without fee is hereby granted, provided
 * that the above copyright notice and this permission notice appear
 * in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 *
 * This utility provides systemd integration for XScreenSaver.
 * It does two things:
 *
 *   - When the system is about to go to sleep (e.g., laptop lid closing)
 *     it locks the screen *before* the system goes to sleep, by running
 *     "xscreensaver-command -suspend".  And then when the system wakes
 *     up again, it runs "xscreensaver-command -deactivate" to force the
 *     unlock dialog to appear immediately.
 *
 *   - When another process on the system makes asks for the screen saver
 *     to be inhibited (e.g. because a video is playing) this program
 *     periodically runs "xscreensaver-command -deactivate" to keep the
 *     display un-blanked.  It does this until the other program asks for
 *     it to stop.
 *
 * For this to work at all, you must prevent Gnome and KDE from usurping
 * the "org.freedesktop.ScreenSaver" messages, or else this program can't
 * receive them.  The "xscreensaver" man page contains the (complicated)
 * installation instructions.
 *
 * Background:
 *
 *     For decades, the traditional way for a video player to temporarily
 *     inhibit the screen saver was to have a heartbeat command that ran
 *     "xscreensaver-command -deactivate" once a minute while the video was
 *     playing, and ceased when the video was paused or stopped.  The reason
 *     to do it as a heartbeat rather than a toggle is so that the player
 *     fails SAFE -- if the player exits abnormally, the heart stops beating,
 *     and screen saving and locking resumes.
 *
 *     These days, the popular apps do this by using systemd.  The design of
 *     the systemd method easily and trivially allows an app to inhibit the
 *     screen saver, crash, and then never un-inhibit it, so now your screen
 *     will never blank again.
 *
 *     Furthermore, since the systemd method uses cookies to ensure that only
 *     the app that sent "inhibit" can send the matching "uninhibit", simply
 *     re-launching the crashed video player does not fix the problem.
 *
 *         "Did IQs just drop sharply while I was away?" -- Ellen Ripley
 *
 *     We can sometimes detect that the inhibiting app has exited abnormally
 *     by using "tracking peers" but I'm not sure how reliable that is.
 *
 *     Furthermore, we can't listen for these "inhibit blanking" requests
 *     if some other program is already listening for them -- which Gnome and
 *     KDE do by default, even if their screen savers are otherwise disabled.
 *     That makes it far more complicated for the user to install XScreenSaver
 *     in such a way that "xscreensaver-systemd" can even launch at all.
 *
 *     To recap: because the existing video players decided to delete the
 *     single line of code that they already had -- the heartbeat call to
 *     "xscreensaver-command -deactivate" -- we had to respond by adding a
 *     THOUSAND LINES of complicated code that talks to a server that may
 *     not be running, and that may not allow us to connect, and that may
 *     not work properly anyway, and that makes installation hellaciously
 *     difficult and confusing for the end user.
 *
 *     This is what is laughingly referred to as "progress".
 *
 *     So here's what we're dealing with now, with the various apps that
 *     you might use to play video on Linux at the end of 2020:
 *
 *
 *****************************************************************************
 *
 * Firefox (version 78.5)
 *
 *     When playing media, Firefox will send "inhibit" to one of these
 *     targets: "org.freedesktop.ScreenSaver" or "org.gnome.SessionManager".
 *
 *     However, Firefox decides which, if any, of those to use at launch time,
 *     and does not revisit that decision.  So if xscreensaver-systemd has not
 *     been launched before Firefox, it won't work.  Fortunately, in most use
 *     cases, xscreensaver will have been launched earlier in the startup
 *     sequence than the web browser.
 *
 *     If you close the tab or exit while playing, Firefox sends "uninhibit".
 *
 * Critical Firefox Bug:
 *
 *     If Firefox crashes or is killed while playing, it never sends
 *     "uninhibit", leaving the screen saver permanently inhibited.  Once
 *     that happens, the only way to un-fuck things is to kill and restart
 *     the "xscreensaver-systemd" program.
 *
 * Annoying Firefox Bug:
 *
 *     Firefox sends an "inhibit" message when it is merely playing audio.
 *     That's horrible.  Playing audio should prevent your machine from going
 *     to sleep, but it should NOT prevent your screen from blanking or
 *     locking.
 *
 *     However at least it sends it with the reason "audio-playing" instead
 *     of "video-playing", meaning we can (and do) special-case Firefox and
 *     ignore that one.
 *
 *
 *****************************************************************************
 *
 * Chrome (version 87)
 *
 *     Sends "inhibit" to "org.freedesktop.ScreenSaver" (though it uses a
 *     a different object path than Firefox does).  Unlike Firefox, Chrome
 *     does not send an "inhibit" message when only audio is playing.
 *
 * Critical Chrome Bug:
 *
 *     If Chrome crashes or is killed while playing, it never sends
 *     "uninhibit", leaving the screen saver permanently inhibited.
 *
 *
 *****************************************************************************
 *
 * Chromium (version 78, Raspbian 10.4)
 *
 *     Does not use "org.freedesktop.ScreenSaver" or "xdg-screensaver".
 *     It appears to make no attempt to inhibit the screen saver while
 *     video is playing.
 *
 *
 *****************************************************************************
 *
 * Chromium (version 84.0.4147.141, Raspbian 10.6)
 *
 *     Sends "inhibit" to "org.freedesktop.ScreenSaver" (though it uses a
 *     a different object path than Firefox does).  Unlike Firefox, Chrome
 *     does not send an "inhibit" message when only audio is playing.
 *
 *     If you close the tab or exit while playing, Chromium sends "uninhibit".
 *
 * Critical Chromium Bug:
 *
 *     If Chromium crashes or is killed while playing, it never sends
 *     "uninhibit", leaving the screen saver permanently inhibited.
 *
 * Annoying Chromium Bug:
 *
 *     Like Firefox, Chromium sends an "inhibit" message when it is merely
 *     playing audio.  Unlike Firefox, it sends exactly the same "reason"
 *     string as it does when playing video, so we can't tell them apart.
 *
 *
 *****************************************************************************
 *
 * MPV (version 0.29.1)
 *
 *     While playing, it runs "xdg-screensaver reset" every 10 seconds as a
 *     heartbeat.  That program is a super-complicated shell script that will
 *     eventually run "xscreensaver-command -reset".  So MPV talks to the
 *     xscreensaver daemon directly rather than going through systemd.
 *     That's fine.
 *
 *     On Debian 10.4 and 10.6, MPV does not have a dependency on the
 *     "xdg-utils" package, so "xdg-screensaver" might not be installed.
 *     Oddly, Chromium *does* have a dependency on "xdg-utils", even though
 *     Chromium doesn't run "xdg-screensaver".
 *
 *     The source code suggests that MPlayer and MPV call XResetScreenSaver()
 *     as well, but only affects the X11 server's built-in screen saver, not
 *     a userspace screen locker like xscreensaver.
 *
 *     They also call XScreenSaverSuspend() which is part of the MIT
 *     SCREEN-SAVER server extension.  XScreenSaver does make use of that
 *     extension because it is worse than useless.  See the commentary at
 *     the top of xscreensaver.c for details.
 *
 * Annoying MPV Bug:
 *
 *     Like Firefox and Chromium, MPV inhibits screen blanking when only
 *     audio is playing.
 *
 *
 *****************************************************************************
 *
 * MPlayer (version mplayer-gui 2:1.3.0)
 *
 *     I can't get this thing to play video at all.  It only plays the audio
 *     of MP4 files, so I can't guess what it might or might not do with video.
 *     It appears to make no attempt to inhibit the screen saver.
 *
 *
 *****************************************************************************
 *
 * VLC (version 3.0.11-0+deb10u1+rpt3)
 *
 *     VLC sends "inhibit" to "org.freedesktop.ScreenSaver" when playing
 *     video.  It does not send "inhibit" when playing audio only, and it
 *     sends "uninhibit" under all the right circumstances.
 *
 *     NOTE: that's what I saw when I tested it on Raspbian 10.6. However,
 *     the version that came with Raspbian 10.4 -- which also called itself
 *     "VLC 3.0.11" -- did not send "uninhibit" when using the window
 *     manager's "close" button!  Or when killed with "kill".
 *
 *     NOTE ALSO: The VLC source code suggests that under some circumstances
 *     it might be talking to these instead: "org.freedesktop.ScreenSaver",
 *     "org.freedesktop.PowerManagement.Inhibit", "org.mate.SessionManager",
 *     and/or "org.gnome.SessionManager".  It also contains code to run
 *     "xdg-screensaver reset" as a heartbeat.  I can't tell how it decides
 *     which system to use.  I have never seen it run "xdg-screensaver".
 *
 *
 *****************************************************************************
 *
 * Zoom
 *
 *    I'm told that the proprietary Zoom executable for Linux sends "inhibit"
 *    to "org.freedesktop.ScreenSaver", but I don't have any further details.
 *
 *****************************************************************************
 *
 * TO DO:
 *
 *   - What precisely does the standalone Zoom executable do on Linux?
 *     There doesn't seem to be a Raspbian build, so I can't test it.
 *
 *   - xscreensaver_method_uninhibit() does not actually send a reply, are
 *     we doing the right thing when registering it?
 *
 *   - Currently this code is only listening to "org.freedesktop.ScreenSaver".
 *     Perhaps it should listen to "org.mate.SessionManager" and
 *     "org.gnome.SessionManager"?  Where are those documented?
 *
 *   - Do we need to call sd_bus_release_name() explicitly on exit?
 *
 *   - Run under valgrind to check for any memory leaks.
 *
 *   - Apparently the two different desktops have managed to come up with
 *     *three* different ways for dbus clients to ask the question, "is the
 *     screen currently blanked?"  We should probably also respond to these:
 *
 *     qdbus org.freedesktop.ScreenSaver /ScreenSaver org.freedesktop.ScreenSaver.GetActive
 *     qdbus org.kde.screensaver         /ScreenSaver org.freedesktop.ScreenSaver.GetActive
 *     qdbus org.gnome.ScreenSaver       /ScreenSaver org.gnome.ScreenSaver.GetActive
 *
 *
 *
 * TESTING:
 *
 *   To call the D-BUS methods manually, you can use "busctl":
 *
 *   busctl --user call org.freedesktop.ScreenSaver \
 *     /ScreenSaver org.freedesktop.ScreenSaver \
 *     Inhibit ss test-application test-reason
 *
 *   This will hand out a cookie, which you can pass back to UnInhibit:
 *
 *   u 1792821391
 *
 *   busctl --user call org.freedesktop.ScreenSaver \
 *     /ScreenSaver org.freedesktop.ScreenSaver \
 *     UnInhibit u 1792821391
 *
 * https://github.com/mato/xscreensaver-systemd
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#define _GNU_SOURCE
#include <stdio.h>
#include <poll.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <signal.h>
#include <X11/Xlib.h>

#include <systemd/sd-bus.h>

#include "version.h"
#include "blurb.h"
#include "yarandom.h"
#include "queue.h"

static char *screensaver_version;

#define DBUS_CLIENT_NAME     "org.jwz.XScreenSaver"
#define DBUS_SD_SERVICE_NAME "org.freedesktop.login1"
#define DBUS_SD_OBJECT_PATH  "/org/freedesktop/login1"
#define DBUS_SD_INTERFACE    "org.freedesktop.login1.Manager"
#define DBUS_SD_METHOD       "Inhibit"
#define DBUS_SD_METHOD_ARGS  "ssss"
#define DBUS_SD_METHOD_WHAT  "sleep"
#define DBUS_SD_METHOD_WHO   "xscreensaver"
#define DBUS_SD_METHOD_WHY   "lock screen on suspend"
#define DBUS_SD_METHOD_MODE  "delay"

#define DBUS_SD_MATCH "type='signal'," \
                      "interface='" DBUS_SD_INTERFACE "'," \
                      "member='PrepareForSleep'"

#define DBUS_FDO_NAME          "org.freedesktop.ScreenSaver"
#define DBUS_FDO_OBJECT_PATH   "/ScreenSaver"			/* Firefox */
#define DBUS_FDO_OBJECT_PATH_2 "/org/freedesktop/ScreenSaver"	/* Chrome  */
#define DBUS_FDO_INTERFACE     "org.freedesktop.ScreenSaver"

#define HEARTBEAT_INTERVAL 50  /* seconds */

#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))


struct handler_ctx {
  sd_bus *system_bus;
  sd_bus_message *lock_message;
  int lock_fd;
  int is_inhibited;
  sd_bus_track *track;
};

static struct handler_ctx global_ctx = { NULL, NULL, -1, 0, NULL };

SLIST_HEAD(inhibit_head, inhibit_entry) inhibit_head =
  SLIST_HEAD_INITIALIZER(inhibit_head);

struct inhibit_entry {
  uint32_t cookie;
  time_t start_time;
  char *appname;
  char *peer;
  SLIST_ENTRY(inhibit_entry) entries;
};


static void
xscreensaver_command (const char *cmd)
{
  char buf[1024];
  int rc;
  sprintf (buf, "xscreensaver-command %.100s -%.100s",
           (verbose_p ? "-verbose" : "-quiet"),
           cmd);
  if (verbose_p)
    fprintf (stderr, "%s: exec: %s\n", blurb(), buf);
  rc = system (buf);
  if (rc == -1)
    fprintf (stderr, "%s: exec failed: %s\n", blurb(), buf);
  else if (WEXITSTATUS(rc) != 0)
    fprintf (stderr, "%s: exec: \"%s\" exited with status %d\n", 
             blurb(), buf, WEXITSTATUS(rc));
}


static int
xscreensaver_register_sleep_lock (struct handler_ctx *ctx)
{
  sd_bus_error error = SD_BUS_ERROR_NULL;
  sd_bus_message *reply = NULL;
  int fd = -1;
  int rc = sd_bus_call_method (ctx->system_bus,
                               DBUS_SD_SERVICE_NAME, DBUS_SD_OBJECT_PATH,
                               DBUS_SD_INTERFACE, DBUS_SD_METHOD,
                               &error, &reply,
                               DBUS_SD_METHOD_ARGS,
                               DBUS_SD_METHOD_WHAT, DBUS_SD_METHOD_WHO,
                               DBUS_SD_METHOD_WHY, DBUS_SD_METHOD_MODE);
  if (rc < 0) {
    fprintf (stderr, "%s: inhibit sleep failed: %s\n", 
             blurb(), error.message);
    goto DONE;
  }

  /* Save the lock fd and explicitly take a ref to the lock message. */
  rc = sd_bus_message_read (reply, "h", &fd);
  if (rc < 0 || fd < 0) {
    fprintf (stderr, "%s: inhibit sleep failed: no lock fd: %s\n",
             blurb(), strerror(-rc));
    goto DONE;
  }
  sd_bus_message_ref(reply);
  ctx->lock_message = reply;
  ctx->lock_fd = fd;

 DONE:
  sd_bus_error_free (&error);

  return rc;
}


/* Called when DBUS_SD_INTERFACE sends a "PrepareForSleep" signal.
   The event is sent twice: before sleep, and after.
 */
static int
xscreensaver_systemd_handler (sd_bus_message *m, void *arg,
                              sd_bus_error *ret_error)
{
  struct handler_ctx *ctx = arg;
  int before_sleep;
  int rc;

  rc = sd_bus_message_read (m, "b", &before_sleep);
  if (rc < 0) {
    fprintf (stderr, "%s: message read failed: %s\n",
             blurb(), strerror(-rc));
    return 1;  /* >= 0 means success */
  }

  /* Use the scheme described at
     https://www.freedesktop.org/wiki/Software/systemd/inhibit/
     under "Taking Delay Locks".
   */

  if (before_sleep) {
    /* Tell xscreensaver that we are suspending, and to lock if desired. */
    xscreensaver_command ("suspend");

    if (ctx->lock_message) {
      /* Release the lock, meaning we are done and it's ok to sleep now.
         Don't rely on unref'ing the message to close the fd, do that
         explicitly here.
      */
      close(ctx->lock_fd);
      sd_bus_message_unref (ctx->lock_message);
      ctx->lock_message = NULL;
      ctx->lock_fd = -1;
    } else {
      fprintf (stderr, "%s: no context lock\n", blurb());
    }
  } else {
    /* Tell xscreensaver to present the unlock dialog right now. */
    xscreensaver_command ("deactivate");

    /* We woke from sleep, so we need to re-register for the next sleep. */
    rc = xscreensaver_register_sleep_lock (ctx);
    if (rc < 0)
      fprintf (stderr, "%s: could not re-register sleep lock\n", blurb());
  }

  return 1;  /* >= 0 means success */
}


/* Called from the vtable when another process sends a request to systemd
   to inhibit the screen saver.  We return to them a cookie which they must
   present with their "uninhibit" request.
 */
static int
xscreensaver_method_inhibit (sd_bus_message *m, void *arg,
                             sd_bus_error *ret_error)
{
  struct handler_ctx *ctx = arg;
  const char *application_name = 0, *inhibit_reason = 0;
  struct inhibit_entry *entry = 0;
  const char *s;
  const char *sender;

  int rc = sd_bus_message_read(m, "ss", &application_name, &inhibit_reason);
  if (rc < 0) {
    fprintf (stderr, "%s: failed to parse method call: %s\n",
             blurb(), strerror(-rc));
    return rc;
  }

  if (!application_name || !*application_name) {
    fprintf (stderr, "%s: no app name in method call\n", blurb());
    return -1;
  }

  if (!inhibit_reason || !*inhibit_reason) {
    fprintf (stderr, "%s: no reason in method call from \"%s\"\n",
             blurb(), application_name);
    return -1;
  }

  sender = sd_bus_message_get_sender (m);

  /* Omit directory (Chrome does this shit) */
  s = strrchr (application_name, '/');
  if (s && s[1]) application_name = s+1;

  if (strcasestr (inhibit_reason, "audio") &&
      !strcasestr (inhibit_reason, "video")) {
    /* Firefox 78 sends an inhibit when playing audio only, with reason
       "audio-playing".  This is horrible.  Ignore it.  (But perhaps it
       would be better to accept it, issue them a cookie, and then just
       ignore that entry?) */
    if (verbose_p)
      fprintf (stderr, "%s: inhibited by \"%s\" (%s) with \"%s\", ignored\n",
               blurb(), application_name, sender, inhibit_reason);
    return -1;
  }
  
  /* Tell the global tracker object to monitor when this peer exits. */
  rc = sd_bus_track_add_name(ctx->track, sender);
  if (rc < 0) {
    fprintf (stderr, "%s: failed to track peer \"%s\": %s\n",
             blurb(), sender, strerror(-rc));
    sender = NULL;
  }

  entry = malloc(sizeof (struct inhibit_entry));
  entry->cookie = ya_random();
  entry->appname = strdup(application_name);
  entry->peer = sender ? strdup(sender) : NULL;
  entry->start_time = time ((time_t *)0);
  SLIST_INSERT_HEAD(&inhibit_head, entry, entries);
  ctx->is_inhibited++;
  if (verbose_p)
    fprintf (stderr, "%s: inhibited by \"%s\" (%s) with \"%s\""
             " -> cookie %08X\n",
             blurb(), application_name, sender, inhibit_reason, entry->cookie);

  return sd_bus_reply_method_return (m, "u", entry->cookie);
}


/* Called from the vtable when another process sends a request to systemd
   to uninhibit the screen saver.  The cookie must match an earlier "inhibit"
   request.
 */
static int
xscreensaver_method_uninhibit (sd_bus_message *m, void *arg,
                               sd_bus_error *ret_error)
{
  struct handler_ctx *ctx = arg;
  uint32_t cookie;
  struct inhibit_entry *entry;
  int found = 0;
  const char *sender;

  int rc = sd_bus_message_read (m, "u", &cookie);
  if (rc < 0) {
    fprintf (stderr, "%s: failed to parse method call: %s\n",
             blurb(), strerror(-rc));
    return rc;
  }

  sender = sd_bus_message_get_sender (m);

  SLIST_FOREACH(entry, &inhibit_head, entries) {
    if (entry->cookie == cookie) {
      if (verbose_p)
        fprintf (stderr, "%s: uninhibited by \"%s\" (%s) with cookie %08X\n",
                 blurb(), entry->appname, sender, cookie);
      SLIST_REMOVE (&inhibit_head, entry, inhibit_entry, entries);
      if (entry->appname) free (entry->appname);
      if (entry->peer) {
        rc = sd_bus_track_remove_name(ctx->track, entry->peer);
        if (rc < 0) {
          fprintf (stderr, "%s: failed to stop tracking peer \"%s\": %s\n",
                   blurb(), entry->peer, strerror(-rc));
        }
        free(entry->peer);
      }
      free(entry);
      ctx->is_inhibited--;
      if (ctx->is_inhibited < 0)
        ctx->is_inhibited = 0;
      found = 1;
      break;
    }
  }

  if (! found)
    fprintf (stderr, "%s: uninhibit: no match for cookie %08X\n",
             blurb(), cookie);

  return sd_bus_reply_method_return (m, "");
}

/*
 * This vtable defines the service interface we implement.
 */
static const sd_bus_vtable
xscreensaver_dbus_vtable[] = {
    SD_BUS_VTABLE_START(0),
    SD_BUS_METHOD("Inhibit", "ss", "u", xscreensaver_method_inhibit,
                  SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("UnInhibit", "u", "", xscreensaver_method_uninhibit,
                  SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_VTABLE_END
};


/* The only reason this program connects to X at all is so that it dies
   right away when the X server shuts down.  Otherwise the process might
   linger, still connected to systemd but unable to connect to xscreensaver.
 */
static Display *
open_dpy (void)
{
  Display *d;
  const char *s = getenv("DISPLAY");
  if (!s || !*s) {
    fprintf (stderr, "%s: $DISPLAY unset\n", progname);
    exit (1);
  }

  d = XOpenDisplay (s);
  if (!d) {
    fprintf (stderr, "%s: can't open display %s\n", progname, s);
    exit (1);
  }

  return d;
}


static pid_t
get_bus_name_pid (sd_bus *bus, const char *name)
{
  int rc;
  sd_bus_creds *creds;
  pid_t pid;

  rc = sd_bus_get_name_creds (bus, name, SD_BUS_CREDS_PID, &creds);
  if (rc == 0) {
    rc = sd_bus_creds_get_pid (creds, &pid);
    sd_bus_creds_unref (creds);
    if (rc == 0)
      return pid;
  }

  return -1;
}


/* This only works on Linux, but it's useful for the error message.
 */
static char *
process_name (pid_t pid)
{
  char fn[100], buf[100], *s;
  FILE *fd = 0;
  if (pid <= 0) goto FAIL;
  /* "comm" truncates at 16 characters. "cmdline" has nulls between args. */
  sprintf (fn, "/proc/%lu/cmdline", (unsigned long) pid);
  fd = fopen (fn, "r");
  if (!fd) goto FAIL;
  if (!fgets (buf, sizeof(buf)-1, fd)) goto FAIL;
  if (fclose (fd) != 0) goto FAIL;
  s = strchr (buf, '\n');
  if (s) *s = 0;
  return strdup (buf);
 FAIL:
  if (fd) fclose (fd);
  return 0;
}


static int
xscreensaver_systemd_loop (void)
{
  sd_bus *system_bus = NULL, *user_bus = NULL;
  struct handler_ctx *ctx = &global_ctx;
  sd_bus_error error = SD_BUS_ERROR_NULL;
  int rc;
  time_t last_deactivate_time = 0;
  Display *dpy = open_dpy();

  /* 'user_bus' is where we receive messages from other programs sending
     inhibit/uninhibit to org.freedesktop.ScreenSaver, etc.
   */

  rc = sd_bus_open_user (&user_bus);
  if (rc < 0) {
    fprintf (stderr, "%s: user bus connection failed: %s\n",
             blurb(), strerror(-rc));
    goto FAIL;
  }

  /* Create a single tracking object so that we can later ask it,
     "is the peer with this name still around?"  This is how we tell
     that Firefox has exited without calling 'uninhibit'.
   */
  rc = sd_bus_track_new (user_bus,
                         &global_ctx.track,
                         NULL,
                         NULL);
  if (rc < 0) {
    fprintf (stderr, "%s: cannot create user bus tracker: %s\n",
             blurb(), strerror(-rc));
    goto FAIL;
  }

  rc = sd_bus_add_object_vtable (user_bus,
                                 NULL,
                                 DBUS_FDO_OBJECT_PATH,
                                 DBUS_FDO_INTERFACE,
                                 xscreensaver_dbus_vtable,
                                 &global_ctx);
  if (rc < 0) {
    fprintf (stderr, "%s: vtable registration failed: %s\n",
             blurb(), strerror(-rc));
    goto FAIL;
  }

  rc = sd_bus_add_object_vtable (user_bus,
                                 NULL,
                                 DBUS_FDO_OBJECT_PATH_2,
                                 DBUS_FDO_INTERFACE,
                                 xscreensaver_dbus_vtable,
                                 &global_ctx);
  if (rc < 0) {
    fprintf (stderr, "%s: vtable registration failed: %s\n",
             blurb(), strerror(-rc));
    goto FAIL;
  }

  {
    const char * const names[] = { DBUS_FDO_NAME, DBUS_CLIENT_NAME };
    int i = 0;
    for (i = 0; i < countof(names); i++) {
      rc = sd_bus_request_name (user_bus, names[i], 0);
      if (rc < 0) {
        pid_t pid = get_bus_name_pid (user_bus, names[i]);
        if (pid != -1) {
          char *pname = process_name (pid);
          if (pname) {
            fprintf (stderr,
                     "%s: connection failed: \"%s\" in use by pid %lu (%s)\n",
                     blurb(), names[i], (unsigned long) pid, pname);
            free (pname);
          } else {
            fprintf (stderr,
                     "%s: connection failed: \"%s\" in use by pid %lu\n",
                     blurb(), names[i], (unsigned long) pid);
          }
        } else if (-rc == EEXIST || -rc == EALREADY) {
          fprintf (stderr, "%s: connection failed: \"%s\" already in use\n",
                   blurb(), names[i]);
        } else {
          fprintf (stderr, "%s: connection failed for \"%s\": %s\n",
                   blurb(), names[i], strerror(-rc));
        }
        goto FAIL;
      }
    }
  }

  /* 'system_bus' is where we hold a lock on org.freedesktop.login1, meaning
     that the system will send us a PrepareForSleep message when the system is
     about to suspend.
  */

  rc = sd_bus_open_system (&system_bus);
  if (rc < 0) {
    fprintf (stderr, "%s: system bus connection failed: %s\n",
             blurb(), strerror(-rc));
    goto FAIL;
  }

  /* Obtain a lock fd from the "Inhibit" method, so that we can delay
     sleep when a "PrepareForSleep" signal is posted. */

  ctx->system_bus = system_bus;
  rc = xscreensaver_register_sleep_lock (ctx);
  if (rc < 0)
    goto FAIL;

  /* This is basically an event mask, saying that we are interested in
     "PrepareForSleep", and to run our callback when that signal is thrown.
  */
  rc = sd_bus_add_match (system_bus, NULL, DBUS_SD_MATCH,
                         xscreensaver_systemd_handler,
                         &global_ctx);
  if (rc < 0) {
    fprintf (stderr, "%s: add match failed: %s\n", blurb(), strerror(-rc));
    goto FAIL;
  }

  if (verbose_p)
    fprintf (stderr, "%s: connected\n", blurb());


  /* Run an event loop forever, and wait for our callback to run.
   */
  while (1) {
    struct pollfd fds[3];
    uint64_t poll_timeout, system_timeout, user_timeout;
    struct inhibit_entry *entry;

    /* We MUST call sd_bus_process() on each bus at least once before calling
       sd_bus_get_events(), so just always start the event loop by processing
       all outstanding requests on both busses. */
    do {
      rc = sd_bus_process (system_bus, NULL);
      if (rc < 0) {
        fprintf (stderr, "%s: failed to process system bus: %s\n",
                 blurb(), strerror(-rc));
        goto FAIL;
      }
    } while (rc > 0);

    do {
      rc = sd_bus_process (user_bus, NULL);
      if (rc < 0) {
        fprintf (stderr, "%s: failed to process user bus: %s\n",
                 blurb(), strerror(-rc));
        goto FAIL;
      }
    } while (rc > 0);

    fds[0].fd = sd_bus_get_fd (system_bus);
    fds[0].events = sd_bus_get_events (system_bus);
    fds[0].revents = 0;

    fds[1].fd = sd_bus_get_fd (user_bus);
    fds[1].events = sd_bus_get_events (user_bus);
    fds[1].revents = 0;

    fds[2].fd = XConnectionNumber (dpy);
    fds[2].events = POLLIN;
    fds[2].revents = 0;


    sd_bus_get_timeout (system_bus, &system_timeout);
    sd_bus_get_timeout (user_bus, &user_timeout);

    if (system_timeout == 0 && user_timeout == 0)
      poll_timeout = 0;
    else if (system_timeout == UINT64_MAX && user_timeout == UINT64_MAX)
      poll_timeout = -1;
    else {
      poll_timeout = (system_timeout < user_timeout
                      ? system_timeout : user_timeout);
      poll_timeout /= 1000000;
    }

    /* Prune any entries whose original sender has gone away: this happens
       if a program inhibits, then exits without having called uninhibit.
       That would have left us inhibited forever, even if the inhibiting
       program was re-launched, since the new instance won't have the
       same cookie. */
    SLIST_FOREACH (entry, &inhibit_head, entries) {
      if (entry->peer &&
          !sd_bus_track_count_name (ctx->track, entry->peer)) {
        if (verbose_p)
          fprintf (stderr,
                   "%s: peer %s for inhibiting app \"%s\" has died:"
                   " uninhibiting %08X\n",
                   blurb(),
                   entry->peer,
                   entry->appname,
                   entry->cookie);
        SLIST_REMOVE (&inhibit_head, entry, inhibit_entry, entries);
        if (entry->appname) free (entry->appname);
        free(entry->peer);
        free (entry);
        ctx->is_inhibited--;
        if (ctx->is_inhibited < 0)
          ctx->is_inhibited = 0;
      }
    }


    /* We want to wake up at least once every N seconds to de-activate
       the screensaver if we have been inhibited.
     */
    if (poll_timeout > HEARTBEAT_INTERVAL * 1000)
      poll_timeout = HEARTBEAT_INTERVAL * 1000;

    rc = poll (fds, 3, poll_timeout);
    if (rc < 0) {
      fprintf (stderr, "%s: poll failed: %s\n", blurb(), strerror(-rc));
      exit (EXIT_FAILURE);
    }

    if (fds[2].revents & (POLLERR | POLLHUP | POLLNVAL)) {
      fprintf (stderr, "%s: X connection closed\n", blurb());
      goto FAIL;
    }

    if (ctx->is_inhibited) {
      time_t now = time ((time_t *) 0);
      if (now - last_deactivate_time >= HEARTBEAT_INTERVAL) {
        if (verbose_p) {
          SLIST_FOREACH (entry, &inhibit_head, entries) {
            char ct[100];
            ctime_r (&entry->start_time, ct);
            fprintf (stderr, "%s: inhibited by \"%s\" since %s",
                     blurb(), entry->appname, ct);
          }
        }
        xscreensaver_command ("deactivate");
        last_deactivate_time = now;
      }
    }
  }

 FAIL:

  XCloseDisplay(dpy);

  if (system_bus)
    sd_bus_flush_close_unref (system_bus);

  if (ctx->track)
    sd_bus_track_unref (ctx->track);

  if (user_bus)
    sd_bus_flush_close_unref (user_bus);

  sd_bus_error_free (&error);

  return EXIT_FAILURE;
}


static char *usage = "\n\
usage: %s [-verbose]\n\
\n\
This program is launched by the xscreensaver daemon to monitor DBus.\n\
It invokes 'xscreensaver-command' to tell the xscreensaver daemon to lock\n\
the screen before the system suspends, e.g., when a laptop's lid is closed.\n\
\n\
It also responds to certain messages sent by media players allowing them to\n\
request that the screen not be blanked during playback.\n\
\n\
From XScreenSaver %s, (c) 1991-%s Jamie Zawinski <jwz@jwz.org>.\n";


#define USAGE() do { \
 fprintf (stderr, usage, progname, screensaver_version, year); exit (1); \
 } while(0)


int
main (int argc, char **argv)
{
  int i;
  char *version = strdup (screensaver_id + 17);
  char *year = strchr (version, '-');
  char *s = strchr (version, ' ');
  *s = 0;
  year = strchr (year+1, '-') + 1;
  s = strchr (year, ')');
  *s = 0;

  screensaver_version = version;

  progname = argv[0];
  s = strrchr (progname, '/');
  if (s) progname = s+1;

  for (i = 1; i < argc; i++)
    {
      const char *s = argv [i];
      int L;
      if (s[0] == '-' && s[1] == '-') s++;
      L = strlen (s);
      if (L < 2) USAGE ();
      else if (!strncmp (s, "-verbose", L)) verbose_p = 1;
      else if (!strncmp (s, "-quiet",   L)) verbose_p = 0;
      else USAGE ();
    }

# undef ya_rand_init
  ya_rand_init (0);

  exit (xscreensaver_systemd_loop());
}