From http://www.jwz.org/xscreensaver/xscreensaver-5.16.tar.gz
[xscreensaver] / driver / timers.c
1 /* timers.c --- detecting when the user is idle, and other timer-related tasks.
2  * xscreensaver, Copyright (c) 1991-2012 Jamie Zawinski <jwz@jwz.org>
3  *
4  * Permission to use, copy, modify, distribute, and sell this software and its
5  * documentation for any purpose is hereby granted without fee, provided that
6  * the above copyright notice appear in all copies and that both that
7  * copyright notice and this permission notice appear in supporting
8  * documentation.  No representations are made about the suitability of this
9  * software for any purpose.  It is provided "as is" without express or 
10  * implied warranty.
11  */
12
13 #ifdef HAVE_CONFIG_H
14 # include "config.h"
15 #endif
16
17 #include <stdio.h>
18 #include <X11/Xlib.h>
19 #include <X11/Intrinsic.h>
20 #include <X11/Xos.h>
21 #include <time.h>
22 #include <sys/time.h>
23 #ifdef HAVE_XMU
24 # ifndef VMS
25 #  include <X11/Xmu/Error.h>
26 # else /* VMS */
27 #  include <Xmu/Error.h>
28 # endif /* VMS */
29 # else /* !HAVE_XMU */
30 # include "xmu.h"
31 #endif /* !HAVE_XMU */
32
33 #ifdef HAVE_XIDLE_EXTENSION
34 #include <X11/extensions/xidle.h>
35 #endif /* HAVE_XIDLE_EXTENSION */
36
37 #ifdef HAVE_MIT_SAVER_EXTENSION
38 #include <X11/extensions/scrnsaver.h>
39 #endif /* HAVE_MIT_SAVER_EXTENSION */
40
41 #ifdef HAVE_SGI_SAVER_EXTENSION
42 #include <X11/extensions/XScreenSaver.h>
43 #endif /* HAVE_SGI_SAVER_EXTENSION */
44
45 #ifdef HAVE_RANDR
46 #include <X11/extensions/Xrandr.h>
47 #endif /* HAVE_RANDR */
48
49 #include "xscreensaver.h"
50
51 #undef ABS
52 #define ABS(x)((x)<0?-(x):(x))
53
54 #undef MAX
55 #define MAX(x,y)((x)>(y)?(x):(y))
56
57
58 #ifdef HAVE_PROC_INTERRUPTS
59 static Bool proc_interrupts_activity_p (saver_info *si);
60 #endif /* HAVE_PROC_INTERRUPTS */
61
62 static void check_for_clock_skew (saver_info *si);
63
64
65 void
66 idle_timer (XtPointer closure, XtIntervalId *id)
67 {
68   saver_info *si = (saver_info *) closure;
69
70   /* What an amazingly shitty design.  Not only does Xt execute timeout
71      events from XtAppNextEvent() instead of from XtDispatchEvent(), but
72      there is no way to tell Xt to block until there is an X event OR a
73      timeout happens.  Once your timeout proc is called, XtAppNextEvent()
74      still won't return until a "real" X event comes in.
75
76      So this function pushes a stupid, gratuitous, unnecessary event back
77      on the event queue to force XtAppNextEvent to return Right Fucking Now.
78      When the code in sleep_until_idle() sees an event of type XAnyEvent,
79      which the server never generates, it knows that a timeout has occurred.
80    */
81   XEvent fake_event;
82   fake_event.type = 0;  /* XAnyEvent type, ignored. */
83   fake_event.xany.display = si->dpy;
84   fake_event.xany.window  = 0;
85   XPutBackEvent (si->dpy, &fake_event);
86
87   /* If we are the timer that just went off, clear the pointer to the id. */
88   if (id)
89     {
90       if (si->timer_id && *id != si->timer_id)
91         abort();  /* oops, scheduled timer twice?? */
92       si->timer_id = 0;
93     }
94 }
95
96
97 void
98 schedule_wakeup_event (saver_info *si, Time when, Bool verbose_p)
99 {
100   if (si->timer_id)
101     {
102       if (verbose_p)
103         fprintf (stderr, "%s: idle_timer already running\n", blurb());
104       return;
105     }
106
107   /* Wake up periodically to ask the server if we are idle. */
108   si->timer_id = XtAppAddTimeOut (si->app, when, idle_timer,
109                                   (XtPointer) si);
110
111   if (verbose_p)
112     fprintf (stderr, "%s: starting idle_timer (%ld, %ld)\n",
113              blurb(), when, si->timer_id);
114 }
115
116
117 static void
118 notice_events (saver_info *si, Window window, Bool top_p)
119 {
120   saver_preferences *p = &si->prefs;
121   XWindowAttributes attrs;
122   unsigned long events;
123   Window root, parent, *kids;
124   unsigned int nkids;
125   int screen_no;
126
127   if (XtWindowToWidget (si->dpy, window))
128     /* If it's one of ours, don't mess up its event mask. */
129     return;
130
131   if (!XQueryTree (si->dpy, window, &root, &parent, &kids, &nkids))
132     return;
133   if (window == root)
134     top_p = False;
135
136   /* Figure out which screen this window is on, for the diagnostics. */
137   for (screen_no = 0; screen_no < si->nscreens; screen_no++)
138     if (root == RootWindowOfScreen (si->screens[screen_no].screen))
139       break;
140
141   XGetWindowAttributes (si->dpy, window, &attrs);
142   events = ((attrs.all_event_masks | attrs.do_not_propagate_mask)
143             & KeyPressMask);
144
145   /* Select for SubstructureNotify on all windows.
146      Select for KeyPress on all windows that already have it selected.
147
148      Note that we can't select for ButtonPress, because of X braindamage:
149      only one client at a time may select for ButtonPress on a given
150      window, though any number can select for KeyPress.  Someone explain
151      *that* to me.
152
153      So, if the user spends a while clicking the mouse without ever moving
154      the mouse or touching the keyboard, we won't know that they've been
155      active, and the screensaver will come on.  That sucks, but I don't
156      know how to get around it.
157
158      Since X presents mouse wheels as clicks, this applies to those, too:
159      scrolling through a document using only the mouse wheel doesn't
160      count as activity...  Fortunately, /proc/interrupts helps, on
161      systems that have it.  Oh, if it's a PS/2 mouse, not serial or USB.
162      This sucks!
163    */
164   XSelectInput (si->dpy, window, SubstructureNotifyMask | events);
165
166   if (top_p && p->debug_p && (events & KeyPressMask))
167     {
168       /* Only mention one window per tree (hack hack). */
169       fprintf (stderr, "%s: %d: selected KeyPress on 0x%lX\n",
170                blurb(), screen_no, (unsigned long) window);
171       top_p = False;
172     }
173
174   if (kids)
175     {
176       while (nkids)
177         notice_events (si, kids [--nkids], top_p);
178       XFree ((char *) kids);
179     }
180 }
181
182
183 int
184 BadWindow_ehandler (Display *dpy, XErrorEvent *error)
185 {
186   /* When we notice a window being created, we spawn a timer that waits
187      30 seconds or so, and then selects events on that window.  This error
188      handler is used so that we can cope with the fact that the window
189      may have been destroyed <30 seconds after it was created.
190    */
191   if (error->error_code == BadWindow ||
192       error->error_code == BadMatch ||
193       error->error_code == BadDrawable)
194     return 0;
195   else
196     return saver_ehandler (dpy, error);
197 }
198
199
200 struct notice_events_timer_arg {
201   saver_info *si;
202   Window w;
203 };
204
205 static void
206 notice_events_timer (XtPointer closure, XtIntervalId *id)
207 {
208   struct notice_events_timer_arg *arg =
209     (struct notice_events_timer_arg *) closure;
210
211   XErrorHandler old_handler = XSetErrorHandler (BadWindow_ehandler);
212
213   saver_info *si = arg->si;
214   Window window = arg->w;
215
216   free(arg);
217   notice_events (si, window, True);
218   XSync (si->dpy, False);
219   XSetErrorHandler (old_handler);
220 }
221
222 void
223 start_notice_events_timer (saver_info *si, Window w, Bool verbose_p)
224 {
225   saver_preferences *p = &si->prefs;
226   struct notice_events_timer_arg *arg =
227     (struct notice_events_timer_arg *) malloc(sizeof(*arg));
228   arg->si = si;
229   arg->w = w;
230   XtAppAddTimeOut (si->app, p->notice_events_timeout, notice_events_timer,
231                    (XtPointer) arg);
232
233   if (verbose_p)
234     fprintf (stderr, "%s: starting notice_events_timer for 0x%X (%lu)\n",
235              blurb(), (unsigned int) w, p->notice_events_timeout);
236 }
237
238
239 /* When the screensaver is active, this timer will periodically change
240    the running program.
241  */
242 void
243 cycle_timer (XtPointer closure, XtIntervalId *id)
244 {
245   saver_info *si = (saver_info *) closure;
246   saver_preferences *p = &si->prefs;
247   Time how_long = p->cycle;
248
249   if (si->selection_mode > 0 &&
250       screenhack_running_p (si))
251     /* If we're in "SELECT n" mode, the cycle timer going off will just
252        restart this same hack again.  There's not much point in doing this
253        every 5 or 10 minutes, but on the other hand, leaving one hack running
254        for days is probably not a great idea, since they tend to leak and/or
255        crash.  So, restart the thing once an hour. */
256     how_long = 1000 * 60 * 60;
257
258   if (si->dbox_up_p)
259     {
260       if (p->verbose_p)
261         fprintf (stderr, "%s: dialog box up; delaying hack change.\n",
262                  blurb());
263       how_long = 30000; /* 30 secs */
264     }
265   else
266     {
267       int i;
268       maybe_reload_init_file (si);
269       for (i = 0; i < si->nscreens; i++)
270         kill_screenhack (&si->screens[i]);
271
272       raise_window (si, True, True, False);
273
274       if (!si->throttled_p)
275         for (i = 0; i < si->nscreens; i++)
276           spawn_screenhack (&si->screens[i]);
277       else
278         {
279           if (p->verbose_p)
280             fprintf (stderr, "%s: not launching new hack (throttled.)\n",
281                      blurb());
282         }
283     }
284
285   if (how_long > 0)
286     {
287       si->cycle_id = XtAppAddTimeOut (si->app, how_long, cycle_timer,
288                                       (XtPointer) si);
289
290       if (p->debug_p)
291         fprintf (stderr, "%s: starting cycle_timer (%ld, %ld)\n",
292                  blurb(), how_long, si->cycle_id);
293     }
294   else
295     {
296       if (p->debug_p)
297         fprintf (stderr, "%s: not starting cycle_timer: how_long == %ld\n",
298                  blurb(), (unsigned long) how_long);
299     }
300 }
301
302
303 void
304 activate_lock_timer (XtPointer closure, XtIntervalId *id)
305 {
306   saver_info *si = (saver_info *) closure;
307   saver_preferences *p = &si->prefs;
308
309   if (p->verbose_p)
310     fprintf (stderr, "%s: timed out; activating lock.\n", blurb());
311   set_locked_p (si, True);
312 }
313
314
315 /* Call this when user activity (or "simulated" activity) has been noticed.
316  */
317 void
318 reset_timers (saver_info *si)
319 {
320   saver_preferences *p = &si->prefs;
321   if (si->using_mit_saver_extension || si->using_sgi_saver_extension)
322     return;
323
324   if (si->timer_id)
325     {
326       if (p->debug_p)
327         fprintf (stderr, "%s: killing idle_timer  (%ld, %ld)\n",
328                  blurb(), p->timeout, si->timer_id);
329       XtRemoveTimeOut (si->timer_id);
330       si->timer_id = 0;
331     }
332
333   schedule_wakeup_event (si, p->timeout, p->debug_p); /* sets si->timer_id */
334
335   if (si->cycle_id) abort ();   /* no cycle timer when inactive */
336
337   si->last_activity_time = time ((time_t *) 0);
338
339   /* This will (hopefully, supposedly) tell the server to re-set its
340      DPMS timer.  Without this, the -deactivate clientmessage would
341      prevent xscreensaver from blanking, but would not prevent the
342      monitor from powering down. */
343 #if 0
344   /* #### With some servers, this causes the screen to flicker every
345      time a key is pressed!  Ok, I surrender.  I give up on ever
346      having DPMS work properly.
347    */
348   XForceScreenSaver (si->dpy, ScreenSaverReset);
349
350   /* And if the monitor is already powered off, turn it on.
351      You'd think the above would do that, but apparently not? */
352   monitor_power_on (si, True);
353 #endif
354
355 }
356
357
358 /* Returns true if a mouse has moved since the last time we checked.
359    Small motions (of less than "hysteresis" pixels/second) are ignored.
360  */
361 static Bool
362 device_pointer_moved_p (saver_info *si, poll_mouse_data *last_poll_mouse,
363                         poll_mouse_data *this_poll_mouse, Bool mods_p,
364                         const char *debug_type, int debug_id)
365 {
366   saver_preferences *p = &si->prefs;
367
368   unsigned int distance, dps;
369   unsigned long seconds = 0;
370   Bool moved_p = False;
371
372   distance = MAX (ABS (last_poll_mouse->root_x - this_poll_mouse->root_x),
373                   ABS (last_poll_mouse->root_y - this_poll_mouse->root_y));
374   seconds = (this_poll_mouse->time - last_poll_mouse->time);
375
376
377   /* When the screen is blanked, we get MotionNotify events, but when not
378      blanked, we poll only every 5 seconds, and that's not enough resolution
379      to do hysteresis based on a 1 second interval.  So, assume that any
380      motion we've seen during the 5 seconds when our eyes were closed happened
381      in the last 1 second instead.
382    */
383   if (seconds > 1) seconds = 1;
384
385   dps = (seconds <= 0 ? distance : (distance / seconds));
386
387   /* Motion only counts if the rate is more than N pixels per second.
388    */
389   if (dps >= p->pointer_hysteresis &&
390       distance > 0)
391     moved_p = True;
392
393   /* If the mouse is not on this screen but used to be, that's motion.
394      If the mouse was not on this screen, but is now, that's motion.
395    */
396   {
397     Bool on_screen_p  = (this_poll_mouse->root_x != -1 &&
398                          this_poll_mouse->root_y != -1);
399     Bool was_on_screen_p = (last_poll_mouse->root_x != -1 &&
400                             last_poll_mouse->root_y != -1);
401
402     if (on_screen_p != was_on_screen_p)
403       moved_p = True;
404   }
405
406   if (p->debug_p && (distance != 0 || moved_p))
407     {
408       fprintf (stderr, "%s: %s %d: pointer %s", blurb(), debug_type, debug_id,
409                (moved_p ? "moved:  " : "ignored:"));
410       if (last_poll_mouse->root_x == -1)
411         fprintf (stderr, "off screen");
412       else
413         fprintf (stderr, "%d,%d",
414                  last_poll_mouse->root_x,
415                  last_poll_mouse->root_y);
416       fprintf (stderr, " -> ");
417       if (this_poll_mouse->root_x == -1)
418         fprintf (stderr, "off screen");
419       else
420         fprintf (stderr, "%d,%d", this_poll_mouse->root_x,
421                  this_poll_mouse->root_y);
422       if (last_poll_mouse->root_x != -1 && this_poll_mouse->root_x != -1)
423         fprintf (stderr, " (%d,%d; %d/%lu=%d)",
424                  ABS(last_poll_mouse->root_x - this_poll_mouse->root_x),
425                  ABS(last_poll_mouse->root_y - this_poll_mouse->root_y),
426                  distance, seconds, dps);
427
428       fprintf (stderr, ".\n");
429     }
430
431   if (!moved_p &&
432       mods_p &&
433       this_poll_mouse->mask != last_poll_mouse->mask)
434     {
435       moved_p = True;
436
437       if (p->debug_p)
438         fprintf (stderr, "%s: %s %d: modifiers changed: 0x%04x -> 0x%04x.\n",
439                  blurb(), debug_type, debug_id,
440                  last_poll_mouse->mask, this_poll_mouse->mask);
441     }
442
443   last_poll_mouse->child = this_poll_mouse->child;
444   last_poll_mouse->mask  = this_poll_mouse->mask;
445
446   if (moved_p || seconds > 0)
447     {
448       last_poll_mouse->time   = this_poll_mouse->time;
449       last_poll_mouse->root_x = this_poll_mouse->root_x;
450       last_poll_mouse->root_y = this_poll_mouse->root_y;
451     }
452
453   return moved_p;
454 }
455
456 /* Returns true if core mouse pointer has moved since the last time we checked.
457  */
458 static Bool
459 pointer_moved_p (saver_screen_info *ssi, Bool mods_p)
460 {
461   saver_info *si = ssi->global;
462
463   Window root;
464   poll_mouse_data this_poll_mouse;
465   int x, y;
466
467   /* don't check xinerama pseudo-screens. */
468   if (!ssi->real_screen_p) return False;
469
470   this_poll_mouse.time = time ((time_t *) 0);
471   
472   if (!XQueryPointer (si->dpy, ssi->screensaver_window, &root,
473                       &this_poll_mouse.child,
474                       &this_poll_mouse.root_x, &this_poll_mouse.root_y,
475                       &x, &y, &this_poll_mouse.mask))
476     {
477       /* If XQueryPointer() returns false, the mouse is not on this screen.
478        */
479       this_poll_mouse.root_x = -1;
480       this_poll_mouse.root_y = -1;
481       this_poll_mouse.child = 0;
482       this_poll_mouse.mask = 0;
483     }
484   else
485     si->last_activity_screen = ssi;
486
487   return device_pointer_moved_p(si, &(ssi->last_poll_mouse), &this_poll_mouse,
488                                 mods_p, "screen", ssi->number);
489 }
490
491
492 /* When we aren't using a server extension, this timer is used to periodically
493    wake up and poll the mouse position, which is possibly more reliable than
494    selecting motion events on every window.
495  */
496 static void
497 check_pointer_timer (XtPointer closure, XtIntervalId *id)
498 {
499   int i;
500   saver_info *si = (saver_info *) closure;
501   saver_preferences *p = &si->prefs;
502   Bool active_p = False;
503
504   if (!si->using_proc_interrupts &&
505       (si->using_xidle_extension ||
506        si->using_mit_saver_extension ||
507        si->using_sgi_saver_extension))
508     /* If an extension is in use, we should not be polling the mouse.
509        Unless we're also checking /proc/interrupts, in which case, we should.
510      */
511     abort ();
512
513   if (id && *id == si->check_pointer_timer_id)  /* this is us - it's expired */
514     si->check_pointer_timer_id = 0;
515
516   if (si->check_pointer_timer_id)               /* only queue one at a time */
517     XtRemoveTimeOut (si->check_pointer_timer_id);
518
519   si->check_pointer_timer_id =                  /* now re-queue */
520     XtAppAddTimeOut (si->app, p->pointer_timeout, check_pointer_timer,
521                      (XtPointer) si);
522
523   for (i = 0; i < si->nscreens; i++)
524     {
525       saver_screen_info *ssi = &si->screens[i];
526       if (pointer_moved_p (ssi, True))
527         active_p = True;
528     }
529
530 #ifdef HAVE_PROC_INTERRUPTS
531   if (!active_p &&
532       si->using_proc_interrupts &&
533       proc_interrupts_activity_p (si))
534     {
535       active_p = True;
536     }
537 #endif /* HAVE_PROC_INTERRUPTS */
538
539   if (active_p)
540     reset_timers (si);
541
542   check_for_clock_skew (si);
543 }
544
545
546 /* An unfortunate situation is this: the saver is not active, because the
547    user has been typing.  The machine is a laptop.  The user closes the lid
548    and suspends it.  The CPU halts.  Some hours later, the user opens the
549    lid.  At this point, Xt's timers will fire, and xscreensaver will blank
550    the screen.
551
552    So far so good -- well, not really, but it's the best that we can do,
553    since the OS doesn't send us a signal *before* shutdown -- but if the
554    user had delayed locking (lockTimeout > 0) then we should start off
555    in the locked state, rather than only locking N minutes from when the
556    lid was opened.  Also, eschewing fading is probably a good idea, to
557    clamp down as soon as possible.
558
559    We only do this when we'd be polling the mouse position anyway.
560    This amounts to an assumption that machines with APM support also
561    have /proc/interrupts.
562  */
563 static void
564 check_for_clock_skew (saver_info *si)
565 {
566   saver_preferences *p = &si->prefs;
567   time_t now = time ((time_t *) 0);
568   long shift = now - si->last_wall_clock_time;
569
570   if (p->debug_p)
571     {
572       int i = (si->last_wall_clock_time == 0 ? 0 : shift);
573       fprintf (stderr,
574                "%s: checking wall clock for hibernation (%d:%02d:%02d).\n",
575                blurb(),
576                (i / (60 * 60)), ((i / 60) % 60), (i % 60));
577     }
578
579   if (si->last_wall_clock_time != 0 &&
580       shift > (p->timeout / 1000))
581     {
582       if (p->verbose_p)
583         fprintf (stderr, "%s: wall clock has jumped by %ld:%02ld:%02ld!\n",
584                  blurb(),
585                  (shift / (60 * 60)), ((shift / 60) % 60), (shift % 60));
586
587       si->emergency_lock_p = True;
588       idle_timer ((XtPointer) si, 0);
589     }
590
591   si->last_wall_clock_time = now;
592 }
593
594
595
596 static void
597 dispatch_event (saver_info *si, XEvent *event)
598 {
599   /* If this is for the splash dialog, pass it along.
600      Note that the password dialog is handled with its own event loop,
601      so events for that window will never come through here.
602    */
603   if (si->splash_dialog && event->xany.window == si->splash_dialog)
604     handle_splash_event (si, event);
605
606   XtDispatchEvent (event);
607 }
608
609
610 static void
611 swallow_unlock_typeahead_events (saver_info *si, XEvent *e)
612 {
613   XEvent event;
614   char buf [100];
615   int i = 0;
616
617   memset (buf, 0, sizeof(buf));
618
619   event = *e;
620
621   do
622     {
623       if (event.xany.type == KeyPress)
624         {
625           char s[2];
626           int size = XLookupString ((XKeyEvent *) &event, s, 1, 0, 0);
627           if (size != 1) continue;
628           switch (*s)
629             {
630             case '\010': case '\177':                   /* Backspace */
631               if (i > 0) i--;
632               break;
633             case '\025': case '\030':                   /* Erase line */
634             case '\012': case '\015':                   /* Enter */
635             case '\033':                                /* ESC */
636               i = 0;
637               break;
638             case '\040':                                /* Space */
639               if (i == 0)
640                 break;  /* ignore space at beginning of line */
641               /* else, fall through */
642             default:
643               buf [i++] = *s;
644               break;
645             }
646         }
647
648     } while (i < sizeof(buf)-1 &&
649              XCheckMaskEvent (si->dpy, KeyPressMask, &event));
650
651   buf[i] = 0;
652
653   if (si->unlock_typeahead)
654     {
655       memset (si->unlock_typeahead, 0, strlen(si->unlock_typeahead));
656       free (si->unlock_typeahead);
657     }
658
659   if (i > 0)
660     si->unlock_typeahead = strdup (buf);
661   else
662     si->unlock_typeahead = 0;
663
664   memset (buf, 0, sizeof(buf));
665 }
666
667
668 /* methods of detecting idleness:
669
670       explicitly informed by SGI SCREEN_SAVER server event;
671       explicitly informed by MIT-SCREEN-SAVER server event;
672       poll server idle time with XIDLE extension;
673       select events on all windows, and note absence of recent events;
674       note that /proc/interrupts has not changed in a while;
675       activated by clientmessage.
676
677    methods of detecting non-idleness:
678
679       read events on the xscreensaver window;
680       explicitly informed by SGI SCREEN_SAVER server event;
681       explicitly informed by MIT-SCREEN-SAVER server event;
682       select events on all windows, and note events on any of them;
683       note that /proc/interrupts has changed;
684       deactivated by clientmessage.
685
686    I trust that explains why this function is a big hairy mess.
687  */
688 void
689 sleep_until_idle (saver_info *si, Bool until_idle_p)
690 {
691   saver_preferences *p = &si->prefs;
692
693   /* We have to go through this union bullshit because gcc-4.4.0 has
694      stricter struct-aliasing rules.  Without this, the optimizer
695      can fuck things up.
696    */
697   union {
698     XEvent x_event;
699 # ifdef HAVE_RANDR
700     XRRScreenChangeNotifyEvent xrr_event;
701 # endif /* HAVE_RANDR */
702 # ifdef HAVE_MIT_SAVER_EXTENSION
703     XScreenSaverNotifyEvent sevent;
704 # endif /* HAVE_MIT_SAVER_EXTENSION */
705   } event;
706
707   /* We need to select events on all windows if we're not using any extensions.
708      Otherwise, we don't need to. */
709   Bool scanning_all_windows = !(si->using_xidle_extension ||
710                                 si->using_mit_saver_extension ||
711                                 si->using_sgi_saver_extension);
712
713   /* We need to periodically wake up and check for idleness if we're not using
714      any extensions, or if we're using the XIDLE extension.  The other two
715      extensions explicitly deliver events when we go idle/non-idle, so we
716      don't need to poll. */
717   Bool polling_for_idleness = !(si->using_mit_saver_extension ||
718                                 si->using_sgi_saver_extension);
719
720   /* Whether we need to periodically wake up and check to see if the mouse has
721      moved.  We only need to do this when not using any extensions.  The reason
722      this isn't the same as `polling_for_idleness' is that the "idleness" poll
723      can happen (for example) 5 minutes from now, whereas the mouse-position
724      poll should happen with low periodicity.  We don't need to poll the mouse
725      position with the XIDLE extension, but we do need to periodically wake up
726      and query the server with that extension.  For our purposes, polling
727      /proc/interrupts is just like polling the mouse position.  It has to
728      happen on the same kind of schedule. */
729   Bool polling_mouse_position = (si->using_proc_interrupts ||
730                                  !(si->using_xidle_extension ||
731                                    si->using_mit_saver_extension ||
732                                    si->using_sgi_saver_extension) ||
733                                    si->using_xinput_extension);
734
735   const char *why = 0;  /* What caused the idle-state to change? */
736
737   if (until_idle_p)
738     {
739       if (polling_for_idleness)
740         /* This causes a no-op event to be delivered to us in a while, so that
741            we come back around through the event loop again.  */
742         schedule_wakeup_event (si, p->timeout, p->debug_p);
743
744       if (polling_mouse_position)
745         /* Check to see if the mouse has moved, and set up a repeating timer
746            to do so periodically (typically, every 5 seconds.) */
747         check_pointer_timer ((XtPointer) si, 0);
748     }
749
750   while (1)
751     {
752       XtAppNextEvent (si->app, &event.x_event);
753
754       switch (event.x_event.xany.type) {
755       case 0:           /* our synthetic "timeout" event has been signalled */
756         if (until_idle_p)
757           {
758             Time idle;
759
760             /* We may be idle; check one last time to see if the mouse has
761                moved, just in case the idle-timer went off within the 5 second
762                window between mouse polling.  If the mouse has moved, then
763                check_pointer_timer() will reset last_activity_time.
764              */
765             if (polling_mouse_position)
766               check_pointer_timer ((XtPointer) si, 0);
767
768 #ifdef HAVE_XIDLE_EXTENSION
769             if (si->using_xidle_extension)
770               {
771                 /* The XIDLE extension uses the synthetic event to prod us into
772                    re-asking the server how long the user has been idle. */
773                 if (! XGetIdleTime (si->dpy, &idle))
774                   {
775                     fprintf (stderr, "%s: XGetIdleTime() failed.\n", blurb());
776                     saver_exit (si, 1, 0);
777                   }
778               }
779             else
780 #endif /* HAVE_XIDLE_EXTENSION */
781 #ifdef HAVE_MIT_SAVER_EXTENSION
782               if (si->using_mit_saver_extension)
783                 {
784                   /* We don't need to do anything in this case - the synthetic
785                      event isn't necessary, as we get sent specific events
786                      to wake us up.  In fact, this event generally shouldn't
787                      be being delivered when the MIT extension is in use. */
788                   idle = 0;
789                 }
790             else
791 #endif /* HAVE_MIT_SAVER_EXTENSION */
792 #ifdef HAVE_SGI_SAVER_EXTENSION
793               if (si->using_sgi_saver_extension)
794                 {
795                   /* We don't need to do anything in this case - the synthetic
796                      event isn't necessary, as we get sent specific events
797                      to wake us up.  In fact, this event generally shouldn't
798                      be being delivered when the SGI extension is in use. */
799                   idle = 0;
800                 }
801             else
802 #endif /* HAVE_SGI_SAVER_EXTENSION */
803               {
804                 /* Otherwise, no server extension is in use.  The synthetic
805                    event was to tell us to wake up and see if the user is now
806                    idle.  Compute the amount of idle time by comparing the
807                    `last_activity_time' to the wall clock.  The l_a_t was set
808                    by calling `reset_timers()', which is called only in only
809                    two situations: when polling the mouse position has revealed
810                    the the mouse has moved (user activity) or when we have read
811                    an event (again, user activity.)
812                  */
813                 idle = 1000 * (si->last_activity_time - time ((time_t *) 0));
814               }
815
816             if (idle >= p->timeout)
817               {
818                 /* Look, we've been idle long enough.  We're done. */
819                 why = "timeout";
820                 goto DONE;
821               }
822             else if (si->emergency_lock_p)
823               {
824                 /* Oops, the wall clock has jumped far into the future, so
825                    we need to lock down in a hurry! */
826                 why = "large wall clock change";
827                 goto DONE;
828               }
829             else
830               {
831                 /* The event went off, but it turns out that the user has not
832                    yet been idle for long enough.  So re-signal the event.
833                    Be economical: if we should blank after 5 minutes, and the
834                    user has been idle for 2 minutes, then set this timer to
835                    go off in 3 minutes.
836                  */
837                 if (polling_for_idleness)
838                   schedule_wakeup_event (si, p->timeout - idle, p->debug_p);
839               }
840           }
841         break;
842
843       case ClientMessage:
844         if (handle_clientmessage (si, &event.x_event, until_idle_p))
845           {
846             why = "ClientMessage";
847             goto DONE;
848           }
849         break;
850
851       case CreateNotify:
852         /* A window has been created on the screen somewhere.  If we're
853            supposed to scan all windows for events, prepare this window. */
854         if (scanning_all_windows)
855           {
856             Window w = event.x_event.xcreatewindow.window;
857             start_notice_events_timer (si, w, p->debug_p);
858           }
859         break;
860
861       case KeyPress:
862       case ButtonPress:
863       /* Ignore release events so that hitting ESC at the password dialog
864          doesn't result in the password dialog coming right back again when
865          the fucking release key is seen! */
866       /* case KeyRelease:*/
867       /* case ButtonRelease:*/
868       case MotionNotify:
869
870         if (p->debug_p)
871           {
872             Window root=0, window=0;
873             int x=-1, y=-1;
874             const char *type = 0;
875             if (event.x_event.xany.type == MotionNotify)
876               {
877                 /*type = "MotionNotify";*/
878                 root = event.x_event.xmotion.root;
879                 window = event.x_event.xmotion.window;
880                 x = event.x_event.xmotion.x_root;
881                 y = event.x_event.xmotion.y_root;
882               }
883             else if (event.x_event.xany.type == KeyPress)
884               {
885                 type = "KeyPress";
886                 root = event.x_event.xkey.root;
887                 window = event.x_event.xkey.window;
888                 x = y = -1;
889               }
890             else if (event.x_event.xany.type == ButtonPress)
891               {
892                 type = "ButtonPress";
893                 root = event.x_event.xkey.root;
894                 window = event.x_event.xkey.window;
895                 x = event.x_event.xmotion.x_root;
896                 y = event.x_event.xmotion.y_root;
897               }
898
899             if (type)
900               {
901                 int i;
902                 for (i = 0; i < si->nscreens; i++)
903                   if (root == RootWindowOfScreen (si->screens[i].screen))
904                     break;
905                 fprintf (stderr,"%s: %d: %s on 0x%lx",
906                          blurb(), i, type, (unsigned long) window);
907
908                 /* Be careful never to do this unless in -debug mode, as
909                    this could expose characters from the unlock password. */
910                 if (p->debug_p && event.x_event.xany.type == KeyPress)
911                   {
912                     KeySym keysym;
913                     char c = 0;
914                     XLookupString (&event.x_event.xkey, &c, 1, &keysym, 0);
915                     fprintf (stderr, " (%s%s)",
916                              (event.x_event.xkey.send_event ? "synthetic " : ""),
917                              XKeysymToString (keysym));
918                   }
919
920                 if (x == -1)
921                   fprintf (stderr, "\n");
922                 else
923                   fprintf (stderr, " at %d,%d.\n", x, y);
924               }
925           }
926
927         /* If any widgets want to handle this event, let them. */
928         dispatch_event (si, &event.x_event);
929
930         
931         /* If we got a MotionNotify event, figure out what screen it
932            was on and poll the mouse there: if the mouse hasn't moved
933            far enough to count as "real" motion, then ignore this
934            event.
935          */
936         if (event.x_event.xany.type == MotionNotify)
937           {
938             int i;
939             for (i = 0; i < si->nscreens; i++)
940               if (event.x_event.xmotion.root ==
941                   RootWindowOfScreen (si->screens[i].screen))
942                 break;
943             if (i < si->nscreens)
944               {
945                 if (!pointer_moved_p (&si->screens[i], False))
946                   continue;
947               }
948           }
949
950
951         /* We got a user event.
952            If we're waiting for the user to become active, this is it.
953            If we're waiting until the user becomes idle, reset the timers
954            (since now we have longer to wait.)
955          */
956         if (!until_idle_p)
957           {
958             if (si->demoing_p &&
959                 (event.x_event.xany.type == MotionNotify ||
960                  event.x_event.xany.type == KeyRelease))
961               /* When we're demoing a single hack, mouse motion doesn't
962                  cause deactivation.  Only clicks and keypresses do. */
963               ;
964             else
965               {
966                 /* If we're not demoing, then any activity causes deactivation.
967                  */
968                 why = (event.x_event.xany.type == MotionNotify ?"mouse motion":
969                        event.x_event.xany.type == KeyPress?"keyboard activity":
970                        event.x_event.xany.type == ButtonPress ? "mouse click" :
971                        "unknown user activity");
972                 goto DONE;
973               }
974           }
975         else
976           reset_timers (si);
977
978         break;
979
980       default:
981
982 #ifdef HAVE_MIT_SAVER_EXTENSION
983         if (event.x_event.type == si->mit_saver_ext_event_number)
984           {
985             /* This event's number is that of the MIT-SCREEN-SAVER server
986                extension.  This extension has one event number, and the event
987                itself contains sub-codes that say what kind of event it was
988                (an "idle" or "not-idle" event.)
989              */
990             if (event.sevent.state == ScreenSaverOn)
991               {
992                 int i = 0;
993                 if (p->verbose_p)
994                   fprintf (stderr, "%s: MIT ScreenSaverOn event received.\n",
995                            blurb());
996
997                 /* Get the "real" server window(s) out of the way as soon
998                    as possible. */
999                 for (i = 0; i < si->nscreens; i++)
1000                   {
1001                     saver_screen_info *ssi = &si->screens[i];
1002                     if (ssi->server_mit_saver_window &&
1003                         window_exists_p (si->dpy,
1004                                          ssi->server_mit_saver_window))
1005                       XUnmapWindow (si->dpy, ssi->server_mit_saver_window);
1006                   }
1007
1008                 if (event.sevent.kind != ScreenSaverExternal)
1009                   {
1010                     fprintf (stderr,
1011                          "%s: ScreenSaverOn event wasn't of type External!\n",
1012                              blurb());
1013                   }
1014
1015                 if (until_idle_p)
1016                   {
1017                     why = "MIT ScreenSaverOn";
1018                     goto DONE;
1019                   }
1020               }
1021             else if (event.sevent.state == ScreenSaverOff)
1022               {
1023                 if (p->verbose_p)
1024                   fprintf (stderr, "%s: MIT ScreenSaverOff event received.\n",
1025                            blurb());
1026                 if (!until_idle_p)
1027                   {
1028                     why = "MIT ScreenSaverOff";
1029                     goto DONE;
1030                   }
1031               }
1032             else
1033               fprintf (stderr,
1034                        "%s: unknown MIT-SCREEN-SAVER event %d received!\n",
1035                        blurb(), event.sevent.state);
1036           }
1037         else
1038
1039 #endif /* HAVE_MIT_SAVER_EXTENSION */
1040
1041
1042 #ifdef HAVE_SGI_SAVER_EXTENSION
1043         if (event.x_event.type == (si->sgi_saver_ext_event_number + ScreenSaverStart))
1044           {
1045             /* The SGI SCREEN_SAVER server extension has two event numbers,
1046                and this event matches the "idle" event. */
1047             if (p->verbose_p)
1048               fprintf (stderr, "%s: SGI ScreenSaverStart event received.\n",
1049                        blurb());
1050
1051             if (until_idle_p)
1052               {
1053                 why = "SGI ScreenSaverStart";
1054                 goto DONE;
1055               }
1056           }
1057         else if (event.x_event.type == (si->sgi_saver_ext_event_number +
1058                                 ScreenSaverEnd))
1059           {
1060             /* The SGI SCREEN_SAVER server extension has two event numbers,
1061                and this event matches the "idle" event. */
1062             if (p->verbose_p)
1063               fprintf (stderr, "%s: SGI ScreenSaverEnd event received.\n",
1064                        blurb());
1065             if (!until_idle_p)
1066               {
1067                 why = "SGI ScreenSaverEnd";
1068                 goto DONE;
1069               }
1070           }
1071         else
1072 #endif /* HAVE_SGI_SAVER_EXTENSION */
1073
1074 #ifdef HAVE_XINPUT
1075         /* If we got a MotionNotify event, check to see if the mouse has
1076            moved far enough to count as "real" motion, if not, then ignore
1077            this event.
1078          */
1079         if ((si->num_xinput_devices > 0) &&
1080             (event.x_event.type == si->xinput_DeviceMotionNotify))
1081           {
1082             XDeviceMotionEvent *dme = (XDeviceMotionEvent *) &event;
1083             poll_mouse_data *last_poll_mouse = NULL;
1084             int d;
1085
1086             for (d = 0; d < si->num_xinput_devices; d++)
1087               {
1088                 if (si->xinput_devices[d].device->device_id == dme->deviceid)
1089                   {
1090                     last_poll_mouse = &(si->xinput_devices[d].last_poll_mouse);
1091                     break;
1092                   }
1093               }
1094
1095             if (last_poll_mouse)
1096               {
1097                 poll_mouse_data this_poll_mouse;
1098                 this_poll_mouse.root_x = dme->x_root;
1099                 this_poll_mouse.root_y = dme->y_root;
1100                 this_poll_mouse.child = dme->subwindow;
1101                 this_poll_mouse.mask = dme->device_state;
1102                 this_poll_mouse.time = dme->time / 1000; /* milliseconds */
1103
1104                 if (!device_pointer_moved_p (si, last_poll_mouse,
1105                                              &this_poll_mouse, False,
1106                                              "device", dme->deviceid))
1107                   continue;
1108               }
1109             else if (p->debug_p)
1110               fprintf (stderr,
1111                        "%s: received MotionNotify from unknown device %d\n",
1112                        blurb(), (int) dme->deviceid);
1113           }
1114         
1115         if ((!until_idle_p) &&
1116             (si->num_xinput_devices > 0) &&
1117             (event.x_event.type == si->xinput_DeviceMotionNotify ||
1118              event.x_event.type == si->xinput_DeviceButtonPress))
1119           /* Ignore DeviceButtonRelease, see ButtonRelease comment above. */
1120           {
1121
1122             dispatch_event (si, &event.x_event);
1123             if (si->demoing_p &&
1124                 event.x_event.type == si->xinput_DeviceMotionNotify)
1125               /* When we're demoing a single hack, mouse motion doesn't
1126                  cause deactivation.  Only clicks and keypresses do. */
1127               ;
1128             else
1129               /* If we're not demoing, then any activity causes deactivation.
1130                */
1131               {
1132                 why = (event.x_event.type == si->xinput_DeviceMotionNotify
1133                        ? "XI mouse motion" :
1134                        event.x_event.type == si->xinput_DeviceButtonPress
1135                        ? "XI mouse click" : "unknown XINPUT event");
1136                 goto DONE;
1137               }
1138           }
1139         else
1140 #endif /* HAVE_XINPUT */
1141
1142 #ifdef HAVE_RANDR
1143         if (si->using_randr_extension &&
1144             (event.x_event.type == 
1145              (si->randr_event_number + RRScreenChangeNotify)))
1146           {
1147             /* The Resize and Rotate extension sends an event when the
1148                size, rotation, or refresh rate of any screen has changed.
1149              */
1150             if (p->verbose_p)
1151               {
1152                 /* XRRRootToScreen is in Xrandr.h 1.4, 2001/06/07 */
1153                 int screen = XRRRootToScreen (si->dpy, event.xrr_event.window);
1154                 fprintf (stderr, "%s: %d: screen change event received\n",
1155                          blurb(), screen);
1156               }
1157
1158 # ifdef RRScreenChangeNotifyMask
1159             /* Inform Xlib that it's ok to update its data structures. */
1160             XRRUpdateConfiguration (&event.x_event); /* Xrandr.h 1.9, 2002/09/29 */
1161 # endif /* RRScreenChangeNotifyMask */
1162
1163             /* Resize the existing xscreensaver windows and cached ssi data. */
1164             if (update_screen_layout (si))
1165               {
1166                 if (p->verbose_p)
1167                   {
1168                     fprintf (stderr, "%s: new layout:\n", blurb());
1169                     describe_monitor_layout (si);
1170                   }
1171                 resize_screensaver_window (si);
1172               }
1173           }
1174         else
1175 #endif /* HAVE_RANDR */
1176
1177           /* Just some random event.  Let the Widgets handle it, if desired. */
1178           dispatch_event (si, &event.x_event);
1179       }
1180     }
1181  DONE:
1182
1183   if (p->verbose_p)
1184     {
1185       if (! why) why = "unknown reason";
1186       fprintf (stderr, "%s: %s (%s)\n", blurb(),
1187                (until_idle_p ? "user is idle" : "user is active"),
1188                why);
1189     }
1190
1191   /* If there's a user event on the queue, swallow it.
1192      If we're using a server extension, and the user becomes active, we
1193      get the extension event before the user event -- so the keypress or
1194      motion or whatever is still on the queue.  This makes "unfade" not
1195      work, because it sees that event, and bugs out.  (This problem
1196      doesn't exhibit itself without an extension, because in that case,
1197      there's only one event generated by user activity, not two.)
1198    */
1199   if (!until_idle_p && si->locked_p)
1200     swallow_unlock_typeahead_events (si, &event.x_event);
1201   else
1202     while (XCheckMaskEvent (si->dpy,
1203                             (KeyPressMask|ButtonPressMask|PointerMotionMask),
1204                      &event.x_event))
1205       ;
1206
1207
1208   if (si->check_pointer_timer_id)
1209     {
1210       XtRemoveTimeOut (si->check_pointer_timer_id);
1211       si->check_pointer_timer_id = 0;
1212     }
1213   if (si->timer_id)
1214     {
1215       XtRemoveTimeOut (si->timer_id);
1216       si->timer_id = 0;
1217     }
1218
1219   if (until_idle_p && si->cycle_id)     /* no cycle timer when inactive */
1220     abort ();
1221 }
1222
1223
1224 \f
1225 /* Some crap for dealing with /proc/interrupts.
1226
1227    On Linux systems, it's possible to see the hardware interrupt count
1228    associated with the keyboard.  We can therefore use that as another method
1229    of detecting idleness.
1230
1231    Why is it a good idea to do this?  Because it lets us detect keyboard
1232    activity that is not associated with X events.  For example, if the user
1233    has switched to another virtual console, it's good for xscreensaver to not
1234    be running graphics hacks on the (non-visible) X display.  The common
1235    complaint that checking /proc/interrupts addresses is that the user is
1236    playing Quake on a non-X console, and the GL hacks are perceptibly slowing
1237    the game...
1238
1239    This is tricky for a number of reasons.
1240
1241      * First, we must be sure to only do this when running on an X server that
1242        is on the local machine (because otherwise, we'd be reacting to the
1243        wrong keyboard.)  The way we do this is by noting that the $DISPLAY is
1244        pointing to display 0 on the local machine.  It *could* be that display
1245        1 is also on the local machine (e.g., two X servers, each on a different
1246        virtual-terminal) but it's also possible that screen 1 is an X terminal,
1247        using this machine as the host.  So we can't take that chance.
1248
1249      * Second, one can only access these interrupt numbers in a completely
1250        and utterly brain-damaged way.  You would think that one would use an
1251        ioctl for this.  But no.  The ONLY way to get this information is to
1252        open the pseudo-file /proc/interrupts AS A FILE, and read the numbers
1253        out of it TEXTUALLY.  Because this is Unix, and all the world's a file,
1254        and the only real data type is the short-line sequence of ASCII bytes.
1255
1256        Now it's all well and good that the /proc/interrupts pseudo-file
1257        exists; that's a clever idea, and a useful API for things that are
1258        already textually oriented, like shell scripts, and users doing
1259        interactive debugging sessions.  But to make a *C PROGRAM* open a file
1260        and parse the textual representation of integers out of it is just
1261        insane.
1262
1263      * Third, you can't just hold the file open, and fseek() back to the
1264        beginning to get updated data!  If you do that, the data never changes.
1265        And I don't want to call open() every five seconds, because I don't want
1266        to risk going to disk for any inodes.  It turns out that if you dup()
1267        it early, then each copy gets fresh data, so we can get around that in
1268        this way (but for how many releases, one might wonder?)
1269
1270      * Fourth, the format of the output of the /proc/interrupts file is
1271        undocumented, and has changed several times already!  In Linux 2.0.33,
1272        even on a multiprocessor machine, it looks like this:
1273
1274           0:  309453991   timer
1275           1:    4771729   keyboard
1276    
1277        but in Linux 2.2 and 2.4 kernels with MP machines, it looks like this:
1278
1279                    CPU0       CPU1
1280           0:    1671450    1672618    IO-APIC-edge  timer
1281           1:      13037      13495    IO-APIC-edge  keyboard
1282
1283        and in Linux 2.6, it's gotten even goofier: now there are two lines
1284        labelled "i8042".  One of them is the keyboard, and one of them is
1285        the PS/2 mouse -- and of course, you can't tell them apart, except
1286        by wiggling the mouse and noting which one changes:
1287
1288                    CPU0       CPU1
1289           1:      32051      30864    IO-APIC-edge  i8042
1290          12:     476577     479913    IO-APIC-edge  i8042
1291
1292        Joy!  So how are we expected to parse that?  Well, this code doesn't
1293        parse it: it saves the first line with the string "keyboard" (or
1294        "i8042") in it, and does a string-comparison to note when it has
1295        changed.  If there are two "i8042" lines, we assume the first is
1296        the keyboard and the second is the mouse (doesn't matter which is
1297        which, really, as long as we don't compare them against each other.)
1298
1299    Thanks to Nat Friedman <nat@nat.org> for figuring out most of this crap.
1300
1301    Note that if you have a serial or USB mouse, or a USB keyboard, it won't
1302    detect it.  That's because there's no way to tell the difference between a
1303    serial mouse and a general serial port, and all USB devices look the same
1304    from here.  It would be somewhat unfortunate to have the screensaver turn
1305    off when the modem on COM1 burped, or when a USB disk was accessed.
1306  */
1307
1308
1309 #ifdef HAVE_PROC_INTERRUPTS
1310
1311 #define PROC_INTERRUPTS "/proc/interrupts"
1312
1313 Bool
1314 query_proc_interrupts_available (saver_info *si, const char **why)
1315 {
1316   /* We can use /proc/interrupts if $DISPLAY points to :0, and if the
1317      "/proc/interrupts" file exists and is readable.
1318    */
1319   FILE *f;
1320   if (why) *why = 0;
1321
1322   if (!display_is_on_console_p (si))
1323     {
1324       if (why) *why = "not on primary console";
1325       return False;
1326     }
1327
1328   f = fopen (PROC_INTERRUPTS, "r");
1329   if (!f)
1330     {
1331       if (why) *why = "does not exist";
1332       return False;
1333     }
1334
1335   fclose (f);
1336   return True;
1337 }
1338
1339
1340 static Bool
1341 proc_interrupts_activity_p (saver_info *si)
1342 {
1343   static FILE *f0 = 0;
1344   FILE *f1 = 0;
1345   int fd;
1346   static char last_kbd_line[255] = { 0, };
1347   static char last_ptr_line[255] = { 0, };
1348   char new_line[sizeof(last_kbd_line)];
1349   Bool checked_kbd = False, kbd_changed = False;
1350   Bool checked_ptr = False, ptr_changed = False;
1351   int i8042_count = 0;
1352
1353   if (!f0)
1354     {
1355       /* First time -- open the file. */
1356       f0 = fopen (PROC_INTERRUPTS, "r");
1357       if (!f0)
1358         {
1359           char buf[255];
1360           sprintf(buf, "%s: error opening %s", blurb(), PROC_INTERRUPTS);
1361           perror (buf);
1362           goto FAIL;
1363         }
1364
1365 # if defined(HAVE_FCNTL) && defined(FD_CLOEXEC)
1366       /* Close this fd upon exec instead of inheriting / leaking it. */
1367       if (fcntl (fileno (f0), F_SETFD, FD_CLOEXEC) != 0)
1368         perror ("fcntl: CLOEXEC:");
1369 # endif
1370     }
1371
1372   if (f0 == (FILE *) -1)            /* means we got an error initializing. */
1373     return False;
1374
1375   fd = dup (fileno (f0));
1376   if (fd < 0)
1377     {
1378       char buf[255];
1379       sprintf(buf, "%s: could not dup() the %s fd", blurb(), PROC_INTERRUPTS);
1380       perror (buf);
1381       goto FAIL;
1382     }
1383
1384   f1 = fdopen (fd, "r");
1385   if (!f1)
1386     {
1387       char buf[255];
1388       sprintf(buf, "%s: could not fdopen() the %s fd", blurb(),
1389               PROC_INTERRUPTS);
1390       perror (buf);
1391       goto FAIL;
1392     }
1393
1394   /* Actually, I'm unclear on why this fseek() is necessary, given the timing
1395      of the dup() above, but it is. */
1396   if (fseek (f1, 0, SEEK_SET) != 0)
1397     {
1398       char buf[255];
1399       sprintf(buf, "%s: error rewinding %s", blurb(), PROC_INTERRUPTS);
1400       perror (buf);
1401       goto FAIL;
1402     }
1403
1404   /* Now read through the pseudo-file until we find the "keyboard",
1405      "PS/2 mouse", or "i8042" lines. */
1406
1407   while (fgets (new_line, sizeof(new_line)-1, f1))
1408     {
1409       Bool i8042_p = !!strstr (new_line, "i8042");
1410       if (i8042_p) i8042_count++;
1411
1412       if (strchr (new_line, ','))
1413         {
1414           /* Ignore any line that has a comma on it: this is because
1415              a setup like this:
1416
1417                  12:     930935          XT-PIC  usb-uhci, PS/2 Mouse
1418
1419              is really bad news.  It *looks* like we can note mouse
1420              activity from that line, but really, that interrupt gets
1421              fired any time any USB device has activity!  So we have
1422              to ignore any shared IRQs.
1423            */
1424         }
1425       else if (!checked_kbd &&
1426                (strstr (new_line, "keyboard") ||
1427                 (i8042_p && i8042_count == 1)))
1428         {
1429           /* Assume the keyboard interrupt is the line that says "keyboard",
1430              or the *first* line that says "i8042".
1431            */
1432           kbd_changed = (*last_kbd_line && !!strcmp (new_line, last_kbd_line));
1433           strcpy (last_kbd_line, new_line);
1434           checked_kbd = True;
1435         }
1436       else if (!checked_ptr &&
1437                (strstr (new_line, "PS/2 Mouse") ||
1438                 (i8042_p && i8042_count == 2)))
1439         {
1440           /* Assume the mouse interrupt is the line that says "PS/2 mouse",
1441              or the *second* line that says "i8042".
1442            */
1443           ptr_changed = (*last_ptr_line && !!strcmp (new_line, last_ptr_line));
1444           strcpy (last_ptr_line, new_line);
1445           checked_ptr = True;
1446         }
1447
1448       if (checked_kbd && checked_ptr)
1449         break;
1450     }
1451
1452   if (checked_kbd || checked_ptr)
1453     {
1454       fclose (f1);
1455
1456       if (si->prefs.debug_p && (kbd_changed || ptr_changed))
1457         fprintf (stderr, "%s: /proc/interrupts activity: %s\n",
1458                  blurb(),
1459                  ((kbd_changed && ptr_changed) ? "mouse and kbd" :
1460                   kbd_changed ? "kbd" :
1461                   ptr_changed ? "mouse" : "ERR"));
1462
1463       return (kbd_changed || ptr_changed);
1464     }
1465
1466
1467   /* If we got here, we didn't find either a "keyboard" or a "PS/2 Mouse"
1468      line in the file at all. */
1469   fprintf (stderr, "%s: no keyboard or mouse data in %s?\n",
1470            blurb(), PROC_INTERRUPTS);
1471
1472  FAIL:
1473   if (f1)
1474     fclose (f1);
1475
1476   if (f0 && f0 != (FILE *) -1)
1477     fclose (f0);
1478
1479   f0 = (FILE *) -1;
1480   return False;
1481 }
1482
1483 #endif /* HAVE_PROC_INTERRUPTS */
1484
1485 \f
1486 /* This timer goes off every few minutes, whether the user is idle or not,
1487    to try and clean up anything that has gone wrong.
1488
1489    It calls disable_builtin_screensaver() so that if xset has been used,
1490    or some other program (like xlock) has messed with the XSetScreenSaver()
1491    settings, they will be set back to sensible values (if a server extension
1492    is in use, messing with xlock can cause xscreensaver to never get a wakeup
1493    event, and could cause monitor power-saving to occur, and all manner of
1494    heinousness.)
1495
1496    If the screen is currently blanked, it raises the window, in case some
1497    other window has been mapped on top of it.
1498
1499    If the screen is currently blanked, and there is no hack running, it
1500    clears the window, in case there is an error message printed on it (we
1501    don't want the error message to burn in.)
1502  */
1503
1504 static void
1505 watchdog_timer (XtPointer closure, XtIntervalId *id)
1506 {
1507   saver_info *si = (saver_info *) closure;
1508   saver_preferences *p = &si->prefs;
1509
1510   disable_builtin_screensaver (si, False);
1511
1512   /* If the DPMS settings on the server have changed, change them back to
1513      what ~/.xscreensaver says they should be. */
1514   sync_server_dpms_settings (si->dpy,
1515                              (p->dpms_enabled_p  &&
1516                               p->mode != DONT_BLANK),
1517                              p->dpms_standby / 1000,
1518                              p->dpms_suspend / 1000,
1519                              p->dpms_off / 1000,
1520                              False);
1521
1522   if (si->screen_blanked_p)
1523     {
1524       Bool running_p = screenhack_running_p (si);
1525
1526       if (si->dbox_up_p)
1527         {
1528           if (si->prefs.debug_p)
1529             fprintf (stderr, "%s: dialog box is up: not raising screen.\n",
1530                      blurb());
1531         }
1532       else
1533         {
1534           if (si->prefs.debug_p)
1535             fprintf (stderr, "%s: watchdog timer raising %sscreen.\n",
1536                      blurb(), (running_p ? "" : "and clearing "));
1537
1538           raise_window (si, True, True, running_p);
1539         }
1540
1541       if (screenhack_running_p (si) &&
1542           !monitor_powered_on_p (si))
1543         {
1544           int i;
1545           if (si->prefs.verbose_p)
1546             fprintf (stderr,
1547                      "%s: X says monitor has powered down; "
1548                      "killing running hacks.\n", blurb());
1549           for (i = 0; i < si->nscreens; i++)
1550             kill_screenhack (&si->screens[i]);
1551         }
1552
1553       /* Re-schedule this timer.  The watchdog timer defaults to a bit less
1554          than the hack cycle period, but is never longer than one hour.
1555        */
1556       si->watchdog_id = 0;
1557       reset_watchdog_timer (si, True);
1558     }
1559 }
1560
1561
1562 void
1563 reset_watchdog_timer (saver_info *si, Bool on_p)
1564 {
1565   saver_preferences *p = &si->prefs;
1566
1567   if (si->watchdog_id)
1568     {
1569       XtRemoveTimeOut (si->watchdog_id);
1570       si->watchdog_id = 0;
1571     }
1572
1573   if (on_p && p->watchdog_timeout)
1574     {
1575       si->watchdog_id = XtAppAddTimeOut (si->app, p->watchdog_timeout,
1576                                          watchdog_timer, (XtPointer) si);
1577
1578       if (p->debug_p)
1579         fprintf (stderr, "%s: restarting watchdog_timer (%ld, %ld)\n",
1580                  blurb(), p->watchdog_timeout, si->watchdog_id);
1581     }
1582 }
1583
1584
1585 /* It's possible that a race condition could have led to the saver
1586    window being unexpectedly still mapped.  This can happen like so:
1587
1588     - screen is blanked
1589     - hack is launched
1590     - that hack tries to grab a screen image (it does this by
1591       first unmapping the saver window, then remapping it.)
1592     - hack unmaps window
1593     - hack waits
1594     - user becomes active
1595     - hack re-maps window (*)
1596     - driver kills subprocess
1597     - driver unmaps window (**)
1598
1599    The race is that (*) might have been sent to the server before
1600    the client process was killed, but, due to scheduling randomness,
1601    might not have been received by the server until after (**).
1602    In other words, (*) and (**) might happen out of order, meaning
1603    the driver will unmap the window, and then after that, the
1604    recently-dead client will re-map it.  This leaves the user
1605    locked out (it looks like a desktop, but it's not!)
1606
1607    To avoid this: after un-blanking the screen, we launch a timer
1608    that wakes up once a second for ten seconds, and makes damned
1609    sure that the window is still unmapped.
1610  */
1611
1612 void
1613 de_race_timer (XtPointer closure, XtIntervalId *id)
1614 {
1615   saver_info *si = (saver_info *) closure;
1616   saver_preferences *p = &si->prefs;
1617   int secs = 1;
1618
1619   if (id == 0)  /* if id is 0, this is the initialization call. */
1620     {
1621       si->de_race_ticks = 10;
1622       if (p->verbose_p)
1623         fprintf (stderr, "%s: starting de-race timer (%d seconds.)\n",
1624                  blurb(), si->de_race_ticks);
1625     }
1626   else
1627     {
1628       int i;
1629       XSync (si->dpy, False);
1630       for (i = 0; i < si->nscreens; i++)
1631         {
1632           saver_screen_info *ssi = &si->screens[i];
1633           Window w = ssi->screensaver_window;
1634           XWindowAttributes xgwa;
1635           XGetWindowAttributes (si->dpy, w, &xgwa);
1636           if (xgwa.map_state != IsUnmapped)
1637             {
1638               if (p->verbose_p)
1639                 fprintf (stderr,
1640                          "%s: %d: client race! emergency unmap 0x%lx.\n",
1641                          blurb(), i, (unsigned long) w);
1642               XUnmapWindow (si->dpy, w);
1643             }
1644           else if (p->debug_p)
1645             fprintf (stderr, "%s: %d: (de-race of 0x%lx is cool.)\n",
1646                      blurb(), i, (unsigned long) w);
1647         }
1648       XSync (si->dpy, False);
1649
1650       si->de_race_ticks--;
1651     }
1652
1653   if (id && *id == si->de_race_id)
1654     si->de_race_id = 0;
1655
1656   if (si->de_race_id) abort();
1657
1658   if (si->de_race_ticks <= 0)
1659     {
1660       si->de_race_id = 0;
1661       if (p->verbose_p)
1662         fprintf (stderr, "%s: de-race completed.\n", blurb());
1663     }
1664   else
1665     {
1666       si->de_race_id = XtAppAddTimeOut (si->app, secs * 1000,
1667                                         de_race_timer, closure);
1668     }
1669 }