/* xscreensaver, Copyright (c) 1991-2020 Jamie Zawinski <jwz@jwz.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 */

/*   ========================================================================
 *   HOW IT WORKS
 *   ========================================================================
 *
 *   First we wait until the keyboard and mouse become idle for the specified
 *   amount of time.  Then, we map one or more full screen black windows.
 *
 *   We hold grabs on our override-redirect windows to ensure that user input
 *   does not leak through the screen saver to other applications on the 
 *   desktop.  If we cannot secure those grabs, we do not blank the screen.
 *
 *   Creating those windows:
 *
 *     - If there are multiple screens, in the X11 sense of "screen", we
 *       create a window for each (the second number in the $DISPLAY
 *       variable, "host:display.screen".)
 *
 *     - On Xinerama/RANDR systems, we create windows covering each physical
 *       monitor, meaning multiple windows on the same virtual desktop.
 *
 *   Then we pick a random program to run, and start it.  We assume that it
 *   has been specified with whatever command line arguments are required to
 *   make it render onto the window we have provided.  This is most easily
 *   accomplished by simply including the late-2003 version of "vroot.h",
 *   which will find the window via the $XSCREENSAVER_WINDOW environment
 *   variable, or via the __SWM_VROOT property.
 *
 *   Programs must draw onto the window provided.  Creating their own window
 *   atop the xscreensaver window does not work.
 *
 *   Then, we wait for keyboard or mouse events to be generated on our
 *   windows.  When they are, we kill the inferior process, unmap the
 *   windows, and restore the __SWM_VROOT property to the real virtual root
 *   window if there was one.
 *
 *   Do not ever kill XScreenSaver with signal 9 -- that can lead to the
 *   __SWM_VROOT property not being restored, and that will screw up your
 *   window manager.  Rather than "kill", use "xscreensaver-command -exit"
 *   instead.
 *
 *   While we are waiting for user activity, we also set up timers so that,
 *   after a certain amount of time has passed, we can start a different
 *   screenhack.  We do this by killing the running child process with
 *   SIGTERM, and then starting a new one in the same way.
 *
 *   This program accepts ClientMessages of type SCREENSAVER; these messages
 *   may contain the atoms ACTIVATE, DEACTIVATE, etc. The included
 *   "xscreensaver-command" program sends these messsages.
 *
 *
 *   ========================================================================
 *   ABOUT SERVER EXTENSIONS
 *   ========================================================================
 *
 *   Over the decades, there have been three X11 server extensions that are
 *   applicable to screen saving:
 *
 *     - XIdle
 *
 *       This extension provided a function to poll the user's idle time.
 *       It was simple and direct and worked great.  Therefore, it was
 *       removed from the X11 distribution in 1994, with the release of
 *       X11R6.  https://bugs.freedesktop.org/show_bug.cgi?id=1419
 *
 *     - SGI SCREEN_SAVER
 *
 *       This extension sent two new events: "user is idle", and "user
 *       is no longer idle". It was simple and direct and worked great.
 *       But as the name implies, it only ever worked on Silicon
 *       Graphics machines.  SGI became irrelevant around 1998 and went
 *       out of business in 2009.
 *
 *     - MIT-SCREEN-SAVER
 *
 *       This extension still exists, but it is useless to us.  It takes
 *       the following approach:
 *
 *         - When the user is idle, immediately map full screen black
 *           windows on each screen.
 *
 *         - Inform the screen saver client that the screen is now black.
 *
 *         - When user activity occurs, unmap the windows and then
 *           inform the screen saver client.
 *
 *       The screen saver client can specify a few parameters of that
 *       window, like visual and depth, but that's it.
 *
 *       The extension is designed with the assumption that a screen saver
 *       would render onto the provided window.  However:
 *
 *         - OpenGL programs may require different visuals than 2D X11
 *           programs, and you can't change the visual of a window after it
 *           has been created.
 *
 *         - The extension maps one window per X11 "Screen", which, in this
 *           modern world, tend to span the entire virtual desktop; whereas
 *           XScreenSaver runs savers full screen on each *monitor* instead.
 *           In other words, it is incompatible with Xinerama / RANDR.
 *
 *         - Since this extension maps its own full-screen black windows and
 *           informs us of that after the fact, it prevents the "fade/unfade"
 *           animations from working properly.
 *
 *         - Since it only tells us when the user is idle or non-idle, it
 *           prevents the "hysteresis" option from working properly (where
 *           we ignore tiny mouse motions).
 *
 *       In summary, it creates its windows too early, removes them too late,
 *       creates windows of the wrong quantity and wrong shape, cannot create
 *       them with the proper visuals, and delivers too little information
 *       about what caused the user activity.
 *
 *       Also my experience was that the MIT-SCREEN-SAVER extension was flaky,
 *       and using it at all led to frequent server crashes.
 *
 *       So that's why, even if the server supports the MIT-SCREEN-SAVER
 *       extension, we don't use it.
 *
 *       There is a recent trend among those who hack on video players to
 *       say, "We inhibit blanking by calling XResetScreenSaver and/or
 *       XScreenSaverSuspend, so our work here is done, fuck off."  This
 *       betrays a willful ignorance of why the MIT-SCREEN-SAVER extension
 *       is a useless foundation upon which to build a screen saver or
 *       screen locker.
 *
 *       The proper way to inhibit blanking while video is playing is to
 *       run "xscreensaver-command -deactivate" once a minute while the
 *       video is playing, as has been explained in the XScreenSaver FAQ
 *       for 3 decades: https://www.jwz.org/xscreensaver/faq.html#dvd
 *
 *       The reason to do it as a heartbeat is so that your video player
 *       fails SAFE.  Should the player exit abnormally, or freeze, the
 *       heartbeat stops coming, and screen blanking and locking can resume.
 *
 *
 *   ========================================================================
 *   WITHOUT SERVER EXTENSIONS
 *   ========================================================================
 *
 *   So.  Having established that there no longer exist any server extensions
 *   that help us in any way, here's how idle detection ACTUALLY works:
 *
 *   XScreenSaver notices every window that gets created, wait 30 seconds or
 *   so until its birth pangs have settled down, and then select KeyPress
 *   events on those windows.
 *
 *   Actually it only selects KeyPress events on windows that already selected
 *   for their own KeyPress events, because to do otherwise would interfere
 *   with event propagation.  When dispatching a KeyPress event, X finds the
 *   lowest (leafmost) window in the hierarchy on which *any* client selects
 *   for KeyPress, and sends the event to that window.  This means that if a
 *   client had a window with subwindows, and expected to receive KeyPress
 *   events on the parent window instead of the subwindows, then that client
 *   would malfunction if some other client selected KeyPress events on the
 *   subwindows.  It is an incredible misdesign that one client can make
 *   another client malfunction in this way.
 *
 *   But here's a new kink that started showing up in late 2014: GNOME programs
 *   don't actually select for or receive KeyPress events!  They do it behind
 *   the scenes through some kind of Input Method magic, even when running in
 *   an en_US locale.  However, in that case, those applications *do* seem to
 *   update the _NET_WM_USER_TIME on their own windows every time they have
 *   received a secret KeyPress, so we *also* monitor that property on every
 *   window, and treat changes to it as identical to KeyPress.
 *
 *   To detect mouse motion, we periodically wake up and poll the mouse
 *   position and button/modifier state, and notice when something has
 *   changed.  We make this check every five seconds by default, and since
 *   the screensaver timeout has a granularity of one minute, this makes the
 *   chance of a false positive very small.  We could detect mouse motion in
 *   the same way as keyboard activity, but that would suffer from the same
 *   "client changing event mask" problem that the KeyPress events hack does.
 *   Polling is more reliable.
 *
 *   Also, because cats, trucks and earthquakes are things that exist, we
 *   ignore any mouse motions smaller than 10px by default.
 *
 *   On Linux systems with /proc/interrupts we poll that file and note when
 *   the interrupt counter numbers on the "keyboard" and "PS/2" lines change.
 *   That was helpful for a decade or so, but then PS/2 devices went out of
 *   fashion, and there is no reliable way, using /proc/interrupts, to detect
 *   activity on USB keyboards or mice.  Oh well.
 *
 *
 *   ========================================================================
 *   DEBUGGING HINTS
 *   ========================================================================
 *
 *     - Have a second terminal handy, e.g. a Ctrl-Alt-F1 console.  If you
 *       are running xscreensaver under a debugger, it might be helpful to
 *       run it from that other console, not from a terminal window within
 *       the same X11 session.  That runs the risk of stopping at a
 *       breakpoint while the screen is blanked and the keyboard is grabbed.
 *
 *     - Go read the code related to `debug_p'.
 *
 *     - You probably can't set breakpoints in functions that are called on
 *       the other side of a call to fork() -- if your subprocesses are
 *       dying with signal 5 Trace/BPT Trap, you're losing in this way.
 *
 *     - Don't leave this stopped under the debugger for very long, or the
 *       X input buffer will get huge with un-read KeyPress events.  This
 *       can make your X server hang with "no more input buffers."
 *
 *     - Writing a new screen saver?  See the README.hacking file.
 *
 * ======================================================================== */

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

#include <stdio.h>
#include <ctype.h>
#include <X11/Xlib.h>

#ifdef ENABLE_NLS
# include <locale.h>
# include <libintl.h>
#endif /* ENABLE_NLS */

#include <X11/Xlibint.h>

#include <X11/Xatom.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Shell.h>
#include <X11/Xos.h>
#include <time.h>
#include <sys/time.h>
#include <netdb.h>	/* for gethostbyname() */
#include <sys/types.h>
#include <pwd.h>
#ifdef HAVE_XMU
# ifndef VMS
#  include <X11/Xmu/Error.h>
# else  /* !VMS */
#  include <Xmu/Error.h>
# endif /* !VMS */
#else  /* !HAVE_XMU */
# include "xmu.h"
#endif /* !HAVE_XMU */

#ifdef HAVE_MIT_SAVER_EXTENSION
#include <X11/extensions/scrnsaver.h>
#endif /* HAVE_MIT_SAVER_EXTENSION */

#ifdef HAVE_XIDLE_EXTENSION
# include <X11/extensions/xidle.h>
#endif /* HAVE_XIDLE_EXTENSION */

#ifdef HAVE_SGI_VC_EXTENSION
# include <X11/extensions/XSGIvc.h>
#endif /* HAVE_SGI_VC_EXTENSION */

#ifdef HAVE_READ_DISPLAY_EXTENSION
# include <X11/extensions/readdisplay.h>
#endif /* HAVE_READ_DISPLAY_EXTENSION */

#ifdef HAVE_XSHM_EXTENSION
# include <X11/extensions/XShm.h>
#endif /* HAVE_XSHM_EXTENSION */

#ifdef HAVE_DPMS_EXTENSION
# include <X11/extensions/dpms.h>
#endif /* HAVE_DPMS_EXTENSION */


