You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
420 lines
12 KiB
420 lines
12 KiB
/*****************************************************************************
|
|
*
|
|
* Authors: Michel Eyckmans (MCE) & Stefan De Troch (SDT)
|
|
*
|
|
* Content: This file is part of version 2.x of xautolock. It implements
|
|
* the program's core functions.
|
|
*
|
|
* Please send bug reports etc. to eyckmans@imec.be.
|
|
*
|
|
* --------------------------------------------------------------------------
|
|
*
|
|
* Copyright 1990,1992-1999,2001-2002 by Stefan De Troch and Michel Eyckmans.
|
|
*
|
|
* Versions 2.0 and above of xautolock are available under version 2 of the
|
|
* GNU GPL. Earlier versions are available under other conditions. For more
|
|
* information, see the License file.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include <X11/Xlib.h>
|
|
#include <time.h>
|
|
|
|
#include "xautolock_c.h"
|
|
|
|
/*
|
|
* Function for querying the idle time from the server.
|
|
* Only used if either the Xidle or the Xscreensaver
|
|
* extension is present.
|
|
*/
|
|
void
|
|
xautolock_queryIdleTime (Display* d)
|
|
{
|
|
Time idleTime = 0; /* millisecs since last input event */
|
|
|
|
#ifdef HasXidle
|
|
if (xautolock_useXidle)
|
|
{
|
|
XGetIdleTime (d, &idleTime);
|
|
}
|
|
else
|
|
#endif /* HasXIdle */
|
|
{
|
|
#ifdef HasScreenSaver
|
|
if( xautolock_useMit )
|
|
{
|
|
static XScreenSaverInfo* mitInfo = 0;
|
|
if (!mitInfo) mitInfo = XScreenSaverAllocInfo ();
|
|
XScreenSaverQueryInfo (d, DefaultRootWindow (d), mitInfo);
|
|
idleTime = mitInfo->idle;
|
|
}
|
|
else
|
|
#endif /* HasScreenSaver */
|
|
{
|
|
d = d; /* shut up */
|
|
return; /* DIY */
|
|
}
|
|
}
|
|
|
|
if (idleTime < CHECK_INTERVAL )
|
|
{
|
|
xautolock_resetTriggers ();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Function for monitoring pointer movements. This implements the
|
|
* `corners' feature and as a side effect also tracks pointer
|
|
* related user activity. The latter actually is only needed when
|
|
* we're using the DIY mode of operations, but it's much simpler
|
|
* to do it unconditionally.
|
|
*/
|
|
void
|
|
xautolock_queryPointer (Display* d)
|
|
{
|
|
Window dummyWin; /* as it says */
|
|
int dummyInt; /* as it says */
|
|
unsigned mask; /* modifier mask */
|
|
int rootX; /* as it says */
|
|
int rootY; /* as it says */
|
|
int corner; /* corner index */
|
|
time_t now; /* as it says */
|
|
time_t newTrigger; /* temporary storage */
|
|
int i; /* loop counter */
|
|
static Window root; /* root window the pointer is on */
|
|
static Screen* screen; /* screen the pointer is on */
|
|
static unsigned prevMask = 0; /* as it says */
|
|
static int prevRootX = -1; /* as it says */
|
|
static int prevRootY = -1; /* as it says */
|
|
static Bool firstCall = True; /* as it says */
|
|
|
|
/*
|
|
* Have a guess...
|
|
*/
|
|
if (firstCall)
|
|
{
|
|
firstCall = False;
|
|
root = DefaultRootWindow (d);
|
|
screen = ScreenOfDisplay (d, DefaultScreen (d));
|
|
}
|
|
|
|
/*
|
|
* Find out whether the pointer has moved. Using XQueryPointer for this
|
|
* is gross, but it also is the only way never to mess up propagation
|
|
* of pointer events.
|
|
*/
|
|
if (!XQueryPointer (d, root, &root, &dummyWin, &rootX, &rootY,
|
|
&dummyInt, &dummyInt, &mask))
|
|
{
|
|
/*
|
|
* Pointer has moved to another screen, so let's find out which one.
|
|
*/
|
|
for (i = -1; ++i < ScreenCount (d); )
|
|
{
|
|
if (root == RootWindow (d, i))
|
|
{
|
|
screen = ScreenOfDisplay (d, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( rootX == prevRootX
|
|
&& rootY == prevRootY
|
|
&& mask == prevMask)
|
|
{
|
|
xautolock_corner_t* corners = xautolock_corners;
|
|
/*
|
|
* If the pointer has not moved since the previous call and
|
|
* is inside one of the 4 corners, we act according to the
|
|
* contents of the "corners" array.
|
|
*
|
|
* If rootX and rootY are less than zero, don't lock even if
|
|
* ca_forceLock is set in the upper-left corner. Why? 'cause
|
|
* on initial server startup, if (and only if) the pointer is
|
|
* never moved, XQueryPointer() can return values less than
|
|
* zero (only some servers, Openwindows 2.0 and 3.0 in
|
|
* particular).
|
|
*/
|
|
if ( (corner = 0,
|
|
rootX <= cornerSize && rootX >= 0
|
|
&& rootY <= cornerSize && rootY >= 0)
|
|
|| (corner++,
|
|
rootX >= WidthOfScreen (screen) - cornerSize - 1
|
|
&& rootY <= cornerSize)
|
|
|| (corner++,
|
|
rootX <= cornerSize
|
|
&& rootY >= HeightOfScreen (screen) - cornerSize - 1)
|
|
|| (corner++,
|
|
rootX >= WidthOfScreen (screen) - cornerSize - 1
|
|
&& rootY >= HeightOfScreen (screen) - cornerSize - 1))
|
|
{
|
|
now = time (0);
|
|
|
|
switch (corners[corner])
|
|
{
|
|
case ca_forceLock:
|
|
#if 0
|
|
newTrigger = now + (useRedelay ? cornerRedelay : cornerDelay) - 1;
|
|
#else
|
|
newTrigger = now;
|
|
#endif
|
|
|
|
#if 0
|
|
if (newTrigger < lockTrigger)
|
|
{
|
|
setLockTrigger (newTrigger - now);
|
|
}
|
|
#else
|
|
xautolock_setTrigger( newTrigger );
|
|
#endif
|
|
break;
|
|
|
|
case ca_dontLock:
|
|
xautolock_resetTriggers ();
|
|
|
|
#ifdef __GNUC__
|
|
default: ; /* Makes gcc -Wall shut up. */
|
|
#endif /* __GNUC__ */
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#if 0
|
|
useRedelay = False;
|
|
#endif
|
|
prevRootX = rootX;
|
|
prevRootY = rootY;
|
|
prevMask = mask;
|
|
|
|
xautolock_resetTriggers ();
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
/*
|
|
* Support for deciding whether to lock or kill.
|
|
*/
|
|
void
|
|
evaluateTriggers (Display* d)
|
|
{
|
|
static time_t prevNotification = 0;
|
|
time_t now = 0;
|
|
|
|
/*
|
|
* Obvious things first.
|
|
*
|
|
* The triggers are being moved all the time while in disabled
|
|
* mode in order to make absolutely sure we cannot run into
|
|
* trouble by an enable message coming in at an odd moment.
|
|
* Otherwise we possibly might lock or kill too soon.
|
|
*/
|
|
if (disabled)
|
|
{
|
|
resetTriggers ();
|
|
}
|
|
|
|
/*
|
|
* Next, wait for (or kill, if we were so told) the previous
|
|
* locker (if any). Note that this must also be done while in
|
|
* disabled mode. Not only to avoid a potential zombie proces
|
|
* hanging around until we are re-enabled, but also to prevent
|
|
* us from incorrectly setting a kill trigger at the moment
|
|
* when we are finally re-enabled.
|
|
*/
|
|
#ifdef VMS
|
|
if (vmsStatus == 0)
|
|
{
|
|
#else /* VMS */
|
|
if (lockerPid)
|
|
{
|
|
#if !defined (UTEKV) && !defined (SYSV) && !defined (SVR4)
|
|
union wait status; /* childs process status */
|
|
#else /* !UTEKV && !SYSV && !SVR4 */
|
|
int status = 0; /* childs process status */
|
|
#endif /* !UTEKV && !SYSV && !SVR4 */
|
|
|
|
if (unlockNow && !disabled)
|
|
{
|
|
(void) kill (lockerPid, SIGTERM);
|
|
}
|
|
|
|
#if !defined (UTEKV) && !defined (SYSV) && !defined (SVR4)
|
|
if (wait3 (&status, WNOHANG, 0))
|
|
#else /* !UTEKV && !SYSV && !SVR4 */
|
|
if (waitpid (-1, &status, WNOHANG))
|
|
#endif /* !UTEKV && !SYSV && !SVR4 */
|
|
{
|
|
/*
|
|
* If the locker exited normally, we disable any pending kill
|
|
* trigger. Otherwise, we assume that it either has crashed or
|
|
* was not able to lock the display because of an existing
|
|
* locker (which may have been started manually). In both of
|
|
* the later cases, disabling the kill trigger would open a
|
|
* loop hole.
|
|
*/
|
|
if ( WIFEXITED (status)
|
|
&& WEXITSTATUS (status) == EXIT_SUCCESS)
|
|
{
|
|
disableKillTrigger ();
|
|
}
|
|
|
|
useRedelay = True;
|
|
lockerPid = 0;
|
|
}
|
|
#endif /* VMS */
|
|
|
|
setLockTrigger (lockTime);
|
|
|
|
/*
|
|
* No return here! The pointer may be sitting in a corner, while
|
|
* parameter settings may be such that we need to start another
|
|
* locker without further delay. If you think this cannot happen,
|
|
* consider the case in which the locker simply crashed.
|
|
*/
|
|
}
|
|
|
|
unlockNow = False;
|
|
|
|
/*
|
|
* Note that the above lot needs to be done even when we're in
|
|
* disabled mode, since we may have entered said mode with an
|
|
* active locker around.
|
|
*/
|
|
if (disabled) return;
|
|
|
|
/*
|
|
* Is it time to run the killer command?
|
|
*/
|
|
now = time (0);
|
|
|
|
if (killTrigger && now >= killTrigger)
|
|
{
|
|
/*
|
|
* There is a dirty trick here. On the one hand, we don't want
|
|
* to block until the killer returns, but on the other one
|
|
* we don't want to have it interfere with the wait() stuff we
|
|
* do to keep track of the locker. To obtain both, the killer
|
|
* command has already been patched by KillerChecker() so that
|
|
* it gets backgrounded by the shell started by system().
|
|
*
|
|
* For the time being, VMS users are out of luck: their xautolock
|
|
* will indeed block until the killer returns.
|
|
*/
|
|
(void) system (killer);
|
|
setKillTrigger (killTime);
|
|
}
|
|
|
|
/*
|
|
* Now trigger the notifier if required.
|
|
*/
|
|
if ( notifyLock
|
|
&& now + notifyMargin >= lockTrigger
|
|
&& prevNotification < now - notifyMargin - 1)
|
|
{
|
|
if (notifierSpecified)
|
|
{
|
|
/*
|
|
* Here we use the same dirty trick as for the killer command.
|
|
*/
|
|
(void) system (notifier);
|
|
}
|
|
else
|
|
{
|
|
(void) XBell (d, bellPercent);
|
|
(void) XSync (d, 0);
|
|
}
|
|
|
|
prevNotification = now;
|
|
}
|
|
|
|
/*
|
|
* Finally fire up the locker if time has somehow come.
|
|
*/
|
|
if ( lockNow
|
|
|| now >= lockTrigger)
|
|
{
|
|
#ifdef VMS
|
|
if (vmsStatus != 0)
|
|
#else /* VMS */
|
|
if (!lockerPid)
|
|
#endif /* VMS */
|
|
{
|
|
switch (lockerPid = vfork ())
|
|
{
|
|
case -1:
|
|
lockerPid = 0;
|
|
break;
|
|
|
|
case 0:
|
|
(void) close (ConnectionNumber (d));
|
|
#ifdef VMS
|
|
vmsStatus = 0;
|
|
lockerPid = lib$spawn ((lockNow ? &nowLockerDescr : &lockerDescr),
|
|
0, 0, &1, 0, 0, &vmsStatus);
|
|
|
|
if (!(lockerPid & 1)) exit (lockerPid);
|
|
|
|
#ifdef SLOW_VMS
|
|
(void) sleep (SLOW_VMS_DELAY);
|
|
#endif /* SLOW_VMS */
|
|
#else /* VMS */
|
|
(void) execl ("/bin/sh", "/bin/sh", "-c",
|
|
(lockNow ? nowLocker : locker), 0);
|
|
#endif /* VMS */
|
|
_exit (EXIT_FAILURE);
|
|
|
|
default:
|
|
/*
|
|
* In general xautolock should keep its fingers off the real
|
|
* screensaver because no universally acceptable policy can
|
|
* be defined. In no case should it decide to disable or enable
|
|
* it all by itself. Setting the screensaver policy is something
|
|
* the locker should take care of. After all, xautolock is not
|
|
* supposed to know what the "locker" does and doesn't do.
|
|
* People might be using xautolock for totally different
|
|
* purposes (which, by the way, is why it will accept a
|
|
* different set of X resources after being renamed).
|
|
*
|
|
* Nevertheless, simply resetting the screensaver is a
|
|
* convenience action that aids many xlock users, and doesn't
|
|
* harm anyone (*). The problem with older versions of xlock
|
|
* is that they can be told to replace (= disable) the real
|
|
* screensaver, but forget to reset that same screensaver if
|
|
* it was already active at the time xlock starts. I guess
|
|
* xlock initially wasn't designed to be run without a user
|
|
* actually typing the comand ;-).
|
|
*
|
|
* (*) Well, at least it used not to harm anyone, but with the
|
|
* advent of DPMS monitors, it now can mess up the power
|
|
* saving setup. Hence we better make it optional.
|
|
*
|
|
* Also, some xlock versions also unconditionally call
|
|
* XResetScreenSaver, yielding the same kind of problems
|
|
* with DPMS that xautolock did. The latest and greatest
|
|
* xlocks also have a -resetsaver option for this very
|
|
* reason. You may want to upgrade.
|
|
*/
|
|
if (resetSaver) (void) XResetScreenSaver(d);
|
|
|
|
setLockTrigger (lockTime);
|
|
(void) XSync (d,0);
|
|
}
|
|
|
|
/*
|
|
* Once the locker is running, all that needs to be done is to
|
|
* set the killTrigger if needed. Notice that this must be done
|
|
* even if we actually failed to start the locker. Otherwise
|
|
* the error would "propagate" from one feature to another.
|
|
*/
|
|
if (killerSpecified) setKillTrigger (killTime);
|
|
|
|
useRedelay = False;
|
|
}
|
|
|
|
lockNow = False;
|
|
}
|
|
}
|
|
#endif
|