-/* xscreensaver, Copyright (c) 1991-1998 Jamie Zawinski <jwz@netscape.com>
+/* xscreensaver, Copyright (c) 1991-2003 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
* 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 (or, in the case of the
- * MIT-SCREEN-SAVER extension, use the one it gave us.)
+ * 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.
+ * 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.
* 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.
*
- * While we are waiting, 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.
+ * 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.
+ *
+ * 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
* 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 atom ACTIVATE or DEACTIVATE, meaning to turn the
+ * 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
+ * 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
* 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 that's probably pretty rare.
- *
+ * 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
* "client changing event mask" problem that the KeyPress events hack does.
* I think polling is more reliable.
*
- * None of this crap happens if we're using one of the extensions, so install
- * one of them if the description above sounds just too flaky to live. It
- * is, but those are your choices.
+ * 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
* 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 clients are dying
- * with signal 5, Trace/BPT Trap, you're losing in this way.
+ * 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 <stdio.h>
#include <ctype.h>
#include <X11/Xlib.h>
+
+#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() */
#ifdef HAVE_XMU
# ifndef VMS
# include <X11/Xmu/Error.h>
#endif /* !HAVE_XMU */
#ifdef HAVE_XIDLE_EXTENSION
-#include <X11/extensions/xidle.h>
+# include <X11/extensions/xidle.h>
#endif /* HAVE_XIDLE_EXTENSION */
+#ifdef HAVE_XINERAMA
+# include <X11/extensions/Xinerama.h>
+#endif /* HAVE_XINERAMA */
+
#include "xscreensaver.h"
#include "version.h"
#include "yarandom.h"
#include "resources.h"
#include "visual.h"
+#include "usleep.h"
saver_info *global_si_kludge = 0; /* I hate C so much... */
XrmDatabase db = 0;
+static Atom XA_SCREENSAVER_RESPONSE;
static Atom XA_ACTIVATE, XA_DEACTIVATE, XA_CYCLE, XA_NEXT, XA_PREV;
-static Atom XA_EXIT, XA_RESTART, XA_DEMO, XA_LOCK;
+static Atom XA_RESTART, XA_SELECT;
+static Atom XA_THROTTLE, XA_UNTHROTTLE;
+Atom XA_DEMO, XA_PREFS, XA_EXIT, XA_LOCK, XA_BLANK;
\f
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" },
+
+ /* There's really no reason to have these command-line args; they just
+ lead to confusion when the .xscreensaver file has conflicting values.
+ */
+#if 0
+ { "-splash", ".splash", XrmoptionNoArg, "on" },
+ { "-capture-stderr", ".captureStderr", XrmoptionNoArg, "on" },
{ "-timeout", ".timeout", XrmoptionSepArg, 0 },
{ "-cycle", ".cycle", XrmoptionSepArg, 0 },
{ "-lock-mode", ".lock", XrmoptionNoArg, "on" },
{ "-no-lock-mode", ".lock", XrmoptionNoArg, "off" },
+ { "-no-lock", ".lock", XrmoptionNoArg, "off" },
{ "-lock-timeout", ".lockTimeout", XrmoptionSepArg, 0 },
+ { "-lock-vts", ".lockVTs", XrmoptionNoArg, "on" },
+ { "-no-lock-vts", ".lockVTs", XrmoptionNoArg, "off" },
{ "-visual", ".visualID", XrmoptionSepArg, 0 },
{ "-install", ".installColormap", XrmoptionNoArg, "on" },
{ "-no-install", ".installColormap", XrmoptionNoArg, "off" },
- { "-verbose", ".verbose", XrmoptionNoArg, "on" },
- { "-silent", ".verbose", XrmoptionNoArg, "off" },
+ { "-timestamp", ".timestamp", XrmoptionNoArg, "on" },
{ "-xidle-extension", ".xidleExtension", XrmoptionNoArg, "on" },
{ "-no-xidle-extension", ".xidleExtension", XrmoptionNoArg, "off" },
{ "-mit-extension", ".mitSaverExtension",XrmoptionNoArg, "on" },
{ "-no-mit-extension", ".mitSaverExtension",XrmoptionNoArg, "off" },
{ "-sgi-extension", ".sgiSaverExtension",XrmoptionNoArg, "on" },
{ "-no-sgi-extension", ".sgiSaverExtension",XrmoptionNoArg, "off" },
+ { "-proc-interrupts", ".procInterrupts", XrmoptionNoArg, "on" },
+ { "-no-proc-interrupts", ".procInterrupts", XrmoptionNoArg, "off" },
{ "-idelay", ".initialDelay", XrmoptionSepArg, 0 },
- { "-nice", ".nice", XrmoptionSepArg, 0 }
+ { "-nice", ".nice", XrmoptionSepArg, 0 },
+#endif /* 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)
{
- printf ("\
-xscreensaver %s, copyright (c) 1991-1998 by Jamie Zawinski <jwz@netscape.com>\n\
-The standard Xt command-line options are accepted; other options include:\n\
+ fflush (stdout);
+ fflush (stderr);
+ fprintf (stdout, "\
+xscreensaver %s, copyright (c) 1991-2004 by Jamie Zawinski <jwz@jwz.org>\n\
\n\
- -timeout <minutes> When the screensaver should activate.\n\
- -cycle <minutes> How long to let each hack run.\n\
- -lock-mode Require a password before deactivating.\n\
- -no-lock-mode Don't.\n\
- -lock-timeout <minutes> Grace period before locking; default 0.\n\
- -visual <id-or-class> Which X visual to run on.\n\
- -install Install a private colormap.\n\
- -no-install Don't.\n\
- -verbose Be loud.\n\
- -silent Don't.\n\
- -mit-extension Use the R6 MIT_SCREEN_SAVER server extension.\n\
- -no-mit-extension Don't.\n\
- -sgi-extension Use the SGI SCREEN-SAVER server extension.\n\
- -no-sgi-extension Don't.\n\
- -xidle-extension Use the R5 XIdle server extension.\n\
- -no-xidle-extension Don't.\n\
- -help This message.\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\
-The `xscreensaver' program should be left running in the background.\n\
-Use the `xscreensaver-command' program to manipulate a running xscreensaver.\n\
+ xscreensaver &\n\
+ xscreensaver-demo\n\
\n\
-The `*programs' resource controls which graphics demos will be launched by\n\
-the screensaver. See `man xscreensaver' or the web page for more details.\n\
+ For updates, online manual, and FAQ, please see the web page:\n\
\n\
-For updates, check http://people.netscape.com/jwz/xscreensaver/\n\n",
- si->version);
-
-#ifdef NO_LOCKING
- printf ("Support for locking was not enabled at compile-time.\n");
-#endif
-#ifdef NO_DEMO_MODE
- printf ("Support for demo mode was not enabled at compile-time.\n");
-#endif
-#if !defined(HAVE_XIDLE_EXTENSION) && !defined(HAVE_MIT_SAVER_EXTENSION) && !defined(HAVE_SGI_SAVER_EXTENSION)
- printf ("Support for the XIDLE, SCREEN_SAVER, and MIT-SCREEN-SAVER server\
- extensions\nwas not enabled at compile-time.\n");
-#endif /* !HAVE_XIDLE_EXTENSION && !HAVE_MIT_SAVER_EXTENSION && !HAVE_SGI_SAVER_EXTENSION */
+ http://www.jwz.org/xscreensaver/\n\
+\n");
fflush (stdout);
+ fflush (stderr);
exit (1);
}
-static char *
-reformat_hack(const char *hack)
+char *
+timestring (void)
{
- int i;
- const char *in = hack;
- int indent = 13;
- char *h2 = (char *) malloc(strlen(in) + indent + 2);
- char *out = h2;
-
- while (isspace(*in)) in++; /* skip whitespace */
- while (*in && !isspace(*in) && *in != ':')
- *out++ = *in++; /* snarf first token */
- while (isspace(*in)) in++; /* skip whitespace */
-
- if (*in == ':')
- *out++ = *in++; /* copy colon */
+ 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 = False; /* kludge */
+
+const char *
+blurb (void)
+{
+ if (!blurb_timestamp_p)
+ return progname;
else
{
- in = hack;
- out = h2; /* reset to beginning */
+ 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;
}
+}
- *out = 0;
-
- while (isspace(*in)) in++; /* skip whitespace */
- for (i = strlen(h2); i < indent; i++) /* indent */
- *out++ = ' ';
- while (*in) *out++ = *in++; /* copy rest of line */
- *out = 0;
+int
+saver_ehandler (Display *dpy, XErrorEvent *error)
+{
+ saver_info *si = global_si_kludge; /* I hate C so much... */
+ int i;
+ Bool fatal_p;
- return h2;
-}
+ if (!real_stderr) real_stderr = stderr;
+ fprintf (real_stderr, "\n"
+ "#######################################"
+ "#######################################\n\n"
+ "%s: X Error! PLEASE REPORT THIS BUG.\n",
+ blurb());
-static void
-get_screenhacks (saver_info *si)
-{
- saver_preferences *p = &si->prefs;
- int i = 0;
- int hacks_size = 60;
- int size;
- char *d;
-
- d = get_string_resource ("monoPrograms", "MonoPrograms");
- if (d && !*d) { free(d); d = 0; }
- if (!d)
- d = get_string_resource ("colorPrograms", "ColorPrograms");
- if (d && !*d) { free(d); d = 0; }
-
- if (d)
+ for (i = 0; i < si->nscreens; i++)
{
- fprintf (stderr,
- "%s: the `monoPrograms' and `colorPrograms' resources are obsolete;\n\
- see the manual for details.\n", progname);
- free(d);
+ 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);
}
- d = get_string_resource ("programs", "Programs");
+ 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.
+ */
- size = d ? strlen (d) : 0;
- p->screenhacks = (char **) malloc (sizeof (char *) * hacks_size);
- p->screenhacks_count = 0;
+ fprintf (real_stderr, "\n");
- while (i < size)
+ if (! fatal_p)
+ fprintf (real_stderr, "%s: nonfatal error.\n\n", blurb());
+ else
{
- int end, start = i;
- if (d[i] == ' ' || d[i] == '\t' || d[i] == '\n' || d[i] == 0)
+ if (si->prefs.xsync_p)
{
- i++;
- continue;
+ saver_exit (si, -1, "because of synchronous X Error");
}
- if (hacks_size <= p->screenhacks_count)
- p->screenhacks = (char **) realloc (p->screenhacks,
- (hacks_size = hacks_size * 2) *
- sizeof (char *));
- p->screenhacks [p->screenhacks_count++] = d + i;
- while (d[i] != 0 && d[i] != '\n')
- i++;
- end = i;
- while (i > start && (d[i-1] == ' ' || d[i-1] == '\t'))
- i--;
- d[i] = 0;
- i = end + 1;
- }
-
- /* shrink all whitespace to one space, for the benefit of the "demo"
- mode display. We only do this when we can easily tell that the
- whitespace is not significant (no shell metachars).
- */
- for (i = 0; i < p->screenhacks_count; i++)
- {
- char *s = p->screenhacks [i];
- char *s2;
- int L = strlen (s);
- int j, k;
- for (j = 0; j < L; j++)
+ else
{
- switch (s[j])
- {
- case '\'': case '"': case '`': case '\\':
- goto DONE;
- case '\t':
- s[j] = ' ';
- case ' ':
- k = 0;
- for (s2 = s+j+1; *s2 == ' ' || *s2 == '\t'; s2++)
- k++;
- if (k > 0)
- {
- for (s2 = s+j+1; s2[k]; s2++)
- *s2 = s2[k];
- *s2 = 0;
- }
- break;
- }
+ fprintf (real_stderr,
+ "#######################################"
+ "#######################################\n\n");
+ fprintf (real_stderr,
+ " If at all possible, please re-run xscreensaver with the command\n"
+ " line arguments `-sync -verbose -no-capture', 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!\n"
+ " That won't work.\n");
+ fprintf (real_stderr,
+ "\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");
+ fprintf (real_stderr,
+ "#######################################"
+ "#######################################\n\n");
+
+ saver_exit (si, -1, 0);
}
- DONE:
- p->screenhacks[i] = reformat_hack(s); /* mallocs */
}
- if (p->screenhacks_count)
+ 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))
{
- /* Shrink down the screenhacks array to be only as big as it needs to.
- This doesn't really matter at all. */
- p->screenhacks = (char **)
- realloc (p->screenhacks, ((p->screenhacks_count + 1) *
- sizeof(char *)));
- p->screenhacks [p->screenhacks_count] = 0;
+ 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
{
- free (p->screenhacks);
- p->screenhacks = 0;
+ 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);
}
+\f
+/* The zillions of initializations.
+ */
+/* Set progname, version, etc. This is done very early.
+ */
static void
-get_resources (saver_info *si)
+set_version_string (saver_info *si, int *argc, char **argv)
{
- char *s;
- saver_preferences *p = &si->prefs;
+ progclass = "XScreenSaver";
- p->verbose_p = get_boolean_resource ("verbose", "Boolean");
- p->lock_p = get_boolean_resource ("lock", "Boolean");
- p->fade_p = get_boolean_resource ("fade", "Boolean");
- p->unfade_p = get_boolean_resource ("unfade", "Boolean");
- p->fade_seconds = get_seconds_resource ("fadeSeconds", "Time");
- p->fade_ticks = get_integer_resource ("fadeTicks", "Integer");
- p->install_cmap_p = get_boolean_resource ("installColormap", "Boolean");
- p->nice_inferior = get_integer_resource ("nice", "Nice");
+ /* progname is reset later, after we connect to X. */
+ progname = strrchr(argv[0], '/');
+ if (progname) progname++;
+ else progname = argv[0];
- p->initial_delay = get_seconds_resource ("initialDelay", "Time");
- p->timeout = 1000 * get_minutes_resource ("timeout", "Time");
- p->lock_timeout = 1000 * get_minutes_resource ("lockTimeout", "Time");
- p->cycle = 1000 * get_minutes_resource ("cycle", "Time");
+ if (strlen(progname) > 100) /* keep it short. */
+ progname[99] = 0;
-#ifndef NO_LOCKING
- p->passwd_timeout = 1000 * get_seconds_resource ("passwdTimeout", "Time");
-#endif
+ /* The X resource database blows up if argv[0] has a "." in it. */
+ {
+ char *s = argv[0];
+ while ((s = strchr (s, '.')))
+ *s = '_';
+ }
- p->pointer_timeout = 1000 * get_seconds_resource ("pointerPollTime", "Time");
- p->notice_events_timeout = 1000*get_seconds_resource("windowCreationTimeout",
- "Time");
- p->shell = get_string_resource ("bourneShell", "BourneShell");
+ si->version = (char *) malloc (5);
+ memcpy (si->version, screensaver_id + 17, 4);
+ si->version [4] = 0;
+}
- /* don't set use_xidle_extension unless it is explicitly specified */
- if ((s = get_string_resource ("xidleExtension", "Boolean")))
- p->use_xidle_extension = get_boolean_resource ("xidleExtension","Boolean");
- else
-#ifdef HAVE_XIDLE_EXTENSION /* pick a default */
- p->use_xidle_extension = True; /* if we have it, use it */
-#else /* !HAVE_XIDLE_EXTENSION */
- p->use_xidle_extension = False;
-#endif /* !HAVE_XIDLE_EXTENSION */
- if (s) free (s);
-
- /* don't set use_mit_extension unless it is explicitly specified */
- if ((s = get_string_resource ("mitSaverExtension", "Boolean")))
- p->use_mit_saver_extension = get_boolean_resource ("mitSaverExtension",
- "Boolean");
- else
-#ifdef HAVE_MIT_SAVER_EXTENSION /* pick a default */
- p->use_mit_saver_extension = False; /* Default false, because it sucks */
-#else /* !HAVE_MIT_SAVER_EXTENSION */
- p->use_mit_saver_extension = False;
-#endif /* !HAVE_MIT_SAVER_EXTENSION */
- if (s) free (s);
-
-
- /* don't set use_mit_extension unless it is explicitly specified */
- if ((s = get_string_resource ("sgiSaverExtension", "Boolean")))
- p->use_sgi_saver_extension = get_boolean_resource ("sgiSaverExtension",
- "Boolean");
- else
-#ifdef HAVE_SGI_SAVER_EXTENSION /* pick a default */
- p->use_sgi_saver_extension = True; /* if we have it, use it */
-#else /* !HAVE_SGI_SAVER_EXTENSION */
- p->use_sgi_saver_extension = False;
-#endif /* !HAVE_SGI_SAVER_EXTENSION */
- if (s) free (s);
+/* 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);
+}
- /* Throttle the various timeouts to reasonable values.
- */
-#ifndef NO_LOCKING
- if (p->passwd_timeout == 0) p->passwd_timeout = 30000; /* 30 secs */
-#endif
- if (p->timeout < 10000) p->timeout = 10000; /* 10 secs */
- if (p->cycle != 0 && p->cycle < 2000) p->cycle = 2000; /* 2 secs */
- if (p->pointer_timeout == 0) p->pointer_timeout = 5000; /* 5 secs */
- if (p->notice_events_timeout == 0)
- p->notice_events_timeout = 10000; /* 10 secs */
- if (p->fade_seconds == 0 || p->fade_ticks == 0)
- p->fade_p = False;
- if (! p->fade_p) p->unfade_p = False;
-
- p->watchdog_timeout = p->cycle;
- if (p->watchdog_timeout < 30000) p->watchdog_timeout = 30000; /* 30 secs */
- if (p->watchdog_timeout > 3600000) p->watchdog_timeout = 3600000; /* 1 hr */
+/* 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";
- if (p->lock_p)
- {
- p->lock_p = False;
- fprintf (stderr, "%s: not compiled with support for locking.\n",
- progname);
- }
-#else /* ! NO_LOCKING */
- if (p->lock_p && si->locking_disabled_p)
+#else /* !NO_LOCKING */
+
+ /* Finish initializing locking, now that we're out of privileged code. */
+ if (! lock_init (*argc, argv, si->prefs.verbose_p))
{
- fprintf (stderr, "%s: locking is disabled (%s).\n", progname,
- si->nolock_reason);
- p->lock_p = False;
+ si->locking_disabled_p = True;
+ si->nolock_reason = "error getting password";
}
-#endif /* ! NO_LOCKING */
-
- get_screenhacks (si);
- if (p->debug_p)
+ /* 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"))
{
- XSynchronize(si->dpy, True);
- p->verbose_p = True;
- p->initial_delay = 0;
+ 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
-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;
-}
+ 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);
-static void initialize (saver_info *si, int argc, char **argv);
-static void main_loop (saver_info *si);
+ if (macos_p)
+ {
+ si->locking_disabled_p = True;
+ si->nolock_reason = "Cannot lock securely on MacOS X";
+ }
+ }
-int
-main (int argc, char **argv)
-{
- saver_info si;
- memset(&si, 0, sizeof(si));
- global_si_kludge = &si; /* I hate C so much... */
- initialize (&si, argc, argv);
- main_loop (&si); /* doesn't return */
- return 0;
+#endif /* NO_LOCKING */
}
-int
-saver_ehandler (Display *dpy, XErrorEvent *error)
+/* Open the connection to the X server, and intern our Atoms.
+ */
+static Widget
+connect_to_server (saver_info *si, int *argc, char **argv)
{
- saver_info *si = global_si_kludge; /* I hate C so much... */
+ Widget toplevel_shell;
- fprintf (real_stderr, "\nX error in %s:\n", progname);
- if (XmuPrintDefaultErrorMessage (dpy, error, real_stderr))
- saver_exit (si, -1);
- else
- fprintf (real_stderr, " (nonfatal.)\n");
- return 0;
-}
+#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 */
-static void
-initialize_connection (saver_info *si, int argc, char **argv)
-{
- int i;
- Widget toplevel_shell = XtAppInitialize (&si->app, progclass,
- options, XtNumber (options),
- &argc, argv, defaults, 0, 0);
+ 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->db = XtDatabase (si->dpy);
+ si->prefs.db = XtDatabase (si->dpy);
XtGetApplicationNameAndClass (si->dpy, &progname, &progclass);
- if(strlen(progname) > 100) progname [99] = 0; /* keep it short. */
-
- db = si->db; /* resources.c needs this */
-
- if (argc == 2 && !strcmp (argv[1], "-help"))
- do_help (si);
-
- else if (argc == 2 && !strcmp (argv[1], "-debug"))
- si->prefs.debug_p = True; /* no resource for this one, out of paranoia. */
+ if(strlen(progname) > 100) /* keep it short. */
+ progname [99] = 0;
- else if (argc > 1)
- {
- const char *s = argv[1];
- fprintf (stderr, "%s: unknown option \"%s\". Try \"-help\".\n",
- progname, 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, "-lock") ||
- !strcmp (s, "-version") ||
- !strcmp (s, "-time"))
- {
- fprintf (stderr, "\n\
- However, %s is an option to the `xscreensaver-command' program.\n\
- 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-command'. See the man pages for details,\n\
- or check the web page: http://people.netscape.com/jwz/xscreensaver/\n\n",
- s);
-
- /* Since version 1.21 renamed the "-lock" option to "-lock-mode",
- suggest that explicitly. */
- if (!strcmp (s, "-lock"))
- fprintf (stderr, "\
- Or perhaps you meant either the \"-lock-mode\" or the\n\
- \"-lock-timeout <minutes>\" options to xscreensaver?\n\n");
- }
+ db = si->prefs.db; /* resources.c needs this */
- exit (1);
- }
- get_resources (si);
-#ifndef NO_SETUID
- hack_uid_warn (si);
-#endif /* NO_SETUID */
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_TIME = XInternAtom (si->dpy, "_SCREENSAVER_TIME", 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);
- si->nscreens = ScreenCount(si->dpy);
- si->screens = (saver_screen_info *)
- calloc(sizeof(saver_screen_info), si->nscreens);
+ return toplevel_shell;
+}
- si->default_screen = &si->screens[DefaultScreen(si->dpy)];
- for (i = 0; i < si->nscreens; i++)
+/* 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++)
{
- saver_screen_info *ssi = &si->screens[i];
- ssi->global = si;
- ssi->screen = ScreenOfDisplay (si->dpy, i);
-
- /* Note: we can't use the resource ".visual" because Xt is SO FUCKED. */
- ssi->default_visual =
- get_visual_resource (ssi->screen, "visualID", "VisualID", False);
+ if (!strcmp (argv[i], "-debug"))
+ /* no resource for this one, out of paranoia. */
+ si->prefs.debug_p = True;
- ssi->current_visual = ssi->default_visual;
- ssi->current_depth = visual_depth (ssi->screen, ssi->current_visual);
+ else if (!strcmp (argv[i], "-h") ||
+ !strcmp (argv[i], "-help") ||
+ !strcmp (argv[i], "--help"))
+ do_help (si);
- if (ssi == si->default_screen)
- /* Since this is the default screen, use the one already created. */
- ssi->toplevel_shell = toplevel_shell;
else
- /* Otherwise, each screen must have its own unmapped root widget. */
- ssi->toplevel_shell =
- XtVaAppCreateShell(progname, progclass, applicationShellWidgetClass,
- si->dpy,
- XtNscreen, ssi->screen,
- XtNvisual, ssi->current_visual,
- XtNdepth, visual_depth(ssi->screen,
- ssi->current_visual),
- 0);
+ {
+ 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");
+
+ /* Since version 1.21 renamed the "-lock" option to "-lock-mode",
+ suggest that explicitly. */
+ if (!strcmp (s, "-lock"))
+ fprintf (stderr, "\
+ Or perhaps you meant either the \"-lock-mode\" or the\n\
+ \"-lock-timeout <minutes>\" options to 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
-initialize (saver_info *si, int argc, char **argv)
+print_banner (saver_info *si)
{
- int i;
saver_preferences *p = &si->prefs;
- Bool initial_demo_mode_p = False;
- si->version = (char *) malloc (5);
- memcpy (si->version, screensaver_id + 17, 4);
- si->version [4] = 0;
- progname = argv[0]; /* reset later; this is for the benefit of lock_init() */
- if(strlen(progname) > 100) progname[99] = 0; /* keep it short. */
+ /* 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 ("verbose", "Boolean"));
-#ifdef NO_LOCKING
- si->locking_disabled_p = True;
- si->nolock_reason = "not compiled with locking support";
-#else
- si->locking_disabled_p = False;
+ /* Ditto, for the locking_disabled_p message. */
+ p->lock_p = get_boolean_resource ("lock", "Boolean");
-#ifdef SCO
- set_auth_parameters(argc, argv);
-#endif
+ if (p->verbose_p)
+ fprintf (stderr,
+ "%s %s, copyright (c) 1991-2004 "
+ "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 (! lock_init (argc, argv)) /* before hack_uid() for proper permissions */
+ if (p->verbose_p)
{
- si->locking_disabled_p = True;
- si->nolock_reason = "error getting password";
+ 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());
}
-#endif
+}
-#ifndef NO_SETUID
- hack_uid (si);
-#endif
+static void
+print_lock_failure_banner (saver_info *si)
+{
+ saver_preferences *p = &si->prefs;
- progclass = "XScreenSaver";
+ /* 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());
+ }
- /* remove -initial-demo-mode switch before saving argv */
- for (i = 1; i < argc; i++)
- while (!strcmp ("-initial-demo-mode", argv [i]))
- {
- int j;
- initial_demo_mode_p = True;
- for (j = i; j < argc; j++)
- argv [j] = argv [j+1];
- argv [j] = 0;
- argc--;
- if (argc <= i) break;
- }
- save_argv (argc, argv);
- initialize_connection (si, argc, argv);
+}
- if (p->verbose_p)
- printf ("\
-%s %s, copyright (c) 1991-1998 by Jamie Zawinski <jwz@netscape.com>\n\
- pid = %d.\n", progname, si->version, (int) getpid ());
-
- for (i = 0; i < si->nscreens; i++)
- if (ensure_no_screensaver_running (si->dpy, si->screens[i].screen))
- exit (1);
+/* 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)
+{
+ Bool found_any_writable_cells = False;
+ int i;
- si->demo_mode_p = initial_demo_mode_p;
- srandom ((int) time ((time_t *) 0));
+# ifdef HAVE_XINERAMA
+ {
+ int event, error;
+ si->xinerama_p = (XineramaQueryExtension (si->dpy, &event, &error) &&
+ XineramaIsActive (si->dpy));
+ }
- if (p->use_sgi_saver_extension)
+ if (si->xinerama_p && ScreenCount (si->dpy) != 1)
{
-#ifdef HAVE_SGI_SAVER_EXTENSION
- if (! query_sgi_saver_extension (si))
- {
- fprintf (stderr,
- "%s: display %s does not support the SGI SCREEN_SAVER extension.\n",
- progname, DisplayString (si->dpy));
- p->use_sgi_saver_extension = False;
- }
- else if (p->use_mit_saver_extension)
- {
- fprintf (stderr, "%s: SGI SCREEN_SAVER extension used instead\
- of MIT-SCREEN-SAVER extension.\n",
- progname);
- p->use_mit_saver_extension = False;
- }
- else if (p->use_xidle_extension)
- {
- fprintf (stderr,
- "%s: SGI SCREEN_SAVER extension used instead of XIDLE extension.\n",
- progname);
- p->use_xidle_extension = False;
- }
-#else /* !HAVE_MIT_SAVER_EXTENSION */
- fprintf (stderr,
- "%s: not compiled with support for the SGI SCREEN_SAVER extension.\n",
- progname);
- p->use_sgi_saver_extension = False;
-#endif /* !HAVE_SGI_SAVER_EXTENSION */
+ si->xinerama_p = False;
+ if (si->prefs.verbose_p)
+ fprintf (stderr,
+ "%s: Xinerama AND %d screens? Disabling Xinerama support!\n",
+ blurb(), ScreenCount(si->dpy));
}
- if (p->use_mit_saver_extension)
+ if (si->xinerama_p)
{
-#ifdef HAVE_MIT_SAVER_EXTENSION
- if (! query_mit_saver_extension (si))
- {
- fprintf (stderr,
- "%s: display %s does not support the MIT-SCREEN-SAVER extension.\n",
- progname, DisplayString (si->dpy));
- p->use_mit_saver_extension = False;
- }
- else if (p->use_xidle_extension)
- {
- fprintf (stderr,
- "%s: MIT-SCREEN-SAVER extension used instead of XIDLE extension.\n",
- progname);
- p->use_xidle_extension = False;
- }
-#else /* !HAVE_MIT_SAVER_EXTENSION */
- fprintf (stderr,
- "%s: not compiled with support for the MIT-SCREEN-SAVER extension.\n",
- progname);
- p->use_mit_saver_extension = False;
-#endif /* !HAVE_MIT_SAVER_EXTENSION */
+ XineramaScreenInfo *xsi = XineramaQueryScreens (si->dpy, &si->nscreens);
+ if (!xsi)
+ si->xinerama_p = False;
+ else
+ {
+ si->screens = (saver_screen_info *)
+ calloc(sizeof(saver_screen_info), si->nscreens);
+ for (i = 0; i < si->nscreens; i++)
+ {
+ si->screens[i].x = xsi[i].x_org;
+ si->screens[i].y = xsi[i].y_org;
+ si->screens[i].width = xsi[i].width;
+ si->screens[i].height = xsi[i].height;
+ }
+ XFree (xsi);
+ }
+ si->default_screen = &si->screens[0];
+ si->default_screen->real_screen_p = True;
}
+# endif /* !HAVE_XINERAMA */
- if (p->use_xidle_extension)
+ if (!si->xinerama_p)
{
-#ifdef HAVE_XIDLE_EXTENSION
- int first_event, first_error;
- if (! XidleQueryExtension (si->dpy, &first_event, &first_error))
- {
- fprintf (stderr,
- "%s: display %s does not support the XIdle extension.\n",
- progname, DisplayString (si->dpy));
- p->use_xidle_extension = False;
- }
-#else /* !HAVE_XIDLE_EXTENSION */
- fprintf (stderr, "%s: not compiled with support for XIdle.\n",
- progname);
- p->use_xidle_extension = False;
-#endif /* !HAVE_XIDLE_EXTENSION */
- }
+ si->nscreens = ScreenCount(si->dpy);
+ si->screens = (saver_screen_info *)
+ calloc(sizeof(saver_screen_info), si->nscreens);
+ si->default_screen = &si->screens[DefaultScreen(si->dpy)];
- /* Call this only after having probed for presence of desired extension. */
- initialize_screensaver_window (si);
+ for (i = 0; i < si->nscreens; i++)
+ {
+ saver_screen_info *ssi = &si->screens[i];
+ ssi->width = DisplayWidth (si->dpy, i);
+ ssi->height = DisplayHeight (si->dpy, i);
+ ssi->real_screen_p = True;
+ ssi->real_screen_number = i;
+ }
+ }
- init_sigchld ();
- disable_builtin_screensaver (si, True);
+ /* In "quad mode", we use the Xinerama code to pretend that there are 4
+ screens for every physical screen, and run four times as many hacks...
+ */
+ if (si->prefs.quad_p)
+ {
+ int ns2 = si->nscreens * 4;
+ saver_screen_info *ssi2 = (saver_screen_info *)
+ calloc(sizeof(saver_screen_info), ns2);
- if (p->verbose_p && p->use_mit_saver_extension)
- fprintf (stderr, "%s: using MIT-SCREEN-SAVER server extension.\n",
- progname);
- if (p->verbose_p && p->use_sgi_saver_extension)
- fprintf (stderr, "%s: using SGI SCREEN_SAVER server extension.\n",
- progname);
- if (p->verbose_p && p->use_xidle_extension)
- fprintf (stderr, "%s: using XIdle server extension.\n",
- progname);
+ for (i = 0; i < si->nscreens; i++)
+ {
+ saver_screen_info *old = &si->screens[i];
+
+ if (si->prefs.debug_p) old->width = old->width / 2;
+
+ ssi2[i*4 ] = *old;
+ ssi2[i*4+1] = *old;
+ ssi2[i*4+2] = *old;
+ ssi2[i*4+3] = *old;
+
+ ssi2[i*4 ].width /= 2;
+ ssi2[i*4 ].height /= 2;
+
+ ssi2[i*4+1].x += ssi2[i*4 ].width;
+ ssi2[i*4+1].width -= ssi2[i*4 ].width;
+ ssi2[i*4+1].height /= 2;
+
+ ssi2[i*4+2].y += ssi2[i*4 ].height;
+ ssi2[i*4+2].width /= 2;
+ ssi2[i*4+2].height -= ssi2[i*4 ].height;
+
+ ssi2[i*4+3].x += ssi2[i*4+2].width;
+ ssi2[i*4+3].y += ssi2[i*4+2].height;
+ ssi2[i*4+3].width -= ssi2[i*4+2].width;
+ ssi2[i*4+3].height -= ssi2[i*4+2].height;
+
+ ssi2[i*4+1].real_screen_p = False;
+ ssi2[i*4+2].real_screen_p = False;
+ ssi2[i*4+3].real_screen_p = False;
+ }
+
+ si->nscreens = ns2;
+ free (si->screens);
+ si->screens = ssi2;
+ si->default_screen = &si->screens[DefaultScreen(si->dpy) * 4];
+ si->xinerama_p = True;
+ }
- initialize_stderr (si);
- XSetErrorHandler (saver_ehandler);
+ /* finish initializing the screens.
+ */
+ for (i = 0; i < si->nscreens; i++)
+ {
+ saver_screen_info *ssi = &si->screens[i];
+ ssi->global = si;
- if (initial_demo_mode_p)
- /* If the user wants demo mode, don't wait around before doing it. */
- p->initial_delay = 0;
+ ssi->number = i;
+ ssi->screen = ScreenOfDisplay (si->dpy, ssi->real_screen_number);
- if (!p->use_xidle_extension &&
- !p->use_mit_saver_extension &&
- !p->use_sgi_saver_extension)
- {
- if (p->initial_delay)
+ if (!si->xinerama_p)
+ {
+ ssi->width = WidthOfScreen (ssi->screen);
+ ssi->height = HeightOfScreen (ssi->screen);
+ }
+
+ /* Note: we can't use the resource ".visual" because Xt is SO FUCKED. */
+ ssi->default_visual =
+ get_visual_resource (ssi->screen, "visualID", "VisualID", False);
+
+ ssi->current_visual = ssi->default_visual;
+ ssi->current_depth = visual_depth (ssi->screen, ssi->current_visual);
+
+ /* Execute a subprocess to find the GL visual. */
+ ssi->best_gl_visual = get_best_gl_visual (ssi);
+
+ if (ssi == si->default_screen)
+ /* Since this is the default screen, use the one already created. */
+ ssi->toplevel_shell = toplevel_shell;
+ else
+ /* Otherwise, each screen must have its own unmapped root widget. */
+ 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);
+
+ if (! found_any_writable_cells)
{
- if (p->verbose_p)
- {
- printf ("%s: waiting for %d second%s...", progname,
- (int) p->initial_delay,
- (p->initial_delay == 1 ? "" : "s"));
- fflush (stdout);
- }
- sleep (p->initial_delay);
- if (p->verbose_p)
- printf (" done.\n");
+ /* 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.
+ */
+ if (has_writable_cells (ssi->screen, ssi->current_visual) ||
+ get_visual (ssi->screen, "PseudoColor", True, False) ||
+ get_visual (ssi->screen, "GrayScale", True, False))
+ found_any_writable_cells = True;
}
+ }
+
+ si->fading_possible_p = found_any_writable_cells;
+
+#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;
+ 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;
+
+#ifdef HAVE_XIDLE_EXTENSION
+ server_has_xidle_extension_p = query_xidle_extension (si);
+#endif
+#ifdef HAVE_SGI_SAVER_EXTENSION
+ server_has_sgi_saver_extension_p = query_sgi_saver_extension (si);
+#endif
+#ifdef HAVE_MIT_SAVER_EXTENSION
+ server_has_mit_saver_extension_p = query_mit_saver_extension (si);
+#endif
+#ifdef HAVE_PROC_INTERRUPTS
+ system_has_proc_interrupts_p = query_proc_interrupts_available (si, &piwhy);
+#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());
+ }
+
+ /* These are incompatible (or at least, our support for them is...) */
+ if (si->xinerama_p && si->using_mit_saver_extension)
+ {
+ si->using_mit_saver_extension = False;
+ if (p->verbose_p)
+ fprintf (stderr, "%s: Xinerama in use: disabling MIT-SCREEN-SAVER.\n",
+ blurb());
+ }
+
+ 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());
+ }
+}
+
+
+/* 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)
{
- printf ("%s: selecting events on extant windows...", progname);
+ 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");
+}
- /* 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++)
- start_notice_events_timer (si,
- RootWindowOfScreen (si->screens[i].screen));
+void
+maybe_reload_init_file (saver_info *si)
+{
+ saver_preferences *p = &si->prefs;
+ if (init_file_changed_p (p))
+ {
if (p->verbose_p)
- printf (" done.\n");
+ fprintf (stderr, "%s: file \"%s\" has changed, reloading.\n",
+ blurb(), init_file_name());
+
+ load_init_file (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_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;
+
while (1)
{
- if (! si->demo_mode_p)
- sleep_until_idle (si, True);
+ Bool was_locked = False;
-#ifndef NO_DEMO_MODE
- if (si->demo_mode_p)
- demo_mode (si);
- else
-#endif /* !NO_DEMO_MODE */
+ 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 (p->verbose_p)
- printf ("%s: user is idle; waking up at %s.\n", progname,
- timestring());
- blank_screen (si);
- spawn_screenhack (si, True);
- if (p->cycle)
- si->cycle_id = XtAppAddTimeOut (si->app, p->cycle, cycle_timer,
- (XtPointer) si);
+ if (si->demoing_p)
+ fprintf (stderr, "%s: demoing %d at %s.\n", blurb(),
+ si->selection_mode, timestring());
+ else
+ fprintf (stderr, "%s: blanking screen at %s.\n", blurb(),
+ timestring());
+ }
+
+ maybe_reload_init_file (si);
+
+ if (p->mode == DONT_BLANK)
+ {
+ if (p->verbose_p)
+ fprintf (stderr, "%s: idle with blanking disabled at %s.\n",
+ blurb(), timestring());
+
+ /* 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.
+ */
+ continue;
+ }
+
+ 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.
+
+ So, just go around the loop again and wait for the
+ next bout of idleness.
+ */
+
+ fprintf (stderr,
+ "%s: unable to grab keyboard or mouse! Blanking aborted.\n",
+ blurb());
+ continue;
+ }
+
+ kill_screenhack (si);
+
+ if (!si->throttled_p)
+ spawn_screenhack (si, True);
+ else if (p->verbose_p)
+ fprintf (stderr, "%s: not launching hack (throttled.)\n", blurb());
+
+ /* 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
- if (p->lock_p && p->lock_timeout == 0)
- si->locked_p = True;
- if (p->lock_p && !si->locked_p)
- /* locked_p might be true already because of ClientMessage */
- si->lock_id = XtAppAddTimeOut (si->app, p->lock_timeout,
- activate_lock_timer,
- (XtPointer) si);
+ /* Maybe start locking the screen.
+ */
+ {
+ Time lock_timeout = p->lock_timeout;
+
+ 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 */
- PASSWD_INVALID:
- sleep_until_idle (si, False); /* until not idle */
+ 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
- if (si->locked_p)
- {
- Bool val;
- if (si->locking_disabled_p) abort ();
- si->dbox_up_p = True;
-
- /* We used to ungrab the keyboard here, before calling unlock_p()
- to pop up the dialog box. This left the keyboard ungrabbed
- for a small window, during an insecure state. Bennett Todd
- was seeing the bahavior that, when the load was high, he could
- actually get characters through to a shell under the saver
- window (he accidentally typed his password there...)
-
- So the ungrab has been moved down into pop_passwd_dialog()
- just after the server is grabbed, closing this window
- entirely.
- */
- /* ungrab_keyboard_and_mouse (si); */
-
- {
- saver_screen_info *ssi = si->default_screen;
- suspend_screenhack (si, True);
- XUndefineCursor (si->dpy, ssi->screensaver_window);
- if (p->verbose_p)
- printf ("%s: prompting for password.\n", progname);
- val = unlock_p (si);
- if (p->verbose_p && val == False)
- printf ("%s: password incorrect!\n", progname);
- si->dbox_up_p = False;
- XDefineCursor (si->dpy, ssi->screensaver_window, ssi->cursor);
- suspend_screenhack (si, False);
-
- /* I think this grab is now redundant, but it shouldn't hurt.
- */
- if (!si->demo_mode_p)
- grab_keyboard_and_mouse (si, ssi->screensaver_window,
- ssi->cursor);
- }
-
- if (! val)
- goto PASSWD_INVALID;
- si->locked_p = False;
- }
+ /* 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;
+ suspend_screenhack (si, True);
+ 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);
+ suspend_screenhack (si, 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);
+ }
+ }
#endif /* !NO_LOCKING */
- /* Let's kill it before unblanking, to get it to stop drawing as
- soon as possible... */
- kill_screenhack (si);
- unblank_screen (si);
+ } while (!ok_to_unblank);
- if (si->cycle_id)
- {
- XtRemoveTimeOut (si->cycle_id);
- si->cycle_id = 0;
- }
-#ifndef NO_LOCKING
- if (si->lock_id)
- {
- XtRemoveTimeOut (si->lock_id);
- si->lock_id = 0;
- }
-#endif /* !NO_LOCKING */
+ if (p->verbose_p)
+ fprintf (stderr, "%s: unblanking screen at %s.\n",
+ blurb(), timestring ());
+
+ /* Kill before unblanking, to stop drawing as soon as possible. */
+ kill_screenhack (si);
+ 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 (p->verbose_p)
- printf ("%s: user is active; going to sleep at %s.\n", progname,
- timestring ());
+ if (si->lock_id)
+ {
+ XtRemoveTimeOut (si->lock_id);
+ si->lock_id = 0;
}
+
+ /* It's possible that a race condition could have led to the saver
+ window being unexpectedly still mapped. This can happen like so:
+
+ - screen is blanked
+ - hack is launched
+ - that hack tries to grab a screen image (it does this by
+ first unmapping the saver window, then remapping it.)
+ - hack unmaps window
+ - hack waits
+ - user becomes active
+ - hack re-maps window (*)
+ - driver kills subprocess
+ - driver unmaps window (**)
+
+ The race is that (*) might have been sent to the server before
+ the client process was killed, but, due to scheduling randomness,
+ might not have been received by the server until after (**).
+ In other words, (*) and (**) might happen out of order, meaning
+ the driver will unmap the window, and then after that, the
+ recently-dead client will re-map it. This leaves the user
+ locked out (it looks like a desktop, but it's not!)
+
+ To avoid this: after un-blanking the screen, sleep for a second,
+ and then really make sure the window is unmapped.
+
+ Update: actually, let's do that once a second for 8 seconds,
+ because sometimes the machine is slow, and we miss...
+ */
+ {
+ int i, j;
+ for (j = 0; j < 8; j++)
+ {
+ XSync (si->dpy, False);
+ sleep (1);
+ for (i = 0; i < si->nscreens; i++)
+ {
+ saver_screen_info *ssi = &si->screens[i];
+ Window w = ssi->screensaver_window;
+ XWindowAttributes xgwa;
+ XGetWindowAttributes (si->dpy, w, &xgwa);
+ if (xgwa.map_state != IsUnmapped)
+ {
+ if (p->verbose_p)
+ fprintf (stderr,
+ "%s: %d: client race! emergency unmap 0x%lx.\n",
+ blurb(), i, (unsigned long) w);
+ XUnmapWindow (si->dpy, w);
+ }
+ }
+ XSync (si->dpy, False);
+ }
+ }
}
}
+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;
+ int i;
+
+ 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);
+
+ shell = connect_to_server (si, &argc, argv);
+ process_command_line (si, &argc, argv);
+ print_banner (si);
+
+ load_init_file (p); /* must be before initialize_per_screen_info() */
+ 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);
+ }
+
+ 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_standby / 1000,
+ p->dpms_suspend / 1000,
+ p->dpms_off / 1000,
+ False);
+
+ initialize_stderr (si);
+ handle_signals (si);
+
+ 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);
+}
+
+
\f
+/* 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);
+ }
+}
+
+
+static 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)
+{
+ char *str = XGetAtomName_safe (si->dpy, event->xclient.message_type);
+ Window w = event->xclient.window;
+ char wdesc[255];
+ int screen = 0;
+
+ *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");
+ break;
+ }
+
+ 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);
+}
Bool
handle_clientmessage (saver_info *si, XEvent *event, Bool until_idle_p)
{
saver_preferences *p = &si->prefs;
Atom type = 0;
- if (event->xclient.message_type != XA_SCREENSAVER)
- {
- char *str;
- str = XGetAtomName (si->dpy, event->xclient.message_type);
- fprintf (stderr, "%s: unrecognised ClientMessage type %s received\n",
- progname, (str ? str : "(null)"));
- if (str) XFree (str);
- return False;
- }
- if (event->xclient.format != 32)
+ 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)
{
- fprintf (stderr, "%s: ClientMessage of format %d received, not 32\n",
- progname, event->xclient.format);
+ bogus_clientmessage_warning (si, event);
return False;
}
{
if (until_idle_p)
{
- if (p->verbose_p)
- printf ("%s: ACTIVATE ClientMessage received.\n", progname);
- if (p->use_mit_saver_extension || p->use_sgi_saver_extension)
+ 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;
return True;
}
}
- fprintf (stderr,
- "%s: ClientMessage ACTIVATE received while already active.\n",
- progname);
+ clientmessage_response(si, window, True,
+ "ClientMessage ACTIVATE received while already active.",
+ "already active.");
}
else if (type == XA_DEACTIVATE)
{
if (! until_idle_p)
{
- if (p->verbose_p)
- printf ("%s: DEACTIVATE ClientMessage received.\n", progname);
- if (p->use_mit_saver_extension || p->use_sgi_saver_extension)
+ 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;
return True;
}
}
- fprintf (stderr,
- "%s: ClientMessage DEACTIVATE received while inactive.\n",
- progname);
+ 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_CYCLE)
{
if (! until_idle_p)
{
- if (p->verbose_p)
- printf ("%s: CYCLE ClientMessage received.\n", progname);
+ 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;
}
- fprintf (stderr, "%s: ClientMessage CYCLE received while inactive.\n",
- progname);
+ clientmessage_response(si, window, True,
+ "ClientMessage CYCLE received while inactive.",
+ "not active.");
}
else if (type == XA_NEXT || type == XA_PREV)
{
- if (p->verbose_p)
- printf ("%s: %s ClientMessage received.\n", progname,
- (type == XA_NEXT ? "NEXT" : "PREV"));
- si->next_mode_p = 1 + (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)
{
/* Ignore EXIT message if the screen is locked. */
if (until_idle_p || !si->locked_p)
{
- if (p->verbose_p)
- printf ("%s: EXIT ClientMessage received.\n", progname);
+ clientmessage_response (si, window, False,
+ "EXIT ClientMessage received.",
+ "exiting.");
if (! until_idle_p)
{
unblank_screen (si);
kill_screenhack (si);
XSync (si->dpy, False);
}
- saver_exit (si, 0);
+ saver_exit (si, 0, 0);
}
else
- fprintf (stderr, "%s: EXIT ClientMessage received while locked.\n",
- progname);
+ clientmessage_response (si, window, True,
+ "EXIT ClientMessage received while locked.",
+ "screen is locked.");
}
else if (type == XA_RESTART)
{
*/
if (until_idle_p || !si->locked_p)
{
- if (p->verbose_p)
- printf ("%s: RESTART ClientMessage received.\n", progname);
+ clientmessage_response (si, window, False,
+ "RESTART ClientMessage received.",
+ "restarting.");
if (! until_idle_p)
{
unblank_screen (si);
XSync (si->dpy, False);
}
- /* make sure error message shows up before exit. */
- if (real_stderr && stderr != real_stderr)
- dup2 (fileno(real_stderr), fileno(stderr));
-
- restart_process (si);
- exit (1); /* shouldn't get here; but if restarting didn't work,
- make this command be the same as EXIT. */
+ restart_process (si); /* does not return */
+ abort();
}
else
- fprintf(stderr, "%s: RESTART ClientMessage received while locked.\n",
- progname);
+ clientmessage_response (si, window, True,
+ "RESTART ClientMessage received while locked.",
+ "screen is locked.");
}
else if (type == XA_DEMO)
{
-#ifdef NO_DEMO_MODE
- fprintf (stderr, "%s: not compiled with support for DEMO mode\n",
- progname);
-#else
- if (until_idle_p)
+ long arg = event->xclient.data.l[1];
+ Bool demo_one_hack_p = (arg == 300);
+
+ if (demo_one_hack_p)
{
- if (p->verbose_p)
- printf ("%s: DEMO ClientMessage received.\n", progname);
- si->demo_mode_p = True;
- return True;
+ 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.");
}
- fprintf (stderr,
- "%s: DEMO ClientMessage received while active.\n", progname);
-#endif
+ }
+ 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
- fprintf (stderr, "%s: not compiled with support for LOCK mode\n",
- progname);
-#else
- if (si->locking_disabled_p)
- fprintf (stderr,
- "%s: LOCK ClientMessage received, but locking is disabled.\n",
- progname);
+ clientmessage_response (si, window, True,
+ "not compiled with support for locking.",
+ "locking not enabled.");
+#else /* !NO_LOCKING */
+ if (p->mode == DONT_BLANK)
+ clientmessage_response(si, window, True,
+ "LOCK ClientMessage received in DONT_BLANK mode.",
+ "screen blanking is currently disabled.");
+ else 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)
- fprintf (stderr,
- "%s: LOCK ClientMessage received while already locked.\n",
- progname);
+ clientmessage_response (si, window, True,
+ "LOCK ClientMessage received while already locked.",
+ "already locked.");
else
{
- si->locked_p = True;
- if (p->verbose_p)
- printf ("%s: LOCK ClientMessage received;%s locking.\n",
- progname, until_idle_p ? " activating and" : "");
+ 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);
+ 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 */
{
if (until_idle_p)
{
- if (p->use_mit_saver_extension || p->use_sgi_saver_extension)
+ if (si->using_mit_saver_extension ||
+ si->using_sgi_saver_extension)
{
XForceScreenSaver (si->dpy, ScreenSaverActive);
return False;
}
}
}
-#endif
+#endif /* !NO_LOCKING */
+ }
+ else if (type == XA_THROTTLE)
+ {
+ 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 = (type ? XGetAtomName(si->dpy, type) : 0);
+ str = XGetAtomName_safe (si->dpy, type);
+
if (str)
- fprintf (stderr,
- "%s: unrecognised screensaver ClientMessage %s received\n",
- progname, str);
+ {
+ if (strlen (str) > 80)
+ strcpy (str+70, "...");
+ sprintf (buf, "unrecognised screensaver ClientMessage %s received.",
+ str);
+ free (str);
+ }
else
- fprintf (stderr,
- "%s: unrecognised screensaver ClientMessage 0x%x received\n",
- progname, (unsigned int) event->xclient.data.l[0]);
- if (str) XFree (str);
+ {
+ sprintf (buf,
+ "unrecognised screensaver ClientMessage 0x%x received.",
+ (unsigned int) event->xclient.data.l[0]);
+ }
+
+ clientmessage_response (si, window, True, buf, buf);
}
return False;
}
+
+\f
+/* 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;
+ } exts[] = {
+
+ { "SCREEN_SAVER", /* underscore */ "SGI Screen-Saver",
+# ifdef HAVE_SGI_SAVER_EXTENSION
+ True
+# else
+ False
+# endif
+ }, { "SCREEN-SAVER", /* dash */ "SGI Screen-Saver",
+# ifdef HAVE_SGI_SAVER_EXTENSION
+ True
+# else
+ False
+# endif
+ }, { "MIT-SCREEN-SAVER", "MIT Screen-Saver",
+# ifdef HAVE_MIT_SAVER_EXTENSION
+ True
+# else
+ False
+# endif
+ }, { "XIDLE", "XIdle",
+# ifdef HAVE_XIDLE_EXTENSION
+ True
+# else
+ False
+# endif
+ }, { "SGI-VIDEO-CONTROL", "SGI Video-Control",
+# ifdef HAVE_SGI_VC_EXTENSION
+ True
+# else
+ False
+# endif
+ }, { "READDISPLAY", "SGI Read-Display",
+# ifdef HAVE_READ_DISPLAY_EXTENSION
+ True
+# else
+ False
+# endif
+ }, { "MIT-SHM", "Shared Memory",
+# ifdef HAVE_XSHM_EXTENSION
+ True
+# else
+ False
+# endif
+ }, { "DOUBLE-BUFFER", "Double-Buffering",
+# ifdef HAVE_DOUBLE_BUFFER_EXTENSION
+ True
+# else
+ False
+# endif
+ }, { "DPMS", "Power Management",
+# ifdef HAVE_DPMS_EXTENSION
+ True
+# else
+ False
+# endif
+ }, { "GLX", "GLX",
+# ifdef HAVE_GL
+ True
+# else
+ False
+# endif
+ }, { "XFree86-VidModeExtension", "XF86 Video-Mode",
+# ifdef HAVE_XF86VMODE
+ True
+# else
+ False
+# endif
+ }, { "XINERAMA", "Xinerama",
+ True
+ }, { "Apple-DRI", "Apple-DRI (XDarwin)",
+ True
+ },
+ };
+
+ fprintf (stderr, "%s: running on display \"%s\" (%d %sscreen%s).\n",
+ blurb(),
+ DisplayString(si->dpy),
+ si->nscreens,
+ (si->xinerama_p ? "Xinerama " : ""),
+ (si->nscreens == 1 ? "" : "s"));
+ 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 j;
+ if (!XQueryExtension (si->dpy, exts[i].name, &op, &event, &error))
+ continue;
+ sprintf (buf, "%s: ", blurb());
+ j = strlen (buf);
+ strcat (buf, exts[i].desc);
+ if (!exts[i].useful_p)
+ {
+ int k = j + 18;
+ while (strlen (buf) < k) strcat (buf, " ");
+ strcat (buf, "<-- not supported at compile time!");
+ }
+ fprintf (stderr, "%s\n", buf);
+ }
+
+ 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].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");
+ }
+ }
+
+ if (si->xinerama_p)
+ {
+ fprintf (stderr, "%s: Xinerama layout:\n", blurb());
+ for (i = 0; i < si->nscreens; i++)
+ {
+ saver_screen_info *ssi = &si->screens[i];
+ fprintf (stderr, "%s: %c %d/%d: %dx%d+%d+%d\n",
+ blurb(),
+ (ssi->real_screen_p ? '+' : ' '),
+ ssi->number, ssi->real_screen_number,
+ ssi->width, ssi->height, ssi->x, ssi->y);
+ }
+ }
+}
+
+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
+ {
+ /* 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)
+{
+#ifdef HAVE_SBRK
+ 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 */
+}