#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
# include <X11/extensions/Xdbe.h>
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */

#ifdef HAVE_XF86VMODE
# include <X11/extensions/xf86vmode.h>
#endif /* HAVE_XF86VMODE */

#ifdef HAVE_XF86MISCSETGRABKEYSSTATE
# include <X11/extensions/xf86misc.h>
#endif /* HAVE_XF86MISCSETGRABKEYSSTATE */

#ifdef HAVE_XINERAMA
# include <X11/extensions/Xinerama.h>
#endif /* HAVE_XINERAMA */

#ifdef HAVE_RANDR
# include <X11/extensions/Xrandr.h>
#endif /* HAVE_RANDR */


#include "xscreensaver.h"
#include "version.h"
#include "yarandom.h"
#include "resources.h"
#include "visual.h"
#include "usleep.h"
#include "auth.h"

saver_info *global_si_kludge = 0;	/* I hate C so much... */

char *progname = 0;
char *progclass = 0;
XrmDatabase db = 0;


static Atom XA_SCREENSAVER_RESPONSE;
static Atom XA_ACTIVATE, XA_DEACTIVATE, XA_SUSPEND, XA_CYCLE, XA_NEXT, XA_PREV;
static Atom XA_RESTART, XA_SELECT;
static Atom XA_THROTTLE, XA_UNTHROTTLE;
Atom XA_DEMO, XA_PREFS, XA_EXIT, XA_LOCK, XA_BLANK;


static XrmOptionDescRec options [] = {

  { "-verbose",		   ".verbose",		XrmoptionNoArg, "on" },
  { "-silent",		   ".verbose",		XrmoptionNoArg, "off" },

  /* xscreensaver-demo uses this one */
  { "-nosplash",	   ".splash",		XrmoptionNoArg, "off" },
  { "-no-splash",	   ".splash",		XrmoptionNoArg, "off" },

  /* useful for debugging */
  { "-no-capture-stderr",  ".captureStderr",	XrmoptionNoArg, "off" },
  { "-log",		   ".logFile",		XrmoptionSepArg, 0 },
};

#ifdef __GNUC__
 __extension__     /* shut up about "string length is greater than the length
                      ISO C89 compilers are required to support" when including
                      the .ad file... */
#endif

static char *defaults[] = {
#include "XScreenSaver_ad.h"
 0
};

#ifdef _VROOT_H_
ERROR!  You must not include vroot.h in this file.
#endif

static void
do_help (saver_info *si)
{
  char *s, year[5];
  s = strchr (screensaver_id, '-');
  s = strrchr (s, '-');
  s++;
  strncpy (year, s, 4);
  year[4] = 0;

  fflush (stdout);
  fflush (stderr);
  fprintf (stdout, "\
xscreensaver %s, copyright (c) 1991-%s by Jamie Zawinski <jwz@jwz.org>\n\
\n\
  All xscreensaver configuration is via the `~/.xscreensaver' file.\n\
  Rather than editing that file by hand, just run `xscreensaver-demo':\n\
  that program lets you configure the screen saver graphically,\n\
  including timeouts, locking, and display modes.\n\
\n",
	  si->version, year);
  fprintf (stdout, "\
  Just getting started?  Try this:\n\
\n\
        xscreensaver &\n\
        xscreensaver-demo\n\
\n\
  For updates, online manual, and FAQ, please see the web page:\n\
\n\
       https://www.jwz.org/xscreensaver/\n\
\n");

  fflush (stdout);
  fflush (stderr);
  exit (1);
}


Bool in_signal_handler_p = 0;	/* I hate C so much... */

char *
timestring (time_t when)
{
  if (in_signal_handler_p)
    {
      /* Turns out that ctime() and even localtime_r() call malloc() on Linux!
         So we can't call them from inside SIGCHLD.  WTF.
       */
      static char buf[30];
      strcpy (buf, "... ... ..   signal ....");
      return buf;
    }
  else
    {
      char *str, *nl;
      if (! when) when = time ((time_t *) 0);
      str = (char *) ctime (&when);
      nl = (char *) strchr (str, '\n');
      if (nl) *nl = 0; /* take off that dang newline */
      return str;
    }
}

static Bool blurb_timestamp_p = True;   /* kludge */

const char *
blurb (void)
{
  if (!blurb_timestamp_p)
    return progname;
  else
    {
      static char buf[255];
      char *ct = timestring(0);
      int n = strlen(progname);
      if (n > 100) n = 99;
      strncpy(buf, progname, n);
      buf[n++] = ':';
      buf[n++] = ' ';
      strncpy(buf+n, ct+11, 8);
      strcpy(buf+n+9, ": ");
      return buf;
    }
}


int
saver_ehandler (Display *dpy, XErrorEvent *error)
{
  saver_info *si = global_si_kludge;	/* I hate C so much... */
  int i;
  Bool fatal_p;

  if (!real_stderr) real_stderr = stderr;

  fprintf (real_stderr, "\n"
	   "#######################################"
	   "#######################################\n\n"
	   "%s: X Error!  PLEASE REPORT THIS BUG.\n",
	   blurb());

  for (i = 0; i < si->nscreens; i++)
    {
      saver_screen_info *ssi = &si->screens[i];
      fprintf (real_stderr, "%s: screen %d/%d: 0x%x, 0x%x, 0x%x\n",
               blurb(), ssi->real_screen_number, ssi->number,
               (unsigned int) RootWindowOfScreen (si->screens[i].screen),
               (unsigned int) si->screens[i].real_vroot,
               (unsigned int) si->screens[i].screensaver_window);
    }

  fprintf (real_stderr, "\n"
	   "#######################################"
	   "#######################################\n\n");

  fatal_p = XmuPrintDefaultErrorMessage (dpy, error, real_stderr);

  fatal_p = True;  /* The only time I've ever seen a supposedly nonfatal error,
                      it has been BadImplementation / Xlib sequence lost, which
                      are in truth pretty damned fatal.
                    */

  fprintf (real_stderr, "\n");

  if (! fatal_p)
    fprintf (real_stderr, "%s: nonfatal error.\n\n", blurb());
  else
    {
      if (si->prefs.xsync_p)
	{
	  saver_exit (si, -1, "because of synchronous X Error");
	}
      else
	{
#ifdef __GNUC__
  __extension__   /* don't warn about "string length is greater than the
                     length ISO C89 compilers are required to support". */
#endif
          fprintf (real_stderr,
   "#######################################################################\n"
   "\n"
   "    If at all possible, please re-run xscreensaver with the command\n"
   "    line arguments \"-sync -log log.txt\", and reproduce this bug.\n"
   "    That will cause xscreensaver to dump a `core' file to the current\n"
   "    directory.  Please include the stack trace from that core file\n"
   "    in your bug report.  *DO NOT* mail the core file itself!  That\n"
   "    won't work.  A \"log.txt\" file will also be written.  Please *do*\n"
   "    include the complete \"log.txt\" file with your bug report.\n"
   "\n"
   "    https://www.jwz.org/xscreensaver/bugs.html explains how to create\n"
   "    the most useful bug reports, and how to examine core files.\n"
   "\n"
   "    The more information you can provide, the better.  But please\n"
   "    report this bug, regardless!\n"
   "\n"
   "#######################################################################\n"
   "\n"
   "\n");

	  saver_exit (si, -1, 0);
	}
    }

  return 0;
}


#ifdef __GNUC__  /* Silence warning */
static void startup_ehandler (String, String, String, String, String *,
                              Cardinal *) __attribute__((noreturn));
#endif /* __GNUC__ */

/* This error handler is used only while the X connection is being set up;
   after we've got a connection, we don't use this handler again.  The only
   reason for having this is so that we can present a more idiot-proof error
   message than "cannot open display."
 */
static void 
startup_ehandler (String name, String type, String class,
                  String defalt,  /* one can't even spel properly
                                     in this joke of a language */
                  String *av, Cardinal *ac)
{
  char fmt[512];
  String p[10];
  saver_info *si = global_si_kludge;	/* I hate C so much... */
  XrmDatabase *db = XtAppGetErrorDatabase(si->app);
  *fmt = 0;
  XtAppGetErrorDatabaseText(si->app, name, type, class, defalt,
                            fmt, sizeof(fmt)-1, *db);

  fprintf (stderr, "%s: ", blurb());

  memset (p, 0, sizeof(p));
  if (*ac > countof (p)) *ac = countof (p);
  memcpy ((char *) p, (char *) av, (*ac) * sizeof(*av));
  fprintf (stderr, fmt,		/* Did I mention that I hate C? */
           p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9]);
  fprintf (stderr, "\n");

  describe_uids (si, stderr);

  if (si->orig_uid && !strncmp (si->orig_uid, "root/", 5))
    {
      fprintf (stderr, "\n"
          "%s: This is probably because you're logging in as root.  You\n"
"              shouldn't log in as root: you should log in as a normal user,\n"
"              and then `su' as needed.  If you insist on logging in as\n"
"              root, you will have to turn off X's security features before\n"
"              xscreensaver will work.\n"
               "\n"
"              Please read the manual and FAQ for more information:\n",
               blurb());
    }
  else
    {
      fprintf (stderr, "\n"
          "%s: Errors at startup are usually authorization problems.\n"
"              But you're not logging in as root (good!) so something\n"
"              else must be wrong.  Did you read the manual and the FAQ?\n",
           blurb());
    }

  fprintf (stderr, "\n"
          "              https://www.jwz.org/xscreensaver/faq.html\n"
          "              https://www.jwz.org/xscreensaver/man.html\n"
          "\n");

  fflush (stderr);
  fflush (stdout);
  exit (1);
}


/* The zillions of initializations.
 */

/* Set progname, version, etc.  This is done very early.
 */
static void
set_version_string (saver_info *si, int *argc, char **argv)
{
  progclass = "XScreenSaver";

  /* progname is reset later, after we connect to X. */
  progname = strrchr(argv[0], '/');
  if (progname) progname++;
  else progname = argv[0];

  if (strlen(progname) > 100)	/* keep it short. */
    progname[99] = 0;

  /* The X resource database blows up if argv[0] has a "." in it. */
  {
    char *s = argv[0];
    while ((s = strchr (s, '.')))
      *s = '_';
  }

  si->version = (char *) malloc (32);
  memcpy (si->version, screensaver_id + 17, 4);
  si->version [4] = 0;
}


/* Initializations that potentially take place as a priveleged user:
   If the xscreensaver executable is setuid root, then these initializations
   are run as root, before discarding privileges.
 */
static void
privileged_initialization (saver_info *si, int *argc, char **argv)
{
#ifndef NO_LOCKING
  /* before hack_uid() for proper permissions */
  lock_priv_init (*argc, argv, si->prefs.verbose_p);
#endif /* NO_LOCKING */

  hack_uid (si);
}


