Linux ip-172-26-7-228 5.4.0-1103-aws #111~18.04.1-Ubuntu SMP Tue May 23 20:04:10 UTC 2023 x86_64
Your IP : 18.117.101.250
#!/bin/sh
#---------------------------------------------
# xdg-screensaver
#
# Utility script to control screensaver.
#
# Refer to the usage() function below for usage.
#
# Copyright 2006, Bryce Harrington <bryce@osdl.org>
#
# LICENSE:
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
#
#---------------------------------------------
manualpage()
{
cat << _MANUALPAGE
Name
xdg-screensaver - command line tool for controlling the screensaver
Synopsis
xdg-screensaver suspend WindowID
xdg-screensaver resume WindowID
xdg-screensaver { activate | lock | reset | status }
xdg-screensaver { --help | --manual | --version }
Description
xdg-screensaver provides commands to control the screensaver.
xdg-screensaver is for use inside a desktop session only. It is not recommended
to use xdg-screensaver as root.
Commands
suspend WindowID
Suspends the screensaver and monitor power management. WindowID must be the
X Window ID of an existing window of the calling application. The window
must remain in existence for the duration of the suspension.
WindowID can be represented as either a decimal number or as a hexadecimal
number consisting of the prefix 0x followed by one or more hexadecimal
digits.
The screensaver can be suspended in relation to multiple windows at the
same time. In that case screensaver operation is only restored once the
screensaver has been resumed in relation to each of the windows
resume WindowID
Resume the screensaver and monitor power management after being suspended.
WindowID must be the same X Window ID that was passed to a previous call of
xdg-screensaver suspend
activate
Turns the screensaver on immediately. This may result in the screen getting
locked, depending on existing system policies.
lock
Lock the screen immediately.
reset
Turns the screensaver off immediately. If the screen was locked the user
may be asked to authenticate first.
status
Prints enabled to stdout if the screensaver is enabled to turn on after a
period of inactivity and prints disabled if the screensaver is not enabled.
Options
--help
Show command synopsis.
--manual
Show this manual page.
--version
Show the xdg-utils version information.
Exit Codes
An exit code of 0 indicates success while a non-zero exit code indicates
failure. The following failure codes can be returned:
1
Error in command line syntax.
3
A required tool could not be found.
4
The action failed.
Examples
xdg-screensaver suspend 0x1c00007
Causes the screensaver to be disabled till xdg-screensaver resume 0x1c00007 is
called. 0x1c00007 must be the X Window ID of an existing window.
_MANUALPAGE
}
usage()
{
cat << _USAGE
xdg-screensaver - command line tool for controlling the screensaver
Synopsis
xdg-screensaver suspend WindowID
xdg-screensaver resume WindowID
xdg-screensaver { activate | lock | reset | status }
xdg-screensaver { --help | --manual | --version }
_USAGE
}
#@xdg-utils-common@
#----------------------------------------------------------------------------
# Common utility functions included in all XDG wrapper scripts
#----------------------------------------------------------------------------
DEBUG()
{
[ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && return 0;
[ ${XDG_UTILS_DEBUG_LEVEL} -lt $1 ] && return 0;
shift
echo "$@" >&2
}
# This handles backslashes but not quote marks.
first_word()
{
read first rest
echo "$first"
}
#-------------------------------------------------------------
# map a binary to a .desktop file
binary_to_desktop_file()
{
search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
binary="`which "$1"`"
binary="`readlink -f "$binary"`"
base="`basename "$binary"`"
IFS=:
for dir in $search; do
unset IFS
[ "$dir" ] || continue
[ -d "$dir/applications" ] || [ -d "$dir/applnk" ] || continue
for file in "$dir"/applications/*.desktop "$dir"/applications/*/*.desktop "$dir"/applnk/*.desktop "$dir"/applnk/*/*.desktop; do
[ -r "$file" ] || continue
# Check to make sure it's worth the processing.
grep -q "^Exec.*$base" "$file" || continue
# Make sure it's a visible desktop file (e.g. not "preferred-web-browser.desktop").
grep -Eq "^(NoDisplay|Hidden)=true" "$file" && continue
command="`grep -E "^Exec(\[[^]=]*])?=" "$file" | cut -d= -f 2- | first_word`"
command="`which "$command"`"
if [ x"`readlink -f "$command"`" = x"$binary" ]; then
# Fix any double slashes that got added path composition
echo "$file" | sed -e 's,//*,/,g'
return
fi
done
done
}
#-------------------------------------------------------------
# map a .desktop file to a binary
desktop_file_to_binary()
{
search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
desktop="`basename "$1"`"
IFS=:
for dir in $search; do
unset IFS
[ "$dir" ] && [ -d "$dir/applications" ] || [ -d "$dir/applnk" ] || continue
# Check if desktop file contains -
if [ "${desktop#*-}" != "$desktop" ]; then
vendor=${desktop%-*}
app=${desktop#*-}
if [ -r $dir/applications/$vendor/$app ]; then
file_path=$dir/applications/$vendor/$app
elif [ -r $dir/applnk/$vendor/$app ]; then
file_path=$dir/applnk/$vendor/$app
fi
fi
if test -z "$file_path" ; then
for indir in "$dir"/applications/ "$dir"/applications/*/ "$dir"/applnk/ "$dir"/applnk/*/; do
file="$indir/$desktop"
if [ -r "$file" ]; then
file_path=$file
break
fi
done
fi
if [ -r "$file_path" ]; then
# Remove any arguments (%F, %f, %U, %u, etc.).
command="`grep -E "^Exec(\[[^]=]*])?=" "$file_path" | cut -d= -f 2- | first_word`"
command="`which "$command"`"
readlink -f "$command"
return
fi
done
}
#-------------------------------------------------------------
# Exit script on successfully completing the desired operation
exit_success()
{
if [ $# -gt 0 ]; then
echo "$@"
echo
fi
exit 0
}
#-----------------------------------------
# Exit script on malformed arguments, not enough arguments
# or missing required option.
# prints usage information
exit_failure_syntax()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
echo "Try 'xdg-screensaver --help' for more information." >&2
else
usage
echo "Use 'man xdg-screensaver' or 'xdg-screensaver --manual' for additional info."
fi
exit 1
}
#-------------------------------------------------------------
# Exit script on missing file specified on command line
exit_failure_file_missing()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 2
}
#-------------------------------------------------------------
# Exit script on failure to locate necessary tool applications
exit_failure_operation_impossible()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 3
}
#-------------------------------------------------------------
# Exit script on failure returned by a tool application
exit_failure_operation_failed()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 4
}
#------------------------------------------------------------
# Exit script on insufficient permission to read a specified file
exit_failure_file_permission_read()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 5
}
#------------------------------------------------------------
# Exit script on insufficient permission to write a specified file
exit_failure_file_permission_write()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 6
}
check_input_file()
{
if [ ! -e "$1" ]; then
exit_failure_file_missing "file '$1' does not exist"
fi
if [ ! -r "$1" ]; then
exit_failure_file_permission_read "no permission to read file '$1'"
fi
}
check_vendor_prefix()
{
file_label="$2"
[ -n "$file_label" ] || file_label="filename"
file=`basename "$1"`
case "$file" in
[[:alpha:]]*-*)
return
;;
esac
echo "xdg-screensaver: $file_label '$file' does not have a proper vendor prefix" >&2
echo 'A vendor prefix consists of alpha characters ([a-zA-Z]) and is terminated' >&2
echo 'with a dash ("-"). An example '"$file_label"' is '"'example-$file'" >&2
echo "Use --novendor to override or 'xdg-screensaver --manual' for additional info." >&2
exit 1
}
check_output_file()
{
# if the file exists, check if it is writeable
# if it does not exists, check if we are allowed to write on the directory
if [ -e "$1" ]; then
if [ ! -w "$1" ]; then
exit_failure_file_permission_write "no permission to write to file '$1'"
fi
else
DIR=`dirname "$1"`
if [ ! -w "$DIR" ] || [ ! -x "$DIR" ]; then
exit_failure_file_permission_write "no permission to create file '$1'"
fi
fi
}
#----------------------------------------
# Checks for shared commands, e.g. --help
check_common_commands()
{
while [ $# -gt 0 ] ; do
parm="$1"
shift
case "$parm" in
--help)
usage
echo "Use 'man xdg-screensaver' or 'xdg-screensaver --manual' for additional info."
exit_success
;;
--manual)
manualpage
exit_success
;;
--version)
echo "xdg-screensaver 1.1.2"
exit_success
;;
esac
done
}
check_common_commands "$@"
[ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && unset XDG_UTILS_DEBUG_LEVEL;
if [ ${XDG_UTILS_DEBUG_LEVEL-0} -lt 1 ]; then
# Be silent
xdg_redirect_output=" > /dev/null 2> /dev/null"
else
# All output to stderr
xdg_redirect_output=" >&2"
fi
#--------------------------------------
# Checks for known desktop environments
# set variable DE to the desktop environments name, lowercase
detectDE()
{
# see https://bugs.freedesktop.org/show_bug.cgi?id=34164
unset GREP_OPTIONS
if [ -n "${XDG_CURRENT_DESKTOP}" ]; then
case "${XDG_CURRENT_DESKTOP}" in
# only recently added to menu-spec, pre-spec X- still in use
Cinnamon|X-Cinnamon)
DE=cinnamon;
;;
ENLIGHTENMENT)
DE=enlightenment;
;;
# GNOME, GNOME-Classic:GNOME, or GNOME-Flashback:GNOME
GNOME*)
DE=gnome;
;;
KDE)
DE=kde;
;;
LXDE)
DE=lxde;
;;
LXQt)
DE=lxqt;
;;
MATE)
DE=mate;
;;
XFCE)
DE=xfce
;;
X-Generic)
DE=generic
;;
esac
fi
if [ x"$DE" = x"" ]; then
# classic fallbacks
if [ x"$KDE_FULL_SESSION" != x"" ]; then DE=kde;
elif [ x"$GNOME_DESKTOP_SESSION_ID" != x"" ]; then DE=gnome;
elif [ x"$MATE_DESKTOP_SESSION_ID" != x"" ]; then DE=mate;
elif `dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.gnome.SessionManager > /dev/null 2>&1` ; then DE=gnome;
elif xprop -root _DT_SAVE_MODE 2> /dev/null | grep ' = \"xfce4\"$' >/dev/null 2>&1; then DE=xfce;
elif xprop -root 2> /dev/null | grep -i '^xfce_desktop_window' >/dev/null 2>&1; then DE=xfce
elif echo $DESKTOP | grep -q '^Enlightenment'; then DE=enlightenment;
elif [ x"$LXQT_SESSION_CONFIG" != x"" ]; then DE=lxqt;
fi
fi
if [ x"$DE" = x"" ]; then
# fallback to checking $DESKTOP_SESSION
case "$DESKTOP_SESSION" in
gnome)
DE=gnome;
;;
LXDE|Lubuntu)
DE=lxde;
;;
MATE)
DE=mate;
;;
xfce|xfce4|'Xfce Session')
DE=xfce;
;;
esac
fi
if [ x"$DE" = x"" ]; then
# fallback to uname output for other platforms
case "$(uname 2>/dev/null)" in
CYGWIN*)
DE=cygwin;
;;
Darwin)
DE=darwin;
;;
esac
fi
if [ x"$DE" = x"gnome" ]; then
# gnome-default-applications-properties is only available in GNOME 2.x
# but not in GNOME 3.x
which gnome-default-applications-properties > /dev/null 2>&1 || DE="gnome3"
fi
if [ -f "$XDG_RUNTIME_DIR/flatpak-info" ]; then
DE="flatpak"
fi
}
#----------------------------------------------------------------------------
# kfmclient exec/openURL can give bogus exit value in KDE <= 3.5.4
# It also always returns 1 in KDE 3.4 and earlier
# Simply return 0 in such case
kfmclient_fix_exit_code()
{
version=`LC_ALL=C.UTF-8 kde-config --version 2>/dev/null | grep '^KDE'`
major=`echo $version | sed 's/KDE.*: \([0-9]\).*/\1/'`
minor=`echo $version | sed 's/KDE.*: [0-9]*\.\([0-9]\).*/\1/'`
release=`echo $version | sed 's/KDE.*: [0-9]*\.[0-9]*\.\([0-9]\).*/\1/'`
test "$major" -gt 3 && return $1
test "$minor" -gt 5 && return $1
test "$release" -gt 4 && return $1
return 0
}
#----------------------------------------------------------------------------
# Returns true if there is a graphical display attached.
has_display()
{
if [ -n "$DISPLAY" ] || [ -n "$WAYLAND_DISPLAY" ]; then
return 0
else
return 1
fi
}
# Check if we can use "mv -T"
if mv -T ... ... 2>&1 | grep '\.\.\.' > /dev/null ; then
# We can securely move files in /tmp with mv -T
DEBUG 1 "mv -T available"
MV="mv -T"
screensaver_file="/tmp/xdg-screensaver-$USER-"`echo $DISPLAY | sed 's/:/-/g'`
else
# No secure moves available, use home dir
DEBUG 1 "mv -T not available"
MV="mv"
screensaver_file="$HOME/.xdg-screensaver-"`echo $(hostname)-$DISPLAY | sed 's/:/-/g'`
fi
lockfile_command=`which lockfile 2> /dev/null`
lockfile()
{
if [ -n "$lockfile_command" ] ; then
$lockfile_command -1 -l 10 -s 3 "$screensaver_file".lock
else
# Poor man's attempt at doing a lockfile
# Be careful not to facilitate a symlink attack
local try
try=0
while ! ln -s "$screensaver_file".lock "$screensaver_file".lock 2> /dev/null;
do
sleep 1
try=$(($try+1))
if [ $try -eq 3 ] ; then
rm -f "$screensaver_file".lock || return # Can't remove lockfile
try=0
fi
done
fi
}
unlockfile()
{
rm -f "$screensaver_file".lock
}
perform_action()
{
result=1
if [ "$1" = "resume" ] ; then
# Restore DPMS state
if [ -f "$screensaver_file.dpms" ]; then
rm "$screensaver_file.dpms"
# Re-enable DPMS
xset +dpms
fi
fi
if [ "$1" = "reset" ] ; then
if xset -q | grep 'DPMS is Enabled' > /dev/null 2> /dev/null; then
xset -dpms
xset +dpms
xset dpms force on
fi
fi
case "$DE" in
kde)
if [ -n "${KDE_SESSION_VERSION}" ]; then
screensaver_freedesktop "$1"
else
screensaver_kde3 "$1"
fi
;;
gnome_screensaver)
screensaver_gnome_screensaver "$1"
;;
mate_screensaver)
screensaver_mate_screensaver "$1"
;;
cinnamon)
screensaver_cinnamon_screensaver "$1"
;;
xscreensaver)
screensaver_xscreensaver "$1"
;;
xautolock_screensaver)
xautolock_screensaver "$1"
;;
xfce)
[ -n "$DISPLAY" ] && screensaver_xserver "$1"
;;
''|generic)
[ -n "$DISPLAY" ] && screensaver_xserver "$1"
;;
esac
if [ -n "$DISPLAY" -a "$1" = "suspend" ] ; then
# Save DPMS state
if xset -q | grep 'DPMS is Enabled' > /dev/null 2> /dev/null; then
test "${TMPDIR+set}" = set || TMPDIR=/tmp
tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
$MV "$tmpfile" "$screensaver_file.dpms"
# Disable DPMS
xset -dpms
fi
fi
}
cleanup_suspend()
{
lockfile
test "${TMPDIR+set}" = set || TMPDIR=/tmp
tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
grep -v "$window_id:$xprop_pid\$" "$screensaver_file" > "$tmpfile" 2> /dev/null
$MV "$tmpfile" "$screensaver_file"
if [ ! -s "$screensaver_file" ] ; then
rm "$screensaver_file"
unlockfile
# $screensaver_file is empty, do resume
perform_action resume
else
unlockfile
fi
}
do_resume()
{
lockfile # Obtain lockfile
# Find the PID of the trackingprocess
xprop_pid=`grep "$window_id:" "$screensaver_file" 2> /dev/null | cut -d ':' -f 2`
unlockfile # Free lockfile
if [ -n "$xprop_pid" ] && ps -p "$xprop_pid" 2> /dev/null | grep xprop > /dev/null; then
# Kill the tracking process
kill -s TERM $xprop_pid
fi
cleanup_suspend
}
XPROP=`which xprop 2> /dev/null`
check_window_id()
{
if [ -z "$XPROP" ]; then
DEBUG 3 "xprop not found"
return
fi
DEBUG 2 "Running $XPROP -id $window_id"
if $XPROP -id $window_id > /dev/null 2> /dev/null; then
DEBUG 3 Window $window_id exists
else
DEBUG 3 Window $window_id does not exist
exit_failure_operation_failed "Window $window_id does not exist"
fi
}
track_window()
{
if [ -z "$XPROP" ]; then
# Don't track window if we don't have xprop
return
fi
lockfile
test "${TMPDIR+set}" = set || TMPDIR=/tmp
tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
# Filter stale entries from the xdg-screensaver status file
# Return if $window_id is being tracked already
(
already_tracked=1
IFS_save="$IFS"
IFS=":"
while read wid pid; do
if ps -p "$pid" 2> /dev/null | grep xprop > /dev/null; then
echo "$wid:$pid"
if [ $wid = $window_id ] ; then
already_tracked=0
fi
fi
done
IFS="$IFS_save"
exit $already_tracked
) < $screensaver_file > $tmpfile
already_tracked=$?
if [ "$already_tracked" -eq "0" ] ; then
$MV "$tmpfile" "$screensaver_file"
# We are already tracking $window_id, don't do anything
unlockfile
return
fi
# Start tracking $window_id
$XPROP -id $window_id -spy > /dev/null &
xprop_pid=$!
# Add window_id and xprop_pid to the xdg-screensave status file
echo "$window_id:$xprop_pid" >> $tmpfile
$MV "$tmpfile" "$screensaver_file"
unlockfile
# Wait for xprop to exit, it means that the window disappeared
wait $xprop_pid
# Clean up the administration and resume the screensaver
cleanup_suspend
}
screensaver_freedesktop()
{
case "$1" in
suspend)
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
--print-reply \
--reply-timeout=2000 \
/ScreenSaver \
org.freedesktop.ScreenSaver.Inhibit \
string:$window_id \
string:xdg-screensaver \
| grep uint32 | cut -d ' ' -f 5 >| "$screensaver_file.cookie" \
2> /dev/null
result=$?
;;
resume)
if [ -f "$screensaver_file.cookie" ] ; then
value=`cat "$screensaver_file.cookie"`
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
/ScreenSaver \
org.freedesktop.ScreenSaver.UnInhibit \
uint32:$value \
2> /dev/null
rm -f "$screensaver_file.cookie"
fi
result=$?
;;
activate)
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
/ScreenSaver \
org.freedesktop.ScreenSaver.SetActive \
boolean:true \
2> /dev/null
result=$?
;;
lock)
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
/ScreenSaver \
org.freedesktop.ScreenSaver.Lock \
2> /dev/null
;;
reset)
if [ -f "$screensaver_file.cookie" ] ; then
value=`cat "$screensaver_file.cookie"`
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
/ScreenSaver \
org.freedesktop.ScreenSaver.UnInhibit \
uint32:$value \
2> /dev/null
rm -f "$screensaver_file.cookie"
fi
result=$?
;;
status)
status=`dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
--print-reply \
--reply-timeout=2000 \
/ScreenSaver \
org.freedesktop.ScreenSaver.GetActive \
| grep boolean | cut -d ' ' -f 5`
result=$?
if [ x"$status" = "xtrue" -o x"$status" = "xfalse" ]; then
echo "enabled"
elif [ x"$result" != "x0" ]; then
echo "ERROR: dbus org.freedesktop.ScreenSaver.GetActive returned '$status'" >&2
return 1
else
echo "disabled"
fi
;;
*)
echo "ERROR: Unknown command '$1'" >&2
return 1
;;
esac
}
screensaver_kde3()
{
case "$1" in
suspend)
dcop kdesktop KScreensaverIface enable false > /dev/null
result=$?
;;
resume)
dcop kdesktop KScreensaverIface configure > /dev/null
result=$?
;;
activate)
dcop kdesktop KScreensaverIface save > /dev/null
result=$?
;;
lock)
dcop kdesktop KScreensaverIface lock > /dev/null
result=$?
;;
reset)
# Turns the screensaver off right now
dcop kdesktop KScreensaverIface quit > /dev/null
result=$?
;;
status)
status=`dcop kdesktop KScreensaverIface isEnabled`
result=$?
if [ x"$status" = "xtrue" ]; then
echo "enabled"
elif [ x"$status" = "xfalse" ]; then
echo "disabled"
else
echo "ERROR: kdesktop KScreensaverIface isEnabled returned '$status'" >&2
return 1
fi
;;
*)
echo "ERROR: Unknown command '$1'" >&2
return 1
;;
esac
}
xset_screensaver_timeout()
{
xset q | sed '/^Screen Saver:/,/^[^ ]/ { s/.*timeout: *\([0-9]*\).*/\1/; t }; d'
}
screensaver_xserver()
{
case "$1" in
suspend)
timeout=`xset_screensaver_timeout`
if [ "$timeout" -gt 0 ]; then
echo "$timeout" > "$screensaver_file.xset"
xset s off > /dev/null
fi
result=$?
;;
resume)
if [ -f "$screensaver_file.xset" ] ; then
value=`cat "$screensaver_file.xset"`
xset s $value > /dev/null
rm -f "$screensaver_file.xset"
fi
result=$?
;;
activate)
xset s activate > /dev/null
result=$?
;;
reset)
xset s reset > /dev/null
result=$?
;;
status)
timeout=`xset_screensaver_timeout`
result=$?
if [ "$timeout" -gt 0 ]; then
echo "enabled"
elif [ "$timeout" -eq 0 ]; then
echo "disabled"
else
echo "ERROR: xset q did not report the screensaver timeout" >&2
return 1
fi
;;
*)
echo "ERROR: Unknown command '$1'" >&2
return 1
;;
esac
}
screensaver_suspend_loop()
{
lockfile
test "${TMPDIR+set}" = set || TMPDIR=/tmp
tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
# Filter stale entries from the xdg-screensaver status file
cat "$screensaver_file" 2> /dev/null | (
IFS_save="$IFS"
IFS=":"
while read wid pid; do
if ps -p "$pid" 2> /dev/null | grep xprop > /dev/null; then
echo "$wid:$pid"
fi
done
IFS="$IFS_save"
) > $tmpfile
if [ -s "$tmpfile" ] ; then
# Suspend pending, don't do a thing
$MV "$tmpfile" "$screensaver_file"
unlockfile
return
fi
$MV "$tmpfile" "$screensaver_file"
unlockfile
(while [ -f "$screensaver_file" ]; do $*; sleep 50; done) > /dev/null 2> /dev/null &
}
screensaver_gnome_screensaver()
{
# DBUS interface for gnome-screensaver
# http://people.gnome.org/~mccann/gnome-screensaver/docs/gnome-screensaver.html
case "$1" in
suspend)
perl -e '
use strict;
use warnings;
use Encode qw(decode);
use IO::File;
use Net::DBus;
use X11::Protocol;
my ($window_id, $screensaver_file) = @ARGV;
# Find window name to pass to session manager.
my $x = X11::Protocol->new();
my $named_window_id = hex($window_id);
my $window_name;
while (1) {
($window_name) = $x->GetProperty($named_window_id, $x->atom("WM_NAME"),
$x->atom("STRING"), 0, 1000, 0);
last if defined($window_name) && $window_name ne "";
(undef, $named_window_id) = $x->QueryTree($named_window_id);
if (!defined($named_window_id)) {
$window_name = "?";
last;
}
}
# Replace any invalid unicode characters with U+FFFD, so we dont crash when we
# pass them over to D-Bus
$window_name = decode("utf8", $window_name, Encode::FB_DEFAULT);
# Inhibit idle detection (flags = 8) with window name and ID.
# We have no reason so just send the window name again.
my $bus = Net::DBus->session();
my $sm_svc = $bus->get_service("org.gnome.SessionManager");
my $sm = $sm_svc->get_object("/org/gnome/SessionManager",
"org.gnome.SessionManager");
$sm->Inhibit($window_name, hex($window_id), $window_name, 8);
# Wait until removed from the status file.
while (1) {
sleep(10);
my $status = new IO::File($screensaver_file, "r")
or exit 0;
my $found;
while (<$status>) {
if (/^$window_id:/) {
$found = 1;
last;
}
}
exit 0 unless $found;
}
' $window_id $screensaver_file &
result=0
;;
resume)
# Automatic resume when $screensaver_file disappears
result=0
;;
activate)
dbus-send --session \
--dest=org.gnome.ScreenSaver \
--type=method_call \
/org/gnome/ScreenSaver \
org.gnome.ScreenSaver.SetActive \
boolean:true \
2> /dev/null
result=$?
;;
lock)
dbus-send --session \
--dest=org.gnome.ScreenSaver \
--type=method_call \
/org/gnome/ScreenSaver \
org.gnome.ScreenSaver.Lock \
2> /dev/null
result=$?
;;
reset)
# Turns the screensaver off right now
dbus-send --session \
--dest=org.gnome.ScreenSaver \
--type=method_call \
/org/gnome/ScreenSaver \
org.gnome.ScreenSaver.SimulateUserActivity \
2> /dev/null
result=$?
;;
status)
status=`dbus-send --session \
--dest=org.gnome.ScreenSaver \
--type=method_call \
--print-reply \
--reply-timeout=2000 \
/org/gnome/ScreenSaver \
org.gnome.ScreenSaver.GetActive \
| grep boolean | cut -d ' ' -f 5`
result=$?
if [ x"$status" = "xtrue" -o x"$status" = "xfalse" ]; then
echo "enabled"
elif [ x"$result" != "x0" ]; then
echo "ERROR: dbus org.gnome.ScreenSaver.GetActive returned '$status'" >&2
return 1
else
echo "disabled"
fi
;;
*)
echo "ERROR: Unknown command '$1" >&2
return 1
;;
esac
}
screensaver_mate_screensaver()
{
# DBUS interface for mate-screensaver
# This is same as gnome's for now but may change in the future as MATE
# does not follow gnome's developement necessarily.
case "$1" in
suspend)
screensaver_suspend_loop \
dbus-send --session \
--dest=org.mate.ScreenSaver \
--type=method_call \
/org/mate/ScreenSaver \
org.mate.ScreenSaver.SimulateUserActivity \
2> /dev/null
result=$?
;;
resume)
# Automatic resume when $screensaver_file disappears
result=0
;;
activate)
dbus-send --session \
--dest=org.mate.ScreenSaver \
--type=method_call \
/org/mate/ScreenSaver \
org.mate.ScreenSaver.SetActive \
boolean:true \
2> /dev/null
result=$?
;;
lock)
mate-screensaver-command --lock > /dev/null 2> /dev/null
result=$?
;;
reset)
# Turns the screensaver off right now
dbus-send --session \
--dest=org.mate.ScreenSaver \
--type=method_call \
/org/mate/ScreenSaver \
org.mate.ScreenSaver.SimulateUserActivity \
2> /dev/null
result=$?
;;
status)
status=`dbus-send --session \
--dest=org.mate.ScreenSaver \
--type=method_call \
--print-reply \
--reply-timeout=2000 \
/org/mate/ScreenSaver \
org.mate.ScreenSaver.GetActive \
| grep boolean | cut -d ' ' -f 5`
result=$?
if [ x"$status" = "xtrue" -o x"$status" = "xfalse" ]; then
echo "enabled"
elif [ x"$result" != "x0" ]; then
echo "ERROR: dbus org.mate.ScreenSaver.GetActive returned '$status'" >&2
return 1
else
echo "disabled"
fi
;;
*)
echo "ERROR: Unknown command '$1" >&2
return 1
;;
esac
}
screensaver_cinnamon_screensaver()
{
# DBUS interface for cinnamon-screensaver
# https://raw.githubusercontent.com/linuxmint/cinnamon-screensaver/master/doc/dbus-interface.html
case "$1" in
suspend)
screensaver_suspend_loop \
dbus-send --session \
--dest=org.cinnamon.ScreenSaver \
--type=method_call \
/org/cinnamon/ScreenSaver \
org.cinnamon.ScreenSaver.SimulateUserActivity \
2> /dev/null
result=$?
;;
resume)
# Automatic resume when $screensaver_file disappears
result=0
;;
activate)
dbus-send --session \
--dest=org.cinnamon.ScreenSaver \
--type=method_call \
/org/cinnamon/ScreenSaver \
org.cinnamon.ScreenSaver.SetActive \
boolean:true \
2> /dev/null
result=$?
;;
lock)
dbus-send --session \
--dest=org.cinnamon.ScreenSaver \
--type=method_call \
/org/cinnamon/ScreenSaver \
org.cinnamon.ScreenSaver.Lock \
string:"" \
2> /dev/null
result=$?
;;
reset)
# Turns the screensaver off right now
dbus-send --session \
--dest=org.cinnamon.ScreenSaver \
--type=method_call \
/org/cinnamon/ScreenSaver \
org.cinnamon.ScreenSaver.SimulateUserActivity \
2> /dev/null
result=$?
;;
status)
status=`dbus-send --session \
--dest=org.cinnamon.ScreenSaver \
--type=method_call \
--print-reply \
--reply-timeout=2000 \
/org/cinnamon/ScreenSaver \
org.cinnamon.ScreenSaver.GetActive \
| grep boolean | cut -d ' ' -f 5`
result=$?
if [ x"$status" = "xtrue" ]; then
echo "enabled"
elif [ x"$status" = "xfalse" ]; then
echo "disabled"
else
echo "ERROR: dbus org.cinnamon.ScreenSaver.GetActive returned '$status'" >&2
return 1
fi
;;
*)
echo "ERROR: Unknown command '$1" >&2
return 1
;;
esac
}
screensaver_xscreensaver()
{
case "$1" in
suspend)
screensaver_suspend_loop xscreensaver-command -deactivate
result=0
;;
resume)
# Automatic resume when $screensaver_file disappears
result=0
;;
activate)
xscreensaver-command -activate > /dev/null 2> /dev/null
result=$?
;;
lock)
xscreensaver-command -lock > /dev/null 2> /dev/null
result=$?
;;
reset)
# Turns the screensaver off right now
xscreensaver-command -deactivate > /dev/null 2> /dev/null
result=$?
;;
status)
result=0
if [ -f "$screensaver_file" ] ; then
echo "disabled"
else
echo "enabled"
fi
;;
*)
echo "ERROR: Unknown command '$1" >&2
return 1
;;
esac
}
xautolock_screensaver()
{
case "$1" in
suspend)
xset s off && xautolock -disable > /dev/null
result=$?
;;
resume)
xset s default && xautolock -enable > /dev/null
result=$?
;;
activate)
xautolock -enable
result=$?
;;
lock)
xautolock -locknow
result=$?
;;
reset)
xautolock -restart
result=$?
;;
status)
xautolock -unlocknow >/dev/null
result=$?
if [ $result -eq 0 ]; then
echo "enabled"
else
echo "disabled"
fi
;;
*)
echo "ERROR: Unknown command '$1" >&2
return 1
;;
esac
}
[ x"$1" != x"" ] || exit_failure_syntax
action=
window_id=
case $1 in
suspend)
action="$1"
shift
if [ -z "$1" ] ; then
exit_failure_syntax "WindowID argument missing"
fi
window_id="$1"
check_window_id
;;
resume)
action="$1"
shift
if [ -z "$1" ] ; then
exit_failure_syntax "WindowID argument missing"
fi
window_id="$1"
check_window_id
;;
activate)
action="$1"
;;
lock)
action="$1"
;;
reset)
action="$1"
;;
status)
action="$1"
;;
*)
exit_failure_syntax "unknown command '$1'"
;;
esac
detectDE
# Consider "xscreensaver" a separate DE
xscreensaver-command -version 2> /dev/null | grep XScreenSaver > /dev/null && DE="xscreensaver"
# Consider "gnome-screensaver" a separate DE
dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.gnome.ScreenSaver > /dev/null 2>&1 && DE="gnome_screensaver"
# Consider "mate-screensaver" a separate DE
dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.mate.ScreenSaver > /dev/null 2>&1 && DE="mate_screensaver"
# Consider "xautolock" a separate DE
xautolock -enable > /dev/null 2>&1 && DE="xautolock_screensaver"
if [ "$action" = "resume" ] ; then
do_resume
exit_success
fi
perform_action "$action"
if [ "$action" = "suspend" ] ; then
# Start tracking $window_id and resume the screensaver once it disappears
( track_window ) 2> /dev/null > /dev/null &
fi
if [ $result -eq 0 ]; then
exit_success
else
exit_failure_operation_failed
fi
|