X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=driver%2Fxscreensaver.c;h=bc20b12d6846b037c185b10c1dbbe8203d8d35fc;hb=2c902d6065f9856adf31e8540a94f1e42e68e905;hp=628bcf1d442b4090899e397bed66979fbddf7de6;hpb=a94197e76a5dea5cb60542840809d6c20d0abbf3;p=xscreensaver diff --git a/driver/xscreensaver.c b/driver/xscreensaver.c index 628bcf1d..bc20b12d 100644 --- a/driver/xscreensaver.c +++ b/driver/xscreensaver.c @@ -289,6 +289,7 @@ 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; @@ -301,17 +302,27 @@ saver_ehandler (Display *dpy, XErrorEvent *error) for (i = 0; i < si->nscreens; i++) fprintf (real_stderr, "%s: screen %d: 0x%x, 0x%x, 0x%x\n", blurb(), i, - RootWindowOfScreen (si->screens[i].screen), - si->screens[i].real_vroot, - si->screens[i].screensaver_window); + (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"); - if (XmuPrintDefaultErrorMessage (dpy, error, real_stderr)) + 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 { - fprintf (real_stderr, "\n"); if (si->prefs.xsync_p) { saver_exit (si, -1, "because of synchronous X Error"); @@ -342,8 +353,7 @@ saver_ehandler (Display *dpy, XErrorEvent *error) saver_exit (si, -1, 0); } } - else - fprintf (real_stderr, " (nonfatal.)\n"); + return 0; } @@ -483,9 +493,38 @@ lock_initialization (saver_info *si, int *argc, char **argv) si->locking_disabled_p = True; si->nolock_reason = "running under GDM"; } -#endif /* NO_LOCKING */ - hack_uid (si); + /* 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"; + } + } + +#endif /* NO_LOCKING */ } @@ -500,13 +539,17 @@ connect_to_server (saver_info *si, int *argc, char **argv) char *d = getenv ("DISPLAY"); if (!d || !*d) { - char ndpy[] = "DISPLAY=:0.0"; + 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 */ @@ -676,11 +719,17 @@ print_banner (saver_info *si) 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 (p->lock_p && si->locking_disabled_p) + if (si->locking_disabled_p) { p->lock_p = False; fprintf (stderr, "%s: locking is disabled (%s).\n", blurb(), @@ -695,6 +744,7 @@ print_banner (saver_info *si) "\t See the manual for details.\n", blurb()); } + } @@ -953,7 +1003,13 @@ main_loop (saver_info *si) while (1) { Bool was_locked = False; + + if (p->verbose_p) + fprintf (stderr, "%s: awaiting idleness.\n", blurb()); + + check_for_leaks ("unblanked A"); sleep_until_idle (si, True); + check_for_leaks ("unblanked B"); if (p->verbose_p) { @@ -1059,7 +1115,10 @@ main_loop (saver_info *si) 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 @@ -1181,13 +1240,11 @@ main_loop (saver_info *si) } XSync (si->dpy, False); } - - if (p->verbose_p) - fprintf (stderr, "%s: awaiting idleness.\n", blurb()); } } static void analyze_display (saver_info *si); +static void fix_fds (void); int main (int argc, char **argv) @@ -1201,6 +1258,8 @@ main (int argc, char **argv) memset(si, 0, sizeof(*si)); global_si_kludge = si; /* I hate C so much... */ + fix_fds(); + # undef ya_rand_init ya_rand_init (0); @@ -1229,6 +1288,7 @@ main (int argc, char **argv) exit (1); lock_initialization (si, &argc, argv); + print_lock_failure_banner (si); if (p->xsync_p) XSynchronize (si->dpy, True); @@ -1259,6 +1319,36 @@ main (int argc, char **argv) return 0; } +static void +fix_fds (void) +{ + /* Bad Things Happen if stdin, stdout, and stderr have been closed + (as by the `sh incantation "xscreensaver >&- 2>&-"). When you do + that, the X connection gets allocated to one of these fds, and + then some random library writes to stderr, and random bits get + stuffed down the X pipe, causing "Xlib: sequence lost" errors. + So, we cause the first three file descriptors to be open to + /dev/null if they aren't open to something else already. This + must be done before any other files are opened (or the closing + of that other file will again free up one of the "magic" first + three FDs.) + + We do this by opening /dev/null three times, and then closing + those fds, *unless* any of them got allocated as #0, #1, or #2, + in which case we leave them open. Gag. + + Really, this crap is technically required of *every* X program, + if you want it to be robust in the face of "2>&-". + */ + int fd0 = open ("/dev/null", O_RDWR); + int fd1 = open ("/dev/null", O_RDWR); + int fd2 = open ("/dev/null", O_RDWR); + if (fd0 > 2) close (fd0); + if (fd1 > 2) close (fd1); + if (fd2 > 2) close (fd2); +} + + /* Processing ClientMessage events. */ @@ -1298,7 +1388,7 @@ XGetAtomName_safe (Display *dpy, Atom atom) else { char buf[100]; - sprintf (buf, "<>", (unsigned long) atom); + sprintf (buf, "<>", (unsigned int) atom); return strdup (buf); } } @@ -1842,6 +1932,8 @@ analyze_display (saver_info *si) # endif }, { "XINERAMA", "Xinerama", True + }, { "Apple-DRI", "Apple-DRI (XDarwin)", + True }, }; @@ -1954,3 +2046,20 @@ display_is_on_console_p (saver_info *si) } 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 */ +}