/* Figure out what locking mechanisms are supported.
 */
static void
lock_initialization (saver_info *si, int *argc, char **argv)
{
#ifdef NO_LOCKING
  si->locking_disabled_p = True;
  si->nolock_reason = "not compiled with locking support";
#else /* !NO_LOCKING */

  /* Finish initializing locking, now that we're out of privileged code. */
  if (! lock_init (*argc, argv, si->prefs.verbose_p))
    {
      si->locking_disabled_p = True;
      si->nolock_reason = "error getting password";
    }

  /* If locking is currently enabled, but the environment indicates that
     we have been launched as GDM's "Background" program, then disable
     locking just in case.
   */
  if (!si->locking_disabled_p && getenv ("RUNNING_UNDER_GDM"))
    {
      si->locking_disabled_p = True;
      si->nolock_reason = "running under GDM";
    }

  /* If the server is XDarwin (MacOS X) then disable locking.
     (X grabs only affect X programs, so you can use Command-Tab
     to bring any other Mac program to the front, e.g., Terminal.)
   */
  if (!si->locking_disabled_p)
    {
      int op = 0, event = 0, error = 0;
      Bool macos_p = False;

#ifdef __APPLE__
      /* Disable locking if *running* on Apple hardware, since we have no
         reliable way to determine whether the server is running on MacOS.
         Hopefully __APPLE__ means "MacOS" and not "Linux on Mac hardware"
         but I'm not really sure about that.
       */
      macos_p = True;
#endif

      if (!macos_p)
        /* This extension exists on the Apple X11 server, but not
           on earlier versions of the XDarwin server. */
        macos_p = XQueryExtension (si->dpy, "Apple-DRI", &op, &event, &error);

      if (macos_p)
        {
          si->locking_disabled_p = True;
          si->nolock_reason = "Cannot lock securely on MacOS X";
        }
    }

  /* Like MacOS, locking under Wayland's embedded X11 server does not work.
     (X11 grabs don't work because the Wayland window manager lives at a
     higher level than the X11 emulation layer.)
   */
  if (!si->locking_disabled_p && getenv ("WAYLAND_DISPLAY"))
    {
      si->locking_disabled_p = True;
      si->nolock_reason = "Cannot lock securely under Wayland";
    }

  if (si->prefs.debug_p)    /* But allow locking anyway in debug mode. */
    si->locking_disabled_p = False;

#endif /* NO_LOCKING */
}


/* Open the connection to the X server, and intern our Atoms.
 */
static Widget
connect_to_server (saver_info *si, int *argc, char **argv)
{
  Widget toplevel_shell;

#ifdef HAVE_PUTENV
  char *d = getenv ("DISPLAY");
  if (!d || !*d)
    {
      char *ndpy = strdup("DISPLAY=:0.0");
      /* if (si->prefs.verbose_p) */      /* sigh, too early to test this... */
        fprintf (stderr,
                 "%s: warning: $DISPLAY is not set: defaulting to \"%s\".\n",
                 blurb(), ndpy+8);
      if (putenv (ndpy))
        abort ();
      /* don't free (ndpy) -- some implementations of putenv (BSD 4.4,
         glibc 2.0) copy the argument, but some (libc4,5, glibc 2.1.2)
         do not.  So we must leak it (and/or the previous setting). Yay.
       */
    }
#endif /* HAVE_PUTENV */

  XSetErrorHandler (saver_ehandler);

  XtAppSetErrorMsgHandler (si->app, startup_ehandler);
  toplevel_shell = XtAppInitialize (&si->app, progclass,
				    options, XtNumber (options),
				    argc, argv, defaults, 0, 0);
  XtAppSetErrorMsgHandler (si->app, 0);

  si->dpy = XtDisplay (toplevel_shell);
  si->prefs.db = XtDatabase (si->dpy);
  XtGetApplicationNameAndClass (si->dpy, &progname, &progclass);

  if(strlen(progname) > 100)	/* keep it short. */
    progname [99] = 0;

  db = si->prefs.db;	/* resources.c needs this */

  XA_VROOT = XInternAtom (si->dpy, "__SWM_VROOT", False);
  XA_SCREENSAVER = XInternAtom (si->dpy, "SCREENSAVER", False);
  XA_SCREENSAVER_VERSION = XInternAtom (si->dpy, "_SCREENSAVER_VERSION",False);
  XA_SCREENSAVER_ID = XInternAtom (si->dpy, "_SCREENSAVER_ID", False);
  XA_SCREENSAVER_STATUS = XInternAtom (si->dpy, "_SCREENSAVER_STATUS", False);
  XA_SCREENSAVER_RESPONSE = XInternAtom (si->dpy, "_SCREENSAVER_RESPONSE",
					 False);
  XA_XSETROOT_ID = XInternAtom (si->dpy, "_XSETROOT_ID", False);
  XA_ESETROOT_PMAP_ID = XInternAtom (si->dpy, "ESETROOT_PMAP_ID", False);
  XA_XROOTPMAP_ID = XInternAtom (si->dpy, "_XROOTPMAP_ID", False);
  XA_NET_WM_USER_TIME = XInternAtom (si->dpy, "_NET_WM_USER_TIME", False);
  XA_ACTIVATE = XInternAtom (si->dpy, "ACTIVATE", False);
  XA_DEACTIVATE = XInternAtom (si->dpy, "DEACTIVATE", False);
  XA_SUSPEND = XInternAtom (si->dpy, "SUSPEND", False);
  XA_RESTART = XInternAtom (si->dpy, "RESTART", False);
  XA_CYCLE = XInternAtom (si->dpy, "CYCLE", False);
  XA_NEXT = XInternAtom (si->dpy, "NEXT", False);
  XA_PREV = XInternAtom (si->dpy, "PREV", False);
  XA_SELECT = XInternAtom (si->dpy, "SELECT", False);
  XA_EXIT = XInternAtom (si->dpy, "EXIT", False);
  XA_DEMO = XInternAtom (si->dpy, "DEMO", False);
  XA_PREFS = XInternAtom (si->dpy, "PREFS", False);
  XA_LOCK = XInternAtom (si->dpy, "LOCK", False);
  XA_BLANK = XInternAtom (si->dpy, "BLANK", False);
  XA_THROTTLE = XInternAtom (si->dpy, "THROTTLE", False);
  XA_UNTHROTTLE = XInternAtom (si->dpy, "UNTHROTTLE", False);

  return toplevel_shell;
}


/* Handle the command-line arguments that were not handled for us by Xt.
   Issue an error message and exit if there are unknown options.
 */
static void
process_command_line (saver_info *si, int *argc, char **argv)
{
  int i;
  for (i = 1; i < *argc; i++)
    {
      if (!strcmp (argv[i], "-debug"))
	/* no resource for this one, out of paranoia. */
	si->prefs.debug_p = True;

      else if (!strcmp (argv[i], "-h") ||
	       !strcmp (argv[i], "-help") ||
	       !strcmp (argv[i], "--help"))
	do_help (si);

      else
	{
	  const char *s = argv[i];
	  fprintf (stderr, "%s: unknown option \"%s\".  Try \"-help\".\n",
		   blurb(), s);

	  if (s[0] == '-' && s[1] == '-') s++;
	  if (!strcmp (s, "-activate") ||
	      !strcmp (s, "-deactivate") ||
	      !strcmp (s, "-cycle") ||
	      !strcmp (s, "-next") ||
	      !strcmp (s, "-prev") ||
	      !strcmp (s, "-exit") ||
	      !strcmp (s, "-restart") ||
	      !strcmp (s, "-demo") ||
	      !strcmp (s, "-prefs") ||
	      !strcmp (s, "-preferences") ||
	      !strcmp (s, "-lock") ||
	      !strcmp (s, "-version") ||
	      !strcmp (s, "-time"))
	    {

	      if (!strcmp (s, "-demo") || !strcmp (s, "-prefs"))
		fprintf (stderr, "\n\
    Perhaps you meant to run the `xscreensaver-demo' program instead?\n");
	      else
		fprintf (stderr, "\n\
    However, `%s' is an option to the `xscreensaver-command' program.\n", s);

	      fprintf (stderr, "\
    The `xscreensaver' program is a daemon that runs in the background.\n\
    You control a running xscreensaver process by sending it messages\n\
    with `xscreensaver-demo' or `xscreensaver-command'.\n\
.   See the man pages for details, or check the web page:\n\
    https://www.jwz.org/xscreensaver/\n\n");
	    }

	  exit (1);
	}
    }
}


/* Print out the xscreensaver banner to the tty if applicable;
   Issue any other warnings that are called for at this point.
 */
static void
print_banner (saver_info *si)
{
  saver_preferences *p = &si->prefs;

  char *s, year[5];
  s = strchr (screensaver_id, '-');
  s = strrchr (s, '-');
  s++;
  strncpy (year, s, 4);
  year[4] = 0;

  /* This resource gets set some time before the others, so that we know
     whether to print the banner (and so that the banner gets printed before
     any resource-database-related error messages.)
   */
  p->verbose_p = (p->debug_p || 
                  get_boolean_resource (si->dpy, "verbose", "Boolean"));

  /* Ditto, for the locking_disabled_p message. */
  p->lock_p = get_boolean_resource (si->dpy, "lock", "Boolean");

  if (p->verbose_p)
    fprintf (stderr,
	     "%s %s, copyright (c) 1991-%s "
	     "by Jamie Zawinski <jwz@jwz.org>.\n",
	     progname, si->version, year);

  if (p->debug_p)
    fprintf (stderr, "\n"
	     "%s: Warning: running in DEBUG MODE.  Be afraid.\n"
	     "\n"
	     "\tNote that in debug mode, the xscreensaver window will only\n"
	     "\tcover the left half of the screen.  (The idea is that you\n"
	     "\tcan still see debugging output in a shell, if you position\n"
	     "\tit on the right side of the screen.)\n"
	     "\n"
	     "\tDebug mode is NOT SECURE.  Do not run with -debug in\n"
	     "\tuntrusted environments.\n"
	     "\n",
	     blurb());

  if (p->verbose_p && senesculent_p ())
    fprintf (stderr, "\n"
             "*************************************"
             "**************************************\n"
	     "%s: Warning: this version of xscreensaver is VERY OLD!\n"
	     "%s: Please upgrade!  https://www.jwz.org/xscreensaver/\n"
             "*************************************"
             "**************************************\n"
	     "\n",
             blurb(), blurb());

  if (p->verbose_p)
    {
      if (!si->uid_message || !*si->uid_message)
	describe_uids (si, stderr);
      else
	{
	  if (si->orig_uid && *si->orig_uid)
	    fprintf (stderr, "%s: initial effective uid/gid was %s.\n",
		     blurb(), si->orig_uid);
	  fprintf (stderr, "%s: %s\n", blurb(), si->uid_message);
	}

      fprintf (stderr, "%s: in process %lu.\n", blurb(),
	       (unsigned long) getpid());
    }
}

