1#!/bin/sh
2#---------------------------------------------
3#   xdg-screensaver
4#
5#   Utility script to control screensaver.
6#
7#   Refer to the usage() function below for usage.
8#
9#   Copyright 2006, Bryce Harrington <bryce@osdl.org>
10#
11#   LICENSE:
12#
13#---------------------------------------------
14
15manualpage()
16{
17cat << _MANUALPAGE
18_MANUALPAGE
19}
20
21usage()
22{
23cat << _USAGE
24_USAGE
25}
26
27#@xdg-utils-common@
28
29# Check if we can use "mv -T"
30# FreeBSD mv doesn't support this, so supress scary messages in the terminal
31#if mv -T ... ... 2>&1 | grep '\.\.\.' > /dev/null ; then
32if false; then
33   # We can securely move files in /tmp with mv -T
34   DEBUG 1 "mv -T available"
35   MV="mv -T"
36   screensaver_file="/tmp/xdg-screensaver-$USER-"`echo $DISPLAY | sed 's/:/-/g'`
37else
38   # No secure moves available, use home dir
39   DEBUG 1 "mv -T not available"
40   MV="mv"
41   screensaver_file="$HOME/.xdg-screensaver-"`echo $(hostname)-$DISPLAY | sed 's/:/-/g'`
42fi
43lockfile_command=`which lockfile 2> /dev/null`
44
45lockfile()
46{
47  if [ -n "$lockfile_command" ] ; then
48     $lockfile_command -1 -l 10 -s 3 "$screensaver_file".lock
49  else
50     # Poor man's attempt at doing a lockfile
51     # Be careful not to facilitate a symlink attack
52     local try
53     try=0
54     while ! ln -s "$screensaver_file".lock "$screensaver_file".lock 2> /dev/null;
55     do
56        sleep 1
57        try=$(($try+1))
58        if [ $try -eq 3 ] ; then
59            rm -f "$screensaver_file".lock || return # Can't remove lockfile
60            try=0
61        fi
62     done
63  fi
64}
65
66unlockfile()
67{
68  rm -f "$screensaver_file".lock
69}
70
71perform_action()
72{
73  result=1
74
75  if [ "$1" = "resume" ] ; then
76      # Restore DPMS state
77      if [ -f "$screensaver_file.dpms" ]; then
78          rm "$screensaver_file.dpms"
79          # Re-enable DPMS
80          xset +dpms
81      fi
82  fi
83  if [ "$1" = "reset" ] ; then
84      if xset -q | grep 'DPMS is Enabled' > /dev/null 2> /dev/null; then
85          xset -dpms
86          xset +dpms
87          xset dpms force on
88      fi
89  fi
90
91  case "$DE" in
92    kde)
93      if [ -n "${KDE_SESSION_VERSION}" ]; then
94        screensaver_freedesktop "$1"
95      else
96        screensaver_kde3 "$1"
97      fi
98      ;;
99    gnome_screensaver)
100      screensaver_gnome_screensaver "$1"
101      ;;
102
103    mate_screensaver)
104      screensaver_mate_screensaver "$1"
105      ;;
106
107    cinnamon)
108      screensaver_cinnamon_screensaver "$1"
109      ;;
110
111    xscreensaver)
112      screensaver_xscreensaver "$1"
113      ;;
114
115    xautolock_screensaver)
116      xautolock_screensaver "$1"
117      ;;
118
119    xfce)
120      [ -n "$DISPLAY" ] && screensaver_xserver "$1"
121      ;;
122
123    ''|generic)
124      [ -n "$DISPLAY" ] && screensaver_xserver "$1"
125      ;;
126  esac
127
128  if [ -n "$DISPLAY" -a "$1" = "suspend" ] ; then
129      # Save DPMS state
130      if xset -q | grep 'DPMS is Enabled' > /dev/null 2> /dev/null; then
131          test "${TMPDIR+set}" = set || TMPDIR=/tmp
132          tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
133          $MV "$tmpfile" "$screensaver_file.dpms"
134          # Disable DPMS
135          xset -dpms
136      fi
137  fi
138
139}
140
141cleanup_suspend()
142{
143  lockfile
144  test "${TMPDIR+set}" = set || TMPDIR=/tmp
145  tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
146  grep -v "$window_id:$xprop_pid\$" "$screensaver_file" > "$tmpfile" 2> /dev/null
147  $MV "$tmpfile" "$screensaver_file"
148  if [ ! -s "$screensaver_file" ] ; then
149      rm "$screensaver_file"
150      unlockfile
151      # $screensaver_file is empty, do resume
152      perform_action resume
153  else
154      unlockfile
155  fi
156}
157
158do_resume()
159{
160  lockfile # Obtain lockfile
161  # Find the PID of the trackingprocess
162  xprop_pid=`grep "$window_id:" "$screensaver_file" 2> /dev/null | cut -d ':' -f 2`
163  unlockfile # Free lockfile
164  if [ -n "$xprop_pid" ] && ps -p "$xprop_pid" 2> /dev/null | grep xprop > /dev/null; then
165     # Kill the tracking process
166     kill -s TERM $xprop_pid
167  fi
168  cleanup_suspend
169}
170
171XPROP=`which xprop 2> /dev/null`
172
173check_window_id()
174{
175  if [ -z "$XPROP" ]; then
176     DEBUG 3 "xprop not found"
177     return
178  fi
179  DEBUG 2 "Running $XPROP -id $window_id"
180  if $XPROP -id $window_id > /dev/null 2> /dev/null; then
181     DEBUG 3 Window $window_id exists
182  else
183     DEBUG 3 Window $window_id does not exist
184     exit_failure_operation_failed "Window $window_id does not exist"
185  fi
186}
187
188track_window()
189{
190  if [ -z "$XPROP" ]; then
191     # Don't track window if we don't have xprop
192     return
193  fi
194  lockfile
195
196  test "${TMPDIR+set}" = set || TMPDIR=/tmp
197  tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
198  # Filter stale entries from the xdg-screensaver status file
199  # Return if $window_id is being tracked already
200  (
201    already_tracked=1
202    IFS_save="$IFS"
203    IFS=":"
204    while read wid pid; do
205      if ps -p "$pid" 2> /dev/null | grep xprop > /dev/null; then
206        echo "$wid:$pid"
207        if [ $wid = $window_id ] ; then
208          already_tracked=0
209        fi
210      fi
211    done
212    IFS="$IFS_save"
213    exit $already_tracked
214  ) < $screensaver_file > $tmpfile
215  already_tracked=$?
216
217  if [ "$already_tracked" -eq "0" ] ; then
218    $MV "$tmpfile" "$screensaver_file"
219    # We are already tracking $window_id, don't do anything
220    unlockfile
221    return
222  fi
223
224  # Start tracking $window_id
225  $XPROP -id $window_id -spy > /dev/null &
226  xprop_pid=$!
227  # Add window_id and xprop_pid to the xdg-screensave status file
228  echo "$window_id:$xprop_pid" >> $tmpfile
229  $MV "$tmpfile" "$screensaver_file"
230  unlockfile
231  # Wait for xprop to exit, it means that the window disappeared
232  wait $xprop_pid
233  # Clean up the administration and resume the screensaver
234  cleanup_suspend
235}
236
237screensaver_freedesktop()
238{
239    case "$1" in
240        suspend)
241        dbus-send --session \
242                  --dest=org.freedesktop.ScreenSaver \
243                  --type=method_call \
244                  --print-reply \
245                  --reply-timeout=2000 \
246                  /ScreenSaver \
247                  org.freedesktop.ScreenSaver.Inhibit \
248                  string:$window_id \
249                  string:xdg-screensaver \
250                  | grep uint32 | cut -d ' ' -f 5 >| "$screensaver_file.cookie" \
251                  2> /dev/null
252        result=$?
253        ;;
254
255        resume)
256        if [ -f "$screensaver_file.cookie" ] ; then
257            value=`cat "$screensaver_file.cookie"`
258            dbus-send --session \
259                      --dest=org.freedesktop.ScreenSaver \
260                      --type=method_call \
261                      /ScreenSaver \
262                      org.freedesktop.ScreenSaver.UnInhibit \
263                      uint32:$value \
264                      2> /dev/null
265            rm -f "$screensaver_file.cookie"
266        fi
267        result=$?
268        ;;
269
270        activate)
271        dbus-send --session \
272                  --dest=org.freedesktop.ScreenSaver \
273                  --type=method_call \
274                  /ScreenSaver \
275                  org.freedesktop.ScreenSaver.SetActive \
276                  boolean:true \
277                  2> /dev/null
278        result=$?
279        ;;
280
281        lock)
282        dbus-send --session \
283                  --dest=org.freedesktop.ScreenSaver \
284                  --type=method_call \
285                  /ScreenSaver \
286                  org.freedesktop.ScreenSaver.Lock \
287                  2> /dev/null
288        ;;
289
290        reset)
291        if [ -f "$screensaver_file.cookie" ] ; then
292            value=`cat "$screensaver_file.cookie"`
293            dbus-send --session \
294                      --dest=org.freedesktop.ScreenSaver \
295                      --type=method_call \
296                      /ScreenSaver \
297                      org.freedesktop.ScreenSaver.UnInhibit \
298                      uint32:$value \
299                      2> /dev/null
300            rm -f "$screensaver_file.cookie"
301        fi
302        result=$?
303        ;;
304
305        status)
306        status=`dbus-send --session \
307                          --dest=org.freedesktop.ScreenSaver \
308                          --type=method_call \
309                          --print-reply \
310                          --reply-timeout=2000 \
311                          /ScreenSaver \
312                          org.freedesktop.ScreenSaver.GetActive \
313                          | grep boolean | cut -d ' ' -f 5`
314        result=$?
315        if [ x"$status" = "xtrue" -o x"$status" = "xfalse" ]; then
316            echo "enabled"
317        elif [ x"$result" != "x0" ]; then
318            echo "ERROR: dbus org.freedesktop.ScreenSaver.GetActive returned '$status'" >&2
319            return 1
320        else
321            echo "disabled"
322        fi
323        ;;
324
325        *)
326        echo "ERROR: Unknown command '$1'" >&2
327        return 1
328        ;;
329    esac
330}
331
332screensaver_kde3()
333{
334    case "$1" in
335        suspend)
336        dcop kdesktop KScreensaverIface enable false > /dev/null
337        result=$?
338        ;;
339
340        resume)
341        dcop kdesktop KScreensaverIface configure > /dev/null
342        result=$?
343        ;;
344
345        activate)
346        dcop kdesktop KScreensaverIface save > /dev/null
347        result=$?
348        ;;
349
350        lock)
351        dcop kdesktop KScreensaverIface lock > /dev/null
352        result=$?
353        ;;
354
355        reset)
356        # Turns the screensaver off right now
357        dcop kdesktop KScreensaverIface quit > /dev/null
358        result=$?
359        ;;
360
361        status)
362        status=`dcop kdesktop KScreensaverIface isEnabled`
363        result=$?
364        if [ x"$status" = "xtrue" ]; then
365            echo "enabled"
366        elif [ x"$status" = "xfalse" ]; then
367            echo "disabled"
368        else
369            echo "ERROR: kdesktop KScreensaverIface isEnabled returned '$status'" >&2
370            return 1
371        fi
372        ;;
373
374        *)
375        echo "ERROR: Unknown command '$1'" >&2
376        return 1
377        ;;
378    esac
379}
380
381xset_screensaver_timeout()
382{
383  xset q | sed '/^Screen Saver:/,/^[^ ]/ { s/.*timeout: *\([0-9]*\).*/\1/; t
384  }; d'
385}
386
387screensaver_xserver()
388{
389    case "$1" in
390        suspend)
391        timeout=`xset_screensaver_timeout`
392        if [ "$timeout" -gt 0 ]; then
393            echo "$timeout" > "$screensaver_file.xset"
394            xset s off > /dev/null
395        fi
396        result=$?
397        ;;
398
399        resume)
400        if [ -f "$screensaver_file.xset" ] ; then
401            value=`cat "$screensaver_file.xset"`
402            xset s $value > /dev/null
403            rm -f "$screensaver_file.xset"
404        fi
405        result=$?
406        ;;
407
408        activate)
409        xset s activate > /dev/null
410        result=$?
411        ;;
412
413        reset)
414        xset s reset > /dev/null
415        result=$?
416        ;;
417
418        status)
419        timeout=`xset_screensaver_timeout`
420        result=$?
421        if [ "$timeout" -gt 0 ]; then
422            echo "enabled"
423        elif [ "$timeout" -eq 0 ]; then
424            echo "disabled"
425        else
426            echo "ERROR: xset q did not report the screensaver timeout" >&2
427            return 1
428        fi
429        ;;
430
431        *)
432        echo "ERROR: Unknown command '$1'" >&2
433        return 1
434        ;;
435    esac
436}
437
438screensaver_suspend_loop()
439{
440  lockfile
441  test "${TMPDIR+set}" = set || TMPDIR=/tmp
442  tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
443  # Filter stale entries from the xdg-screensaver status file
444  cat "$screensaver_file" 2> /dev/null | (
445    IFS_save="$IFS"
446    IFS=":"
447    while read wid pid; do
448      if ps -p "$pid" 2> /dev/null | grep xprop > /dev/null; then
449        echo "$wid:$pid"
450      fi
451    done
452    IFS="$IFS_save"
453  ) > $tmpfile
454  if [ -s "$tmpfile" ] ; then
455    # Suspend pending, don't do a thing
456    $MV "$tmpfile" "$screensaver_file"
457    unlockfile
458    return
459  fi
460  $MV "$tmpfile" "$screensaver_file"
461  unlockfile
462  (while [ -f "$screensaver_file" ]; do $*; sleep 50; done) > /dev/null 2> /dev/null &
463}
464
465screensaver_gnome_screensaver()
466{
467# DBUS interface for gnome-screensaver
468# http://people.gnome.org/~mccann/gnome-screensaver/docs/gnome-screensaver.html
469    case "$1" in
470        suspend)
471        perl -e '
472use strict;
473use warnings;
474use IO::File;
475use Net::DBus;
476use X11::Protocol;
477
478my ($window_id, $screensaver_file) = @ARGV;
479
480# Find window name to pass to session manager.
481my $x = X11::Protocol->new();
482my $named_window_id = hex($window_id);
483my $window_name;
484while (1) {
485  ($window_name) = $x->GetProperty($named_window_id, $x->atom("WM_NAME"),
486				   $x->atom("STRING"), 0, 1000, 0);
487  last if defined($window_name) && $window_name ne "";
488  (undef, $named_window_id) = $x->QueryTree($named_window_id);
489  if (!defined($named_window_id)) {
490    $window_name = "?";
491    last;
492  }
493}
494
495# Inhibit idle detection (flags = 8) with window name and ID.
496# We have no reason so just send the window name again.
497my $bus = Net::DBus->session();
498my $sm_svc = $bus->get_service("org.gnome.SessionManager");
499my $sm = $sm_svc->get_object("/org/gnome/SessionManager",
500			     "org.gnome.SessionManager");
501$sm->Inhibit($window_name, hex($window_id), $window_name, 8);
502
503# Wait until removed from the status file.
504while (1) {
505  sleep(10);
506  my $status = new IO::File($screensaver_file, "r")
507    or exit 0;
508  my $found;
509  while (<$status>) {
510    if (/^$window_id:/) {
511      $found = 1;
512      last;
513    }
514  }
515  exit 0 unless $found;
516}
517' $window_id $screensaver_file &
518        result=0
519        ;;
520
521        resume)
522        # Automatic resume when $screensaver_file disappears
523        result=0
524        ;;
525
526        activate)
527        dbus-send --session \
528                  --dest=org.gnome.ScreenSaver \
529                  --type=method_call \
530                  /org/gnome/ScreenSaver \
531                  org.gnome.ScreenSaver.SetActive \
532                  boolean:true \
533                  2> /dev/null
534        result=$?
535        ;;
536
537        lock)
538        dbus-send --session \
539                  --dest=org.gnome.ScreenSaver \
540                  --type=method_call \
541                  /org/gnome/ScreenSaver \
542                  org.gnome.ScreenSaver.Lock \
543                  2> /dev/null
544        result=$?
545        ;;
546
547        reset)
548        # Turns the screensaver off right now
549        dbus-send --session \
550                  --dest=org.gnome.ScreenSaver \
551                  --type=method_call \
552                  /org/gnome/ScreenSaver \
553                  org.gnome.ScreenSaver.SimulateUserActivity \
554                 2> /dev/null
555        result=$?
556        ;;
557
558        status)
559        status=`dbus-send --session \
560                          --dest=org.gnome.ScreenSaver \
561                          --type=method_call \
562                          --print-reply \
563                          --reply-timeout=2000 \
564                          /org/gnome/ScreenSaver \
565                          org.gnome.ScreenSaver.GetActive \
566                          | grep boolean | cut -d ' ' -f 5`
567        result=$?
568        if [ x"$status" = "xtrue" -o x"$status" = "xfalse" ]; then
569            echo "enabled"
570        elif [ x"$result" != "x0" ]; then
571            echo "ERROR: dbus org.gnome.ScreenSaver.GetActive returned '$status'" >&2
572            return 1
573        else
574            echo "disabled"
575        fi
576        ;;
577
578        *)
579        echo "ERROR: Unknown command '$1" >&2
580        return 1
581        ;;
582    esac
583}
584
585screensaver_mate_screensaver()
586{
587# DBUS interface for mate-screensaver
588# This is same as gnome's for now but may change in the future as MATE
589# does not follow gnome's development necessarily.
590    case "$1" in
591        suspend)
592        screensaver_suspend_loop \
593        dbus-send --session \
594                  --dest=org.mate.ScreenSaver \
595                  --type=method_call \
596                  /org/mate/ScreenSaver \
597                  org.mate.ScreenSaver.SimulateUserActivity \
598                  2> /dev/null
599        result=$?
600        ;;
601
602        resume)
603        # Automatic resume when $screensaver_file disappears
604        result=0
605        ;;
606
607        activate)
608        dbus-send --session \
609                  --dest=org.mate.ScreenSaver \
610                  --type=method_call \
611                  /org/mate/ScreenSaver \
612                  org.mate.ScreenSaver.SetActive \
613                  boolean:true \
614                  2> /dev/null
615        result=$?
616        ;;
617
618        lock)
619        mate-screensaver-command --lock > /dev/null 2> /dev/null
620        result=$?
621        ;;
622
623        reset)
624        # Turns the screensaver off right now
625        dbus-send --session \
626                  --dest=org.mate.ScreenSaver \
627                  --type=method_call \
628                  /org/mate/ScreenSaver \
629                  org.mate.ScreenSaver.SimulateUserActivity \
630                 2> /dev/null
631        result=$?
632        ;;
633
634        status)
635        status=`dbus-send --session \
636                          --dest=org.mate.ScreenSaver \
637                          --type=method_call \
638                          --print-reply \
639                          --reply-timeout=2000 \
640                          /org/mate/ScreenSaver \
641                          org.mate.ScreenSaver.GetActive \
642                          | grep boolean | cut -d ' ' -f 5`
643        result=$?
644        if [ x"$status" = "xtrue" -o x"$status" = "xfalse" ]; then
645            echo "enabled"
646        elif [ x"$result" != "x0" ]; then
647            echo "ERROR: dbus org.mate.ScreenSaver.GetActive returned '$status'" >&2
648            return 1
649        else
650            echo "disabled"
651        fi
652        ;;
653
654        *)
655        echo "ERROR: Unknown command '$1" >&2
656        return 1
657        ;;
658    esac
659}
660
661screensaver_cinnamon_screensaver()
662{
663# DBUS interface for cinnamon-screensaver
664# https://raw.githubusercontent.com/linuxmint/cinnamon-screensaver/master/doc/dbus-interface.html
665    case "$1" in
666        suspend)
667        screensaver_suspend_loop \
668        dbus-send --session \
669                  --dest=org.cinnamon.ScreenSaver \
670                  --type=method_call \
671                  /org/cinnamon/ScreenSaver \
672                  org.cinnamon.ScreenSaver.SimulateUserActivity \
673                  2> /dev/null
674        result=$?
675        ;;
676
677        resume)
678        # Automatic resume when $screensaver_file disappears
679        result=0
680        ;;
681
682        activate)
683        dbus-send --session \
684                  --dest=org.cinnamon.ScreenSaver \
685                  --type=method_call \
686                  /org/cinnamon/ScreenSaver \
687                  org.cinnamon.ScreenSaver.SetActive \
688                  boolean:true \
689                  2> /dev/null
690        result=$?
691        ;;
692
693        lock)
694        dbus-send --session \
695                  --dest=org.cinnamon.ScreenSaver \
696                  --type=method_call \
697                  /org/cinnamon/ScreenSaver \
698                  org.cinnamon.ScreenSaver.Lock \
699                  string:"" \
700                  2> /dev/null
701
702        result=$?
703        ;;
704
705        reset)
706        # Turns the screensaver off right now
707        dbus-send --session \
708                  --dest=org.cinnamon.ScreenSaver \
709                  --type=method_call \
710                  /org/cinnamon/ScreenSaver \
711                  org.cinnamon.ScreenSaver.SimulateUserActivity \
712                 2> /dev/null
713        result=$?
714        ;;
715
716        status)
717        status=`dbus-send --session \
718                          --dest=org.cinnamon.ScreenSaver \
719                          --type=method_call \
720                          --print-reply \
721                          --reply-timeout=2000 \
722                          /org/cinnamon/ScreenSaver \
723                          org.cinnamon.ScreenSaver.GetActive \
724                          | grep boolean | cut -d ' ' -f 5`
725        result=$?
726        if [ x"$status" = "xtrue" ]; then
727            echo "enabled"
728        elif [ x"$status" = "xfalse" ]; then
729            echo "disabled"
730        else
731            echo "ERROR: dbus org.cinnamon.ScreenSaver.GetActive returned '$status'" >&2
732            return 1
733        fi
734        ;;
735
736        *)
737        echo "ERROR: Unknown command '$1" >&2
738        return 1
739        ;;
740    esac
741}
742
743screensaver_xscreensaver()
744{
745    case "$1" in
746        suspend)
747        screensaver_suspend_loop xscreensaver-command -deactivate
748        result=0
749        ;;
750
751        resume)
752        # Automatic resume when $screensaver_file disappears
753        result=0
754        ;;
755
756        activate)
757        xscreensaver-command -activate > /dev/null 2> /dev/null
758        result=$?
759        ;;
760
761        lock)
762        xscreensaver-command -lock > /dev/null 2> /dev/null
763        result=$?
764        ;;
765
766        reset)
767        # Turns the screensaver off right now
768        xscreensaver-command -deactivate > /dev/null 2> /dev/null
769        result=$?
770        ;;
771
772        status)
773        result=0
774        if [ -f "$screensaver_file" ] ; then
775            echo "disabled"
776        else
777            echo "enabled"
778        fi
779        ;;
780
781        *)
782        echo "ERROR: Unknown command '$1" >&2
783        return 1
784        ;;
785    esac
786}
787
788xautolock_screensaver()
789{
790    case "$1" in
791        suspend)
792        xset s off && xautolock -disable > /dev/null
793        result=$?
794        ;;
795
796        resume)
797        xset s default && xautolock -enable > /dev/null
798        result=$?
799        ;;
800
801        activate)
802        xautolock -enable
803        result=$?
804        ;;
805
806        lock)
807        xautolock -locknow
808        result=$?
809        ;;
810
811        reset)
812        xautolock -restart
813        result=$?
814        ;;
815
816        status)
817        xautolock -unlocknow >/dev/null
818        result=$?
819        if [ $result -eq 0 ]; then
820            echo "enabled"
821        else
822            echo "disabled"
823        fi
824        ;;
825
826        *)
827        echo "ERROR: Unknown command '$1" >&2
828        return 1
829        ;;
830    esac
831}
832
833[ x"$1" != x"" ] || exit_failure_syntax
834
835action=
836window_id=
837
838case $1 in
839  suspend)
840    action="$1"
841
842    shift
843
844    if [ -z "$1" ] ; then
845        exit_failure_syntax "WindowID argument missing"
846    fi
847
848    window_id="$1"
849    check_window_id
850    ;;
851
852  resume)
853    action="$1"
854
855    shift
856
857    if [ -z "$1" ] ; then
858        exit_failure_syntax "WindowID argument missing"
859    fi
860
861    window_id="$1"
862    check_window_id
863    ;;
864
865  activate)
866    action="$1"
867    ;;
868
869  lock)
870    action="$1"
871    ;;
872
873  reset)
874    action="$1"
875    ;;
876
877  status)
878    action="$1"
879    ;;
880
881  *)
882    exit_failure_syntax "unknown command '$1'"
883    ;;
884esac
885
886detectDE
887# Consider "xscreensaver" a separate DE
888xscreensaver-command -version 2> /dev/null | grep XScreenSaver > /dev/null && DE="xscreensaver"
889# Consider "gnome-screensaver" a separate DE
890dbus-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"
891# Consider "mate-screensaver" a separate DE
892dbus-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"
893# Consider "xautolock" a separate DE
894xautolock -enable > /dev/null 2>&1 && DE="xautolock_screensaver"
895
896if [ "$action" = "resume" ] ; then
897    do_resume
898    exit_success
899fi
900
901perform_action "$action"
902
903if [ "$action" = "suspend" ] ; then
904    # Start tracking $window_id and resume the screensaver once it disappears
905    ( track_window  ) 2> /dev/null > /dev/null &
906fi
907
908if [ $result -eq 0 ]; then
909    exit_success
910else
911    exit_failure_operation_failed
912fi
913