~ubuntu-branches/ubuntu/wily/xscreensaver/wily

/* xscreensaver, Copyright (c) 1991-2011 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.

 */

/*   ========================================================================

 *   First we wait until the keyboard and mouse become idle for the specified

 *   amount of time.  We do this in one of three different ways: periodically

 *   checking with the XIdle server extension; selecting key and mouse events

 *   on (nearly) all windows; or by waiting for the MIT-SCREEN-SAVER extension

 *   to send us a "you are idle" event.

 *

 *   Then, we map a full screen black window.

 *

 *   We place a __SWM_VROOT property on this window, so that newly-started

 *   clients will think that this window is a "virtual root" window (as per

 *   the logic in the historical "vroot.h" header.)

 *

 *   If there is an existing "virtual root" window (one that already had

 *   an __SWM_VROOT property) then we remove that property from that window.

 *   Otherwise, clients would see that window (the real virtual root) instead

 *   of ours (the impostor.)

 *

 *   Then we pick a random program to run, and start it.  Two assumptions 

 *   are made about this program: that it has been specified with whatever

 *   command-line options are necessary to make it run on the root window;

 *   and that it has been compiled with vroot.h, so that it is able to find

 *   the root window when a virtual-root window manager (or this program) is

 *   running.

 *

 *   Then, we wait for keyboard or mouse events to be generated on the window.

 *   When they are, we kill the inferior process, unmap the window, and restore

 *   the __SWM_VROOT property to the real virtual root window if there was one.

 *

 *   On multi-screen systems, we do the above on each screen, and start

 *   multiple programs, each with a different value of $DISPLAY.

 *

 *   On Xinerama systems, we do a similar thing, but instead create multiple

 *   windows on the (only) display, and tell the subprocess which one to use

 *   via the $XSCREENSAVER_WINDOW environment variable -- this trick requires

 *   a recent (Aug 2003) revision of vroot.h.

 *

 *   (See comments in screens.c for more details about Xinerama/RANDR stuff.)

 *

 *   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.

 *

 *   If there was a real virtual root, meaning that we removed the __SWM_VROOT

 *   property from it, meaning we must (absolutely must) restore it before we

 *   exit, then we set up signal handlers for most signals (SIGINT, SIGTERM,

 *   etc.) that do this.  Most Xlib and Xt routines are not reentrant, so it

 *   is not generally safe to call them from signal handlers; however, this

 *   program spends most of its time waiting, so the window of opportunity 

 *   when code could be called reentrantly is fairly small; and also, the worst

 *   that could happen is that the call would fail.  If we've gotten one of

 *   these signals, then we're on our way out anyway.  If we didn't restore the

 *   __SWM_VROOT property, that would be very bad, so it's worth a shot.  Note

 *   that this means that, if you're using a virtual-root window manager, you

 *   can really fuck up the world by killing this process with "kill -9".

 *

 *   This program accepts ClientMessages of type SCREENSAVER; these messages

 *   may contain the atoms ACTIVATE, DEACTIVATE, etc, meaning to turn the 

 *   screensaver on or off now, regardless of the idleness of the user,

 *   and a few other things.  The included "xscreensaver-command" program

 *   sends these messsages.

 *

 *   If we don't have the XIdle, MIT-SCREEN-SAVER, or SGI SCREEN_SAVER

 *   extensions, then we do the XAutoLock trick: notice every window that

 *   gets created, and wait 30 seconds or so until its creating process has

 *   settled down, and then select KeyPress events on those windows which

 *   already select for KeyPress events.  It's important that we not select

 *   KeyPress on windows which don't select them, because that would

 *   interfere with event propagation.  This will break if any program

 *   changes its event mask to contain KeyRelease or PointerMotion more than

 *   30 seconds after creating the window, but such programs do not seem to

 *   occur in nature (I've never seen it happen in all these years.)

 *

 *   The reason that we can't select KeyPresses on windows that don't have

 *   them already is that, 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.

 *

 *   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.

 *   I think polling is more reliable.

 *

 *   On systems with /proc/interrupts (Linux) we poll that file and note when

 *   the interrupt counter numbers on the "keyboard" and "PS/2" lines change.

 *   (There is no reliable way, using /proc/interrupts, to detect non-PS/2

 *   mice, so it doesn't help for serial or USB mice.)

 *

 *   None of this crap happens if we're using one of the extensions.  Sadly,

 *   the XIdle extension hasn't been available for many years; the SGI

 *   extension only exists on SGIs; and the MIT extension, while widely

 *   deployed, is garbage in several ways.

 *

 *   A third idle-detection option could be implemented (but is not): when

 *   running on the console display ($DISPLAY is `localhost`:0) and we're on a

 *   machine where /dev/tty and /dev/mouse have reasonable last-modification

 *   times, we could just stat() those.  But the incremental benefit of

 *   implementing this is really small, so forget I said anything.

 *

 *   Debugging hints:

 *     - Have a second terminal handy.

 *     - Be careful where you set your breakpoints, you don't want this to

 *       stop under the debugger with the keyboard grabbed or the blackout

 *       window exposed.

 *     - If you run your debugger under XEmacs, try M-ESC (x-grab-keyboard)

 *       to keep your emacs window alive even when xscreensaver has 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.

 *     - If you aren't using a server extension, don't leave this stopped

 *       under the debugger for very long, or the X input buffer will get

 *       huge because of the keypress events it's selecting for.  This can

 *       make your X server wedge with "no more input buffers."

 *

 * ======================================================================== */

#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_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)

{

  fflush (stdout);

  fflush (stderr);

  fprintf (stdout, "\

xscreensaver %s, copyright (c) 1991-2008 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);

  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\

       http://www.jwz.org/xscreensaver/\n\

\n");

  fflush (stdout);

  fflush (stderr);

  exit (1);

}

char *

timestring (void)

{

  time_t now = time ((time_t *) 0);

  char *str = (char *) ctime (&now);

  char *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();

      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 -verbose -log log.txt', and reproduce this\n"

   "    bug.  That will cause xscreensaver to dump a `core' file to the\n"

   "    current directory.  Please include the stack trace from that core\n"

   "    file 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"

   "    http://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;

}

/* 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"

          "              http://www.jwz.org/xscreensaver/faq.html\n"

          "              http://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 (5);

  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";

        }

    }

  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_ACTIVATE = XInternAtom (si->dpy, "ACTIVATE", False);

  XA_DEACTIVATE = XInternAtom (si->dpy, "DEACTIVATE", 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\

    http://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;

  /* 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-2008 "

	     "by Jamie Zawinski <jwz@jwz.org>.\n",

	     progname, si->version);

  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)

    {

      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());

    }