static void
print_lock_failure_banner (saver_info *si)
{
  saver_preferences *p = &si->prefs;

  /* If locking was not able to be initalized for some reason, explain why.
     (This has to be done after we've read the lock_p resource.)
   */
  if (si->locking_disabled_p)
    {
      p->lock_p = False;
      fprintf (stderr, "%s: locking is disabled (%s).\n", blurb(),
	       si->nolock_reason);
      if (strstr (si->nolock_reason, "passw"))
	fprintf (stderr, "%s: does xscreensaver need to be setuid?  "
		 "consult the manual.\n", blurb());
      else if (strstr (si->nolock_reason, "running as "))
	fprintf (stderr, 
		 "%s: locking only works when xscreensaver is launched\n"
		 "\t by a normal, non-privileged user (e.g., not \"root\".)\n"
		 "\t See the manual for details.\n",
		 blurb());
    }

}


/* called from screens.c so that all the Xt crud is here. */
void
initialize_screen_root_widget (saver_screen_info *ssi)
{
  saver_info *si = ssi->global;
  if (ssi->toplevel_shell)
    XtDestroyWidget (ssi->toplevel_shell);
  ssi->toplevel_shell =
    XtVaAppCreateShell (progname, progclass, 
                        applicationShellWidgetClass,
                        si->dpy,
                        XtNscreen, ssi->screen,
                        XtNvisual, ssi->current_visual,
                        XtNdepth,  visual_depth (ssi->screen,
                                                 ssi->current_visual),
                        NULL);
}


/* Examine all of the display's screens, and populate the `saver_screen_info'
   structures.  Make sure this is called after hack_environment() sets $PATH.
 */
static void
initialize_per_screen_info (saver_info *si, Widget toplevel_shell)
{
  int i;

  update_screen_layout (si);

  /* Check to see whether fading is ever possible -- if any of the
     screens on the display has a PseudoColor visual, then fading can
     work (on at least some screens.)  If no screen has a PseudoColor
     visual, then don't bother ever trying to fade, because it will
     just cause a delay without causing any visible effect.
   */
  for (i = 0; i < si->nscreens; i++)
    {
      saver_screen_info *ssi = &si->screens[i];
      if (has_writable_cells (ssi->screen, ssi->current_visual) ||
          get_visual (ssi->screen, "PseudoColor", True, False) ||
          get_visual (ssi->screen, "GrayScale", True, False))
        {
          si->fading_possible_p = True;
          break;
        }
    }

#ifdef HAVE_XF86VMODE_GAMMA
  si->fading_possible_p = True;  /* if we can gamma fade, go for it */
#endif
}


/* If any server extensions have been requested, try and initialize them.
   Issue warnings if requests can't be honored.
 */
static void
initialize_server_extensions (saver_info *si)
{
  saver_preferences *p = &si->prefs;

  Bool server_has_xidle_extension_p = False;
  Bool server_has_sgi_saver_extension_p = False;
  Bool server_has_mit_saver_extension_p = False;
  Bool system_has_proc_interrupts_p = False;
  Bool server_has_xinput_extension_p = False;
  const char *piwhy = 0;

  si->using_xidle_extension = p->use_xidle_extension;
  si->using_sgi_saver_extension = p->use_sgi_saver_extension;
  si->using_mit_saver_extension = p->use_mit_saver_extension;
  si->using_proc_interrupts = p->use_proc_interrupts;
  si->using_xinput_extension = p->use_xinput_extension;

#ifdef HAVE_XIDLE_EXTENSION
  {
    int ev, er;
    server_has_xidle_extension_p = XidleQueryExtension (si->dpy, &ev, &er);
  }
#endif
#ifdef HAVE_SGI_SAVER_EXTENSION
  server_has_sgi_saver_extension_p =
    XScreenSaverQueryExtension (si->dpy,
                                &si->sgi_saver_ext_event_number,
                                &si->sgi_saver_ext_error_number);
#endif
#ifdef HAVE_MIT_SAVER_EXTENSION
  server_has_mit_saver_extension_p =
    XScreenSaverQueryExtension (si->dpy,
                                &si->mit_saver_ext_event_number,
                                &si->mit_saver_ext_error_number);
#endif
#ifdef HAVE_PROC_INTERRUPTS
  system_has_proc_interrupts_p = query_proc_interrupts_available (si, &piwhy);
#endif

#ifdef HAVE_XINPUT
  server_has_xinput_extension_p = query_xinput_extension (si);
#endif

  if (!server_has_xidle_extension_p)
    si->using_xidle_extension = False;
  else if (p->verbose_p)
    {
      if (si->using_xidle_extension)
	fprintf (stderr, "%s: using XIDLE extension.\n", blurb());
      else
	fprintf (stderr, "%s: not using server's XIDLE extension.\n", blurb());
    }

  if (!server_has_sgi_saver_extension_p)
    si->using_sgi_saver_extension = False;
  else if (p->verbose_p)
    {
      if (si->using_sgi_saver_extension)
	fprintf (stderr, "%s: using SGI SCREEN_SAVER extension.\n", blurb());
      else
	fprintf (stderr,
		 "%s: not using server's SGI SCREEN_SAVER extension.\n",
		 blurb());
    }

  if (!server_has_mit_saver_extension_p)
    si->using_mit_saver_extension = False;
  else if (p->verbose_p)
    {
      if (si->using_mit_saver_extension)
	fprintf (stderr, "%s: using lame MIT-SCREEN-SAVER extension.\n",
		 blurb());
      else
	fprintf (stderr,
		 "%s: not using server's lame MIT-SCREEN-SAVER extension.\n",
		 blurb());
    }

#ifdef HAVE_RANDR
  if (XRRQueryExtension (si->dpy,
                         &si->randr_event_number, &si->randr_error_number))
    {
      int nscreens = ScreenCount (si->dpy);  /* number of *real* screens */
      int i;

      si->using_randr_extension = TRUE;

      if (p->verbose_p)
	fprintf (stderr, "%s: selecting RANDR events\n", blurb());
      for (i = 0; i < nscreens; i++)
#  ifdef RRScreenChangeNotifyMask                 /* randr.h 1.5, 2002/09/29 */
        XRRSelectInput (si->dpy, RootWindow (si->dpy, i),
                        RRScreenChangeNotifyMask);
#  else  /* !RRScreenChangeNotifyMask */          /* Xrandr.h 1.4, 2001/06/07 */
        XRRScreenChangeSelectInput (si->dpy, RootWindow (si->dpy, i), True);
#  endif /* !RRScreenChangeNotifyMask */
    }
# endif /* HAVE_RANDR */

#ifdef HAVE_XINPUT
  if (!server_has_xinput_extension_p)
    si->using_xinput_extension = False;
  else
    {
      if (si->using_xinput_extension)
        init_xinput_extension(si);

      if (p->verbose_p)
        {
          if (si->using_xinput_extension)
            fprintf (stderr,
                     "%s: selecting events from %d XInputExtension devices.\n",
                     blurb(), si->num_xinput_devices);
          else
            fprintf (stderr,
                     "%s: not using XInputExtension.\n",
                     blurb());
        }
    }
#endif

  if (!system_has_proc_interrupts_p)
    {
      si->using_proc_interrupts = False;
      if (p->verbose_p && piwhy)
	fprintf (stderr, "%s: not using /proc/interrupts: %s.\n", blurb(),
                 piwhy);
    }
  else if (p->verbose_p)
    {
      if (si->using_proc_interrupts)
	fprintf (stderr,
                 "%s: consulting /proc/interrupts for keyboard activity.\n",
		 blurb());
      else
	fprintf (stderr,
                "%s: not consulting /proc/interrupts for keyboard activity.\n",
		 blurb());
    }
}


#ifdef DEBUG_MULTISCREEN
static void
debug_multiscreen_timer (XtPointer closure, XtIntervalId *id)
{
  saver_info *si = (saver_info *) closure;
  saver_preferences *p = &si->prefs;
  if (update_screen_layout (si))
    {
      if (p->verbose_p)
        {
          fprintf (stderr, "%s: new layout:\n", blurb());
          describe_monitor_layout (si);
        }
      resize_screensaver_window (si);
    }
  XtAppAddTimeOut (si->app, 1000*4, debug_multiscreen_timer, (XtPointer) si);
}
#endif /* DEBUG_MULTISCREEN */


/* For the case where we aren't using an server extensions, select user events
   on all the existing windows, and launch timers to select events on
   newly-created windows as well.

   If a server extension is being used, this does nothing.
 */
static void
select_events (saver_info *si)
{
  saver_preferences *p = &si->prefs;
  int i;

  if (si->using_xidle_extension ||
      si->using_mit_saver_extension ||
      si->using_sgi_saver_extension)
    return;

  if (p->initial_delay)
    {
      if (p->verbose_p)
	{
	  fprintf (stderr, "%s: waiting for %d second%s...", blurb(),
		   (int) p->initial_delay/1000,
		   (p->initial_delay == 1000 ? "" : "s"));
	  fflush (stderr);
	  fflush (stdout);
	}
      usleep (p->initial_delay);
      if (p->verbose_p)
	fprintf (stderr, " done.\n");
    }

  if (p->verbose_p)
    {
      fprintf (stderr, "%s: selecting events on extant windows...", blurb());
      fflush (stderr);
      fflush (stdout);
    }

  /* Select events on the root windows of every screen.  This also selects
     for window creation events, so that new subwindows will be noticed.
   */
  for (i = 0; i < si->nscreens; i++)
    {
      saver_screen_info *ssi = &si->screens[i];
      if (ssi->real_screen_p)
        start_notice_events_timer (si,
           RootWindowOfScreen (si->screens[i].screen), False);
    }

  if (p->verbose_p)
    fprintf (stderr, " done.\n");

# ifdef DEBUG_MULTISCREEN
  if (p->debug_p) debug_multiscreen_timer ((XtPointer) si, 0);
# endif
}


void
maybe_reload_init_file (saver_info *si)
{
  saver_preferences *p = &si->prefs;
  if (init_file_changed_p (p))
    {
      if (p->verbose_p)
	fprintf (stderr, "%s: file \"%s\" has changed, reloading.\n",
		 blurb(), init_file_name());

      load_init_file (si->dpy, p);

      /* If a server extension is in use, and p->timeout has changed,
	 we need to inform the server of the new timeout. */
      disable_builtin_screensaver (si, False);

      /* If the DPMS settings in the init file have changed,
         change the settings on the server to match. */
      sync_server_dpms_settings (si->dpy,
                                 (p->dpms_enabled_p  &&
                                  p->mode != DONT_BLANK),
                                 p->dpms_quickoff_p,
                                 p->dpms_standby / 1000,
                                 p->dpms_suspend / 1000,
                                 p->dpms_off / 1000,
                                 False);
    }
}


/* Loop forever:

       - wait until the user is idle;
       - blank the screen;
       - wait until the user is active;
       - unblank the screen;
       - repeat.

 */
static void
main_loop (saver_info *si)
{
  saver_preferences *p = &si->prefs;
  Bool ok_to_unblank;
  int i;

  while (1)
    {
      Bool was_locked = False;

      if (p->verbose_p)
	fprintf (stderr, "%s: awaiting idleness.\n", blurb());

      check_for_leaks ("unblanked A");
      sleep_until_idle (si, True);
      check_for_leaks ("unblanked B");

      if (p->verbose_p)
	{
	  if (si->demoing_p)
	    fprintf (stderr, "%s: demoing %d at %s.\n", blurb(),
		     si->selection_mode, timestring(0));
	  else
            fprintf (stderr, "%s: blanking screen at %s.\n", blurb(),
                     timestring(0));
	}

      maybe_reload_init_file (si);

      /* Treat DONT_BLANK as BLANK_ONLY in emergency-lock when locking
         is enabled. */

      if (p->mode == DONT_BLANK &&
          (!si->emergency_lock_p ||
           !p->lock_p ||
           si->locking_disabled_p))
        {
          if (p->verbose_p)
            fprintf (stderr, "%s: idle with blanking disabled at %s.\n",
                     blurb(), timestring(0));

          /* Go around the loop and wait for the next bout of idleness,
             or for the init file to change, or for a remote command to
             come in, or something.

             But, if locked_p is true, go ahead.  This can only happen
             if we're in "disabled" mode but a "lock" clientmessage came
             in: in that case, we should go ahead and blank/lock the screen.
           */
          if (!si->locked_p)
            continue;
        }

      /* Since we're about to blank the screen, kill the de-race timer,
         if any.  It might still be running if we have unblanked and then
         re-blanked in a short period (e.g., when using the "next" button
         in xscreensaver-demo.)
       */
      if (si->de_race_id)
        {
          if (p->verbose_p)
            fprintf (stderr, "%s: stopping de-race timer (%d remaining.)\n",
                     blurb(), si->de_race_ticks);
          XtRemoveTimeOut (si->de_race_id);
          si->de_race_id = 0;
        }


      /* Now, try to blank.
       */

      if (! blank_screen (si))
        {
          /* We were unable to grab either the keyboard or mouse.
             This means we did not (and must not) blank the screen.
             If we were to blank the screen while some other program
             is holding both the mouse and keyboard grabbed, then
             we would never be able to un-blank it!  We would never
             see any events, and the display would be wedged.

             In particular, without that keyboard grab, we will be
             unable to ever read keypresses on the unlock dialog.
             You can't unlock if you can't type your password.

             So, just go around the loop again and wait for the
             next bout of idleness.  (If the user remains idle, we
             will next try to blank the screen again in no more than
             60 seconds.)
          */
          Time retry = 60 * 1000;
          if (p->timeout < retry)
            retry = p->timeout;

          if (p->debug_p)
            {
              fprintf (stderr,
                  "%s: DEBUG MODE: unable to grab -- BLANKING ANYWAY.\n",
                       blurb());
            }
          else
            {
              fprintf (stderr,
                  "%s: unable to grab keyboard or mouse!  Blanking aborted.\n",
                       blurb());

              /* Since we were unable to blank, clearly we're not locked,
                 but we might have been prematurely marked as locked by
                 the LOCK ClientMessage. */
              if (si->locked_p)
                set_locked_p (si, False);

              schedule_wakeup_event (si, retry, p->debug_p);
              continue;
            }
        }

      for (i = 0; i < si->nscreens; i++)
        kill_screenhack (&si->screens[i]);

      raise_window (si, True, True, False);
      if (si->throttled_p)
        fprintf (stderr, "%s: not launching hack (throttled.)\n", blurb());
      else
        for (i = 0; i < si->nscreens; i++)
          spawn_screenhack (&si->screens[i]);

      /* If we are blanking only, optionally power down monitor right now. */
      if (p->mode == BLANK_ONLY &&
          p->dpms_enabled_p && 
          p->dpms_quickoff_p)
        {
          /* Sync again just in case */
          sync_server_dpms_settings (si->dpy, True,
                                     p->dpms_quickoff_p,
                                     p->dpms_standby / 1000,
                                     p->dpms_suspend / 1000,
                                     p->dpms_off / 1000,
                                     False);
          monitor_power_on (si, False);
        }

      /* Don't start the cycle timer in demo mode. */
      if (!si->demoing_p && p->cycle)
	si->cycle_id = XtAppAddTimeOut (si->app,
                                        (si->selection_mode
                                         /* see comment in cycle_timer() */
                                         ? 1000 * 60 * 60
                                         : p->cycle),
                                        cycle_timer,
					(XtPointer) si);


#ifndef NO_LOCKING
      /* Maybe start locking the screen.
       */
      {
        Time lock_timeout = p->lock_timeout;

        /* If we're fading, don't lock until the fade finishes. */
        if (si->fading_possible_p && p->fade_p)
          lock_timeout += p->fade_seconds / 1000;

        if (si->emergency_lock_p)
          lock_timeout = 0;

        if (si->emergency_lock_p && p->lock_p && lock_timeout)
          {
            int secs = p->lock_timeout / 1000;
            if (p->verbose_p)
              fprintf (stderr,
                     "%s: locking now, instead of waiting for %d:%02d:%02d.\n",
                       blurb(),
                       (secs / (60 * 60)), ((secs / 60) % 60), (secs % 60));
            lock_timeout = 0;
          }

        si->emergency_lock_p = False;

        if (!si->demoing_p &&           /* if not going into demo mode */
            p->lock_p &&                /* and locking is enabled */
            !si->locking_disabled_p &&  /* and locking is possible */
            lock_timeout == 0)          /* and locking is not timer-deferred */
          set_locked_p (si, True);      /* then lock right now. */

        /* locked_p might be true already because of the above, or because of
           the LOCK ClientMessage.  But if not, and if we're supposed to lock
           after some time, set up a timer to do so.
        */
        if (p->lock_p &&
            !si->locked_p &&
            lock_timeout > 0)
          si->lock_id = XtAppAddTimeOut (si->app, lock_timeout,
                                         activate_lock_timer,
                                         (XtPointer) si);
      }
#endif /* !NO_LOCKING */


      ok_to_unblank = True;
      do {

        check_for_leaks ("blanked A");
	sleep_until_idle (si, False);		/* until not idle */
        check_for_leaks ("blanked B");

	maybe_reload_init_file (si);

#ifndef NO_LOCKING
        /* Maybe unlock the screen.
         */
	if (si->locked_p)
	  {
	    saver_screen_info *ssi = si->default_screen;
	    if (si->locking_disabled_p) abort ();

            was_locked = True;
	    si->dbox_up_p = True;
            for (i = 0; i < si->nscreens; i++)
              suspend_screenhack (&si->screens[i], True);	  /* suspend */
	    XUndefineCursor (si->dpy, ssi->screensaver_window);

	    ok_to_unblank = unlock_p (si);

	    si->dbox_up_p = False;
	    XDefineCursor (si->dpy, ssi->screensaver_window, ssi->cursor);
            for (i = 0; i < si->nscreens; i++)
              suspend_screenhack (&si->screens[i], False);	   /* resume */

            if (!ok_to_unblank &&
                !screenhack_running_p (si))
              {
                /* If the lock dialog has been dismissed and we're not about to
                   unlock the screen, and there is currently no hack running,
                   then launch one.  (There might be no hack running if DPMS
                   had kicked in.  But DPMS is off now, so bring back the hack)
                 */
                if (si->cycle_id)
                  XtRemoveTimeOut (si->cycle_id);
                si->cycle_id = 0;
                cycle_timer ((XtPointer) si, 0);
              }

            /* If we are blanking only, optionally power down monitor
               right now: quickoff means power down monitor again as soon
               as unlock dialog is dismissed without unlocking. */
            if (!ok_to_unblank &&
                p->mode == BLANK_ONLY &&
                p->dpms_enabled_p && 
                p->dpms_quickoff_p)
              {
                /* Sync again just in case */
                sync_server_dpms_settings (si->dpy, True,
                                           p->dpms_quickoff_p,
                                           p->dpms_standby / 1000,
                                           p->dpms_suspend / 1000,
                                           p->dpms_off / 1000,
                                           False);
                monitor_power_on (si, False);
              }
	  }
#endif /* !NO_LOCKING */

	} while (!ok_to_unblank);


      if (p->verbose_p)
	fprintf (stderr, "%s: unblanking screen at %s.\n",
		 blurb(), timestring (0));

      /* Kill before unblanking, to stop drawing as soon as possible. */
      for (i = 0; i < si->nscreens; i++)
        kill_screenhack (&si->screens[i]);
      unblank_screen (si);

      set_locked_p (si, False);
      si->emergency_lock_p = False;
      si->demoing_p = 0;
      si->selection_mode = 0;

      /* If we're throttled, and the user has explicitly unlocked the screen,
         then unthrottle.  If we weren't locked, then don't unthrottle
         automatically, because someone might have just bumped the desk... */
      if (was_locked)
        {
          if (si->throttled_p && p->verbose_p)
            fprintf (stderr, "%s: unthrottled.\n", blurb());
          si->throttled_p = False;
        }

      if (si->cycle_id)
	{
	  XtRemoveTimeOut (si->cycle_id);
	  si->cycle_id = 0;
	}

      if (si->lock_id)
	{
	  XtRemoveTimeOut (si->lock_id);
	  si->lock_id = 0;
	}

# ifdef HAVE_LIBSYSTEMD
      /* This might be a good spot to re-launch si->systemd_pid
         if it has died unexpectedly. Which shouldn't happen. */
# endif

      /* Since we're unblanked now, break race conditions and make
         sure we stay that way (see comment in timers.c.) */
      if (! si->de_race_id)
        de_race_timer ((XtPointer) si, 0);
    }
}

static void analyze_display (saver_info *si);
static void fix_fds (void);

int
main (int argc, char **argv)
{
  Widget shell;
  saver_info the_si;
  saver_info *si = &the_si;
  saver_preferences *p = &si->prefs;
  struct passwd *spasswd;
  Bool inhibit_stderr_capture_p = False;
  int i;

  /* It turns out that if we do setlocale (LC_ALL, "") here, people
     running in Japanese locales get font craziness on the password
     dialog, presumably because it is displaying Japanese characters
     in a non-Japanese font.  However, if we don't call setlocale()
     at all, then XLookupString() never returns multi-byte UTF-8
     characters when people type non-Latin1 characters on the
     keyboard.

     The current theory (and at this point, I'm really guessing!) is
     that using LC_CTYPE instead of LC_ALL will make XLookupString()
     behave usefully, without having the side-effect of screwing up
     the fonts on the unlock dialog.

     See https://bugs.launchpad.net/ubuntu/+source/xscreensaver/+bug/671923
     from comment #20 onward.

       -- jwz, 24-Sep-2011
   */
#ifdef ENABLE_NLS
  if (!setlocale (LC_CTYPE, ""))
    fprintf (stderr, "%s: warning: could not set default locale\n",
             progname);

  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
  textdomain (GETTEXT_PACKAGE);
#endif /* ENABLE_NLS */

  memset(si, 0, sizeof(*si));
  global_si_kludge = si;	/* I hate C so much... */

  fix_fds();

# undef ya_rand_init
  ya_rand_init (0);

  save_argv (argc, argv);
  set_version_string (si, &argc, argv);
  privileged_initialization (si, &argc, argv);
  hack_environment (si);

  spasswd = getpwuid(getuid());
  if (!spasswd)
    {
      fprintf(stderr, "Could not figure out who the current user is!\n");
      return 1;
    }

  si->user = strdup(spasswd->pw_name ? spasswd->pw_name : "(unknown)");

# ifndef NO_LOCKING
  si->unlock_cb = gui_auth_conv;
  si->auth_finished_cb = auth_finished_cb;
# endif /* !NO_LOCKING */

  shell = connect_to_server (si, &argc, argv);
  process_command_line (si, &argc, argv);
  inhibit_stderr_capture_p = stderr_log_file (si);
  print_banner (si);

  load_init_file(si->dpy, p); /* must be before initialize_per_screen_info() */

  if (inhibit_stderr_capture_p && !p->verbose_p)
    p->verbose_p = 1;  /* "-log" implies "-verbose -no-capture-stderr" */

  blurb_timestamp_p = p->timestamp_p;  /* kludge */
  initialize_per_screen_info (si, shell); /* also sets si->fading_possible_p */

  /* We can only issue this warning now. */
  if (p->verbose_p && !si->fading_possible_p && (p->fade_p || p->unfade_p))
    fprintf (stderr,
             "%s: there are no PseudoColor or GrayScale visuals.\n"
             "%s: ignoring the request for fading/unfading.\n",
             blurb(), blurb());

  for (i = 0; i < si->nscreens; i++)
    {
      saver_screen_info *ssi = &si->screens[i];
      if (ssi->real_screen_p)
        if (ensure_no_screensaver_running (si->dpy, si->screens[i].screen))
          exit (1);
      ssi->current_hack = -1;
    }

  lock_initialization (si, &argc, argv);
  print_lock_failure_banner (si);

  if (p->xsync_p) XSynchronize (si->dpy, True);

  if (p->verbose_p) analyze_display (si);
  initialize_server_extensions (si);

  si->blank_time = time ((time_t *) 0); /* must be before ..._window */
  initialize_screensaver_window (si);

  select_events (si);
  init_sigchld ();

  disable_builtin_screensaver (si, True);
  sync_server_dpms_settings (si->dpy,
                             (p->dpms_enabled_p  &&
                              p->mode != DONT_BLANK),
                             p->dpms_quickoff_p,
                             p->dpms_standby / 1000,
                             p->dpms_suspend / 1000,
                             p->dpms_off / 1000,
                             False);

  initialize_stderr (si, inhibit_stderr_capture_p);
  handle_signals (si);

  store_saver_status (si);	/* for xscreensaver-command -status */

# ifdef HAVE_LIBSYSTEMD   /* Launch it in the background */
  {
    const char *cmd = (p->verbose_p
                       ? "xscreensaver-systemd -verbose"
                       : "xscreensaver-systemd");
    si->systemd_pid = fork_and_exec_1 (si, 0, cmd);
  }
# endif

  make_splash_dialog (si);

  main_loop (si);		/* doesn't return */
  return 0;
}

static void
fix_fds (void)
{
  /* Bad Things Happen if stdin, stdout, and stderr have been closed
     (as by the `sh incantation "xscreensaver >&- 2>&-").  When you do
     that, the X connection gets allocated to one of these fds, and
     then some random library writes to stderr, and random bits get
     stuffed down the X pipe, causing "Xlib: sequence lost" errors.
     So, we cause the first three file descriptors to be open to
     /dev/null if they aren't open to something else already.  This
     must be done before any other files are opened (or the closing
     of that other file will again free up one of the "magic" first
     three FDs.)

     We do this by opening /dev/null three times, and then closing
     those fds, *unless* any of them got allocated as #0, #1, or #2,
     in which case we leave them open.  Gag.

     Really, this crap is technically required of *every* X program,
     if you want it to be robust in the face of "2>&-".
   */
  int fd0 = open ("/dev/null", O_RDWR);
  int fd1 = open ("/dev/null", O_RDWR);
  int fd2 = open ("/dev/null", O_RDWR);
  if (fd0 > 2) close (fd0);
  if (fd1 > 2) close (fd1);
  if (fd2 > 2) close (fd2);
}



/* Processing ClientMessage events.
 */


static Bool error_handler_hit_p = False;

static int
ignore_all_errors_ehandler (Display *dpy, XErrorEvent *error)
{
  error_handler_hit_p = True;
  return 0;
}

/* Sometimes some systems send us ClientMessage events with bogus atoms in
   them.  We only look up the atom names for printing warning messages,
   so don't bomb out when it happens...
 */
static char *
XGetAtomName_safe (Display *dpy, Atom atom)
{
  char *result;
  XErrorHandler old_handler;
  if (!atom) return 0;

  XSync (dpy, False);
  error_handler_hit_p = False;
  old_handler = XSetErrorHandler (ignore_all_errors_ehandler);
  result = XGetAtomName (dpy, atom);
  XSync (dpy, False);
  XSetErrorHandler (old_handler);
  XSync (dpy, False);
  if (error_handler_hit_p) result = 0;

  if (result)
    return result;
  else
    {
      char buf[100];
      sprintf (buf, "<<undefined atom 0x%04X>>", (unsigned int) atom);
      return strdup (buf);
    }
}


void
clientmessage_response (saver_info *si, Window w, Bool error,
			const char *stderr_msg,
			const char *protocol_msg)
{
  char *proto;
  int L;
  saver_preferences *p = &si->prefs;
  XErrorHandler old_handler;

  if (error || p->verbose_p)
    fprintf (stderr, "%s: %s\n", blurb(), stderr_msg);

  L = strlen(protocol_msg);
  proto = (char *) malloc (L + 2);
  proto[0] = (error ? '-' : '+');
  strcpy (proto+1, protocol_msg);
  L++;

  /* Ignore all X errors while sending a response to a ClientMessage.
     Pretty much the only way we could get an error here is if the
     window we're trying to send the reply on has been deleted, in
     which case, the sender of the ClientMessage won't see our response
     anyway.
   */
  XSync (si->dpy, False);
  error_handler_hit_p = False;
  old_handler = XSetErrorHandler (ignore_all_errors_ehandler);

  XChangeProperty (si->dpy, w, XA_SCREENSAVER_RESPONSE, XA_STRING, 8,
		   PropModeReplace, (unsigned char *) proto, L);

  XSync (si->dpy, False);
  XSetErrorHandler (old_handler);
  XSync (si->dpy, False);

  free (proto);
}


static void
bogus_clientmessage_warning (saver_info *si, XEvent *event)
{
#if 0  /* Oh, fuck it.  GNOME likes to spew random ClientMessages at us
          all the time.  This is presumably indicative of an error in
          the sender of that ClientMessage: if we're getting it and 
          ignoring it, then it's not reaching the intended recipient.
          But people complain to me about this all the time ("waaah!
          xscreensaver is printing to it's stderr and that gets my
          panties all in a bunch!")  And I'm sick of hearing about it.
          So we'll just ignore these messages and let GNOME go right
          ahead and continue to stumble along in its malfunction.
        */

  saver_preferences *p = &si->prefs;
  char *str = XGetAtomName_safe (si->dpy, event->xclient.message_type);
  Window w = event->xclient.window;
  char wdesc[255];
  int screen = 0;
  Bool root_p = False;

  *wdesc = 0;
  for (screen = 0; screen < si->nscreens; screen++)
    if (w == si->screens[screen].screensaver_window)
      {
        strcpy (wdesc, "xscreensaver");
        break;
      }
    else if (w == RootWindow (si->dpy, screen))
      {
        strcpy (wdesc, "root");
        root_p = True;
        break;
      }

  /* If this ClientMessage was sent to the real root window instead of to the
     xscreensaver window, then it might be intended for someone else who is
     listening on the root window (e.g., the window manager).  So only print
     the warning if: we are in debug mode; or if the bogus message was
     actually sent to one of the xscreensaver-created windows.
   */
  if (root_p && !p->debug_p)
    return;

  if (!*wdesc)
    {
      XErrorHandler old_handler;
      XClassHint hint;
      XWindowAttributes xgwa;
      memset (&hint, 0, sizeof(hint));
      memset (&xgwa, 0, sizeof(xgwa));

      XSync (si->dpy, False);
      old_handler = XSetErrorHandler (ignore_all_errors_ehandler);
      XGetClassHint (si->dpy, w, &hint);
      XGetWindowAttributes (si->dpy, w, &xgwa);
      XSync (si->dpy, False);
      XSetErrorHandler (old_handler);
      XSync (si->dpy, False);

      screen = (xgwa.screen ? screen_number (xgwa.screen) : -1);

      sprintf (wdesc, "%.20s / %.20s",
               (hint.res_name  ? hint.res_name  : "(null)"),
               (hint.res_class ? hint.res_class : "(null)"));
      if (hint.res_name)  XFree (hint.res_name);
      if (hint.res_class) XFree (hint.res_class);
    }

  fprintf (stderr, "%s: %d: unrecognised ClientMessage \"%s\" received\n",
           blurb(), screen, (str ? str : "(null)"));
  fprintf (stderr, "%s: %d: for window 0x%lx (%s)\n",
           blurb(), screen, (unsigned long) w, wdesc);
  if (str) XFree (str);

#endif /* 0 */
}


Bool
handle_clientmessage (saver_info *si, XEvent *event, Bool until_idle_p)
{
  saver_preferences *p = &si->prefs;
  Atom type = 0;
  Window window = event->xclient.window;

  /* Preferences might affect our handling of client messages. */
  maybe_reload_init_file (si);

  if (event->xclient.message_type != XA_SCREENSAVER ||
      event->xclient.format != 32)
    {
      bogus_clientmessage_warning (si, event);
      return False;
    }

  type = event->xclient.data.l[0];
  if (type == XA_ACTIVATE)
    {
      if (until_idle_p)
	{
          if (p->mode == DONT_BLANK)
            {
              clientmessage_response(si, window, True,
                         "ACTIVATE ClientMessage received in DONT_BLANK mode.",
                                     "screen blanking is currently disabled.");
              return False;
            }

	  clientmessage_response(si, window, False,
				 "ACTIVATE ClientMessage received.",
				 "activating.");
	  si->selection_mode = 0;
	  si->demoing_p = False;

          if (si->throttled_p && p->verbose_p)
            fprintf (stderr, "%s: unthrottled.\n", blurb());
	  si->throttled_p = False;

	  if (si->using_mit_saver_extension || si->using_sgi_saver_extension)
	    {
	      XForceScreenSaver (si->dpy, ScreenSaverActive);
	      return False;
	    }
	  else
	    {
	      return True;
	    }
	}
      clientmessage_response(si, window, True,
		       "ClientMessage ACTIVATE received while already active.",
			     "already active.");
    }
  else if (type == XA_DEACTIVATE)
    {

      /* Regardless of whether the screen saver is active, a DEACTIVATE
         message should cause the monitor to become powered on. */
      monitor_power_on (si, True);

# if 0
      /* When -deactivate is received while locked, pop up the dialog box
         instead of just ignoring it.  Some people depend on this behavior
         to be able to unlock by using e.g. a fingerprint reader without
         also having to click the mouse first.
       */
      if (si->locked_p) 
        {
          clientmessage_response(si, window, False,
              "DEACTIVATE ClientMessage received while locked: ignored.",
              "screen is locked.");
        }
      else
# endif /* 0 */
        {
          if (! until_idle_p)
            {
              if (si->throttled_p && p->verbose_p)
                fprintf (stderr, "%s: unthrottled.\n", blurb());
              si->throttled_p = False;

              clientmessage_response(si, window, False,
                                     "DEACTIVATE ClientMessage received.",
                                     "deactivating.");
              if (si->using_mit_saver_extension ||
                  si->using_sgi_saver_extension)
                {
                  XForceScreenSaver (si->dpy, ScreenSaverReset);
                  return False;
                }
              else
                {
                  return True;
                }
            }
          clientmessage_response(si, window, False,
                          "ClientMessage DEACTIVATE received while inactive: "
                          "resetting idle timer.",
                                 "not active: idle timer reset.");
          reset_timers (si);
        }
    }
  else if (type == XA_SUSPEND)
    {
      clientmessage_response(si, window, False,
                             "SUSPEND ClientMessage received.",
                             "suspending.");
      si->selection_mode = 0;
      si->demoing_p = False;
      si->throttled_p = True;

      /* When suspending, immediately lock, if locking enabled. */
# ifndef NO_LOCKING
      if (p->lock_p && !si->locked_p && !si->locking_disabled_p)
        {
          si->emergency_lock_p = True;
          if (p->verbose_p)
            fprintf (stderr, "%s: locking.\n", blurb());
          set_locked_p (si, True);
        }
# endif

      /* When suspending, immediately power off the display. */
      monitor_power_on (si, False);

      if (until_idle_p)
        return True;    /* Blank now */
      else
        return False;   /* Do not unblank now */
    }
  else if (type == XA_CYCLE)
    {
      if (! until_idle_p)
	{
	  clientmessage_response(si, window, False,
				 "CYCLE ClientMessage received.",
				 "cycling.");
	  si->selection_mode = 0;	/* 0 means randomize when its time. */
	  si->demoing_p = False;

          if (si->throttled_p && p->verbose_p)
            fprintf (stderr, "%s: unthrottled.\n", blurb());
	  si->throttled_p = False;

	  if (si->cycle_id)
	    XtRemoveTimeOut (si->cycle_id);
	  si->cycle_id = 0;
	  cycle_timer ((XtPointer) si, 0);
	  return False;
	}
      clientmessage_response(si, window, True,
			     "ClientMessage CYCLE received while inactive.",
			     "not active.");
    }
  else if (type == XA_NEXT || type == XA_PREV)
    {
      clientmessage_response(si, window, False,
			     (type == XA_NEXT
			      ? "NEXT ClientMessage received."
			      : "PREV ClientMessage received."),
			     "cycling.");
      si->selection_mode = (type == XA_NEXT ? -1 : -2);
      si->demoing_p = False;

      if (si->throttled_p && p->verbose_p)
        fprintf (stderr, "%s: unthrottled.\n", blurb());
      si->throttled_p = False;

      if (! until_idle_p)
	{
	  if (si->cycle_id)
	    XtRemoveTimeOut (si->cycle_id);
	  si->cycle_id = 0;
	  cycle_timer ((XtPointer) si, 0);
	}
      else
	return True;
    }
  else if (type == XA_SELECT)
    {
      char buf [255];
      char buf2 [255];
      long which = event->xclient.data.l[1];

      if (p->mode == DONT_BLANK)
        {
          clientmessage_response(si, window, True,
                           "SELECT ClientMessage received in DONT_BLANK mode.",
                                 "screen blanking is currently disabled.");
          return False;
        }

      sprintf (buf, "SELECT %ld ClientMessage received.", which);
      sprintf (buf2, "activating (%ld).", which);
      clientmessage_response (si, window, False, buf, buf2);

      if (which < 0) which = 0;		/* 0 == "random" */
      si->selection_mode = which;
      si->demoing_p = False;

      if (si->throttled_p && p->verbose_p)
        fprintf (stderr, "%s: unthrottled.\n", blurb());
      si->throttled_p = False;

      if (! until_idle_p)
	{
	  if (si->cycle_id)
	    XtRemoveTimeOut (si->cycle_id);
	  si->cycle_id = 0;
	  cycle_timer ((XtPointer) si, 0);
	}
      else
	return True;
    }
  else if (type == XA_EXIT)
    {
      /* Ignore EXIT message if the screen is locked. */
      if (until_idle_p || !si->locked_p)
	{
	  clientmessage_response (si, window, False,
				  "EXIT ClientMessage received.",
				  "exiting.");
	  if (! until_idle_p)
	    {
              int i;
              for (i = 0; i < si->nscreens; i++)
                kill_screenhack (&si->screens[i]);
	      unblank_screen (si);
	      XSync (si->dpy, False);
	    }
	  saver_exit (si, 0, 0);
	}
      else
	clientmessage_response (si, window, True,
				"EXIT ClientMessage received while locked.",
				"screen is locked.");
    }
  else if (type == XA_RESTART)
    {
      /* The RESTART message works whether the screensaver is active or not,
	 unless the screen is locked, in which case it doesn't work.
       */
      if (until_idle_p || !si->locked_p)
	{
	  clientmessage_response (si, window, False,
				  "RESTART ClientMessage received.",
				  "restarting.");
	  if (! until_idle_p)
	    {
              int i;
              for (i = 0; i < si->nscreens; i++)
                kill_screenhack (&si->screens[i]);
	      unblank_screen (si);
	      XSync (si->dpy, False);
	    }

	  restart_process (si);  /* does not return */
          abort();
	}
      else
	clientmessage_response (si, window, True,
				"RESTART ClientMessage received while locked.",
				"screen is locked.");
    }
  else if (type == XA_DEMO)
    {
      long arg = event->xclient.data.l[1];
      Bool demo_one_hack_p = (arg == 5000);

      if (demo_one_hack_p)
	{
	  if (until_idle_p)
	    {
	      long which = event->xclient.data.l[2];
	      char buf [255];
	      char buf2 [255];
	      sprintf (buf, "DEMO %ld ClientMessage received.", which);
	      sprintf (buf2, "demoing (%ld).", which);
	      clientmessage_response (si, window, False, buf, buf2);

	      if (which < 0) which = 0;		/* 0 == "random" */
	      si->selection_mode = which;
	      si->demoing_p = True;

              if (si->throttled_p && p->verbose_p)
                fprintf (stderr, "%s: unthrottled.\n", blurb());
              si->throttled_p = False;

	      return True;
	    }

	  clientmessage_response (si, window, True,
				  "DEMO ClientMessage received while active.",
				  "already active.");
	}
      else
	{
	  clientmessage_response (si, window, True,
				  "obsolete form of DEMO ClientMessage.",
				  "obsolete form of DEMO ClientMessage.");
	}
    }
  else if (type == XA_PREFS)
    {
      clientmessage_response (si, window, True,
			      "the PREFS client-message is obsolete.",
			      "the PREFS client-message is obsolete.");
    }
  else if (type == XA_LOCK)
    {
#ifdef NO_LOCKING
      clientmessage_response (si, window, True,
			      "not compiled with support for locking.",
			      "locking not enabled.");
#else /* !NO_LOCKING */
      if (si->locking_disabled_p)
	clientmessage_response (si, window, True,
		      "LOCK ClientMessage received, but locking is disabled.",
			      "locking not enabled.");
      else if (si->locked_p)
	clientmessage_response (si, window, True,
			   "LOCK ClientMessage received while already locked.",
				"already locked.");
      else
	{
	  char buf [255];
	  char *response = (until_idle_p
			    ? "activating and locking."
			    : "locking.");
	  sprintf (buf, "LOCK ClientMessage received; %s", response);
	  clientmessage_response (si, window, False, buf, response);

           /* Have to set the time or xscreensaver-command doesn't report
              the LOCK state change. Must come before set_locked_p(). */
           si->blank_time = time ((time_t *) 0);

          /* Note that this leaves things in a slightly inconsistent state:
             we are blanked but not locked.  And blanking might actually
             fail if we can't get the grab. */
	  set_locked_p (si, True);

	  si->selection_mode = 0;
	  si->demoing_p = False;

	  if (si->lock_id)	/* we're doing it now, so lose the timeout */
	    {
	      XtRemoveTimeOut (si->lock_id);
	      si->lock_id = 0;
	    }

	  if (until_idle_p)
	    {
	      if (si->using_mit_saver_extension ||
                  si->using_sgi_saver_extension)
		{
		  XForceScreenSaver (si->dpy, ScreenSaverActive);
		  return False;
		}
	      else
		{
		  return True;
		}
	    }
	}
#endif /* !NO_LOCKING */
    }
  else if (type == XA_THROTTLE)
    {
      /* The THROTTLE command is deprecated -- it predates the XDPMS
         extension.  Instead of using -throttle, users should instead
         just power off the monitor (e.g., "xset dpms force off".)
         In a few minutes, xscreensaver will notice that the monitor
         is off, and cease running hacks.
       */
      if (si->throttled_p)
	clientmessage_response (si, window, True,
                                "THROTTLE ClientMessage received, but "
                                "already throttled.",
                                "already throttled.");
      else
	{
	  char buf [255];
	  char *response = "throttled.";
	  si->throttled_p = True;
	  si->selection_mode = 0;
	  si->demoing_p = False;
	  sprintf (buf, "THROTTLE ClientMessage received; %s", response);
	  clientmessage_response (si, window, False, buf, response);

          if (! until_idle_p)
            {
              if (si->cycle_id)
                XtRemoveTimeOut (si->cycle_id);
              si->cycle_id = 0;
              cycle_timer ((XtPointer) si, 0);
            }
	}
    }
  else if (type == XA_UNTHROTTLE)
    {
      if (! si->throttled_p)
	clientmessage_response (si, window, True,
                                "UNTHROTTLE ClientMessage received, but "
                                "not throttled.",
                                "not throttled.");
      else
	{
	  char buf [255];
	  char *response = "unthrottled.";
	  si->throttled_p = False;
	  si->selection_mode = 0;
	  si->demoing_p = False;
	  sprintf (buf, "UNTHROTTLE ClientMessage received; %s", response);
	  clientmessage_response (si, window, False, buf, response);

          if (! until_idle_p)
            {
              if (si->cycle_id)
                XtRemoveTimeOut (si->cycle_id);
              si->cycle_id = 0;
              cycle_timer ((XtPointer) si, 0);
            }
	}
    }
  else
    {
      char buf [1024];
      char *str;
      str = XGetAtomName_safe (si->dpy, type);

      if (str)
	{
	  if (strlen (str) > 80)
	    strcpy (str+70, "...");
	  sprintf (buf, "unrecognised screensaver ClientMessage %s received.",
		   str);
	  free (str);
	}
      else
	{
	  sprintf (buf,
		   "unrecognised screensaver ClientMessage 0x%x received.",
		   (unsigned int) event->xclient.data.l[0]);
	}

      clientmessage_response (si, window, True, buf, buf);
    }
  return False;
}


/* Some random diagnostics printed in -verbose mode.
 */

static void
analyze_display (saver_info *si)
{
  int i, j;
  static struct {
    const char *name; const char *desc; 
    Bool useful_p;
    Status (*version_fn) (Display *, int *majP, int *minP);
  } exts[] = {

   { "SCREEN_SAVER", /* underscore */           "SGI Screen-Saver",
#     ifdef HAVE_SGI_SAVER_EXTENSION
        True,  0
#     else
        False, 0
#     endif
   }, { "SCREEN-SAVER", /* dash */              "SGI Screen-Saver",
#     ifdef HAVE_SGI_SAVER_EXTENSION
        True,  0
#     else
        False, 0
#     endif
   }, { "MIT-SCREEN-SAVER",                     "MIT Screen-Saver",
#     ifdef HAVE_MIT_SAVER_EXTENSION
        True,  XScreenSaverQueryVersion
#     else
        False, 0
#     endif
   }, { "XIDLE",                                "XIdle",           
#     ifdef HAVE_XIDLE_EXTENSION
        True,  0
#     else
        False, 0
#     endif
   }, { "SGI-VIDEO-CONTROL",                    "SGI Video-Control",
#     ifdef HAVE_SGI_VC_EXTENSION
        True,  XSGIvcQueryVersion
#     else
        False, 0
#     endif
   }, { "READDISPLAY",                          "SGI Read-Display",
#     ifdef HAVE_READ_DISPLAY_EXTENSION
        True,  XReadDisplayQueryVersion
#     else
        False, 0
#     endif
   }, { "MIT-SHM",                              "Shared Memory",   
#     ifdef HAVE_XSHM_EXTENSION
        True, (Status (*) (Display*,int*,int*)) XShmQueryVersion /* 4 args */
#     else
        False, 0
#     endif
   }, { "DOUBLE-BUFFER",                        "Double-Buffering",
#     ifdef HAVE_DOUBLE_BUFFER_EXTENSION
        True, XdbeQueryExtension
#     else
        False, 0
#     endif
   }, { "DPMS",                                 "Power Management",
#     ifdef HAVE_DPMS_EXTENSION
        True,  DPMSGetVersion
#     else
        False, 0
#     endif
   }, { "GLX",                                  "GLX",             
#     ifdef HAVE_GL
        True,  0
#     else
        False, 0
#     endif
   }, { "XFree86-VidModeExtension",             "XF86 Video-Mode", 
#     ifdef HAVE_XF86VMODE
        True,  XF86VidModeQueryVersion
#     else
        False, 0
#     endif
   }, { "XC-VidModeExtension",                  "XC Video-Mode", 
#     ifdef HAVE_XF86VMODE
        True,  XF86VidModeQueryVersion
#     else
        False, 0
#     endif
   }, { "XFree86-MISC",                         "XF86 Misc", 
#     ifdef HAVE_XF86MISCSETGRABKEYSSTATE
        True,  XF86MiscQueryVersion
#     else
        False, 0
#     endif
   }, { "XC-MISC",                              "XC Misc", 
#     ifdef HAVE_XF86MISCSETGRABKEYSSTATE
        True,  XF86MiscQueryVersion
#     else
        False, 0
#     endif
   }, { "XINERAMA",                             "Xinerama",
#     ifdef HAVE_XINERAMA
        True,  XineramaQueryVersion
#     else
        False, 0
#     endif
   }, { "RANDR",                                "Resize-and-Rotate",
#     ifdef HAVE_RANDR
        True,  XRRQueryVersion
#     else
        False, 0
#     endif
   }, { "DRI",		                        "DRI",
        True,  0
   }, { "NV-CONTROL",                           "NVidia",
        True,  0
   }, { "NV-GLX",                               "NVidia GLX",
        True,  0
   }, { "Apple-DRI",                            "Apple-DRI (XDarwin)",
        True,  0
   }, { "XInputExtension",                      "XInput",
        True,  0
   },
  };

  fprintf (stderr, "%s: running on display \"%s\"\n", blurb(), 
           DisplayString(si->dpy));
  fprintf (stderr, "%s: vendor is %s, %d.\n", blurb(),
	   ServerVendor(si->dpy), VendorRelease(si->dpy));

  fprintf (stderr, "%s: useful extensions:\n", blurb());
  for (i = 0; i < countof(exts); i++)
    {
      int op = 0, event = 0, error = 0;
      char buf [255];
      int maj = 0, min = 0;
      int dummy1, dummy2, dummy3;

      /* Most of the extension version functions take 3 args,
         writing results into args 2 and 3, but some take more.
         We only ever care about the first two results, but we
         pass in three extra pointers just in case.
       */
      Status (*version_fn_2) (Display*,int*,int*,int*,int*,int*) =
        (Status (*) (Display*,int*,int*,int*,int*,int*)) exts[i].version_fn;

      if (!XQueryExtension (si->dpy, exts[i].name, &op, &event, &error))
        continue;
      sprintf (buf, "%s:   ", blurb());
      strcat (buf, exts[i].desc);

      if (!version_fn_2)
        ;
      else if (version_fn_2 (si->dpy, &maj, &min, &dummy1, &dummy2, &dummy3))
        sprintf (buf+strlen(buf), " (%d.%d)", maj, min);
      else
        strcat (buf, " (unavailable)");

      if (!exts[i].useful_p)
        strcat (buf, " (disabled at compile time)");
      fprintf (stderr, "%s\n", buf);
    }

# ifdef HAVE_LIBSYSTEMD
  fprintf (stderr, "%s:   libsystemd\n", blurb());
# else
  fprintf (stderr, "%s:   libsystemd (disabled at compile time)\n", blurb());
# endif

  for (i = 0; i < si->nscreens; i++)
    {
      saver_screen_info *ssi = &si->screens[i];
      unsigned long colormapped_depths = 0;
      unsigned long non_mapped_depths = 0;
      XVisualInfo vi_in, *vi_out;
      int out_count;

      if (!ssi->real_screen_p) continue;

      vi_in.screen = ssi->real_screen_number;
      vi_out = XGetVisualInfo (si->dpy, VisualScreenMask, &vi_in, &out_count);
      if (!vi_out) continue;
      for (j = 0; j < out_count; j++) {
	if (vi_out[j].depth >= 32) continue;
	if (vi_out[j].class == PseudoColor)
	  colormapped_depths |= (1 << vi_out[j].depth);
	else
	  non_mapped_depths  |= (1 << vi_out[j].depth);
	}
      XFree ((char *) vi_out);

      if (colormapped_depths)
	{
	  fprintf (stderr, "%s: screen %d colormapped depths:", blurb(),
                   ssi->real_screen_number);
	  for (j = 0; j < 32; j++)
	    if (colormapped_depths & (1 << j))
	      fprintf (stderr, " %d", j);
	  fprintf (stderr, ".\n");
	}
      if (non_mapped_depths)
	{
	  fprintf (stderr, "%s: screen %d non-colormapped depths:",
                   blurb(), ssi->real_screen_number);
	  for (j = 0; j < 32; j++)
	    if (non_mapped_depths & (1 << j))
	      fprintf (stderr, " %d", j);
	  fprintf (stderr, ".\n");
	}
    }

  describe_monitor_layout (si);
}


Bool
display_is_on_console_p (saver_info *si)
{
  Bool not_on_console = True;
  char *dpystr = DisplayString (si->dpy);
  char *tail = (char *) strchr (dpystr, ':');
  if (! tail || strncmp (tail, ":0", 2))
    not_on_console = True;
  else
    {
      char dpyname[255], localname[255];
      strncpy (dpyname, dpystr, tail-dpystr);
      dpyname [tail-dpystr] = 0;
      if (!*dpyname ||
	  !strcmp(dpyname, "unix") ||
	  !strcmp(dpyname, "localhost"))
	not_on_console = False;
      else if (gethostname (localname, sizeof (localname)))
	not_on_console = True;  /* can't find hostname? */
      else if (!strncmp (dpyname, "/tmp/launch-", 12))  /* MacOS X launchd */
	not_on_console = False;
      else
	{
	  /* We have to call gethostbyname() on the result of gethostname()
	     because the two aren't guarenteed to be the same name for the
	     same host: on some losing systems, one is a FQDN and the other
	     is not.  Here in the wide wonderful world of Unix it's rocket
	     science to obtain the local hostname in a portable fashion.
	     
	     And don't forget, gethostbyname() reuses the structure it
	     returns, so we have to copy the fucker before calling it again.
	     Thank you master, may I have another.
	   */
	  struct hostent *h = gethostbyname (dpyname);
	  if (!h)
	    not_on_console = True;
	  else
	    {
	      char hn [255];
	      struct hostent *l;
	      strcpy (hn, h->h_name);
	      l = gethostbyname (localname);
	      not_on_console = (!l || !!(strcmp (l->h_name, hn)));
	    }
	}
    }
  return !not_on_console;
}


/* Do a little bit of heap introspection...
 */
void
check_for_leaks (const char *where)
{
#if defined(HAVE_SBRK) && defined(LEAK_PARANOIA)
  static unsigned long last_brk = 0;
  int b = (unsigned long) sbrk(0);
  if (last_brk && last_brk < b)
    fprintf (stderr, "%s: %s: brk grew by %luK.\n",
             blurb(), where,
             (((b - last_brk) + 1023) / 1024));
  last_brk = b;
#endif /* HAVE_SBRK */
}