#!/bin/sh
# Release version: 1.15/Oct 20/2010
# /usr/bin/s2 -- offers some flexibility when locking/suspending your desktop.
# Does not use any LRMI or PCI-register weirdness. This script is intended
# for machines with non-crappy BIOSes and working ACPI implementations.

# Copyright (C) <2009,2010> <Sasha Alexandr> <crawlingwithsnakes at hush dot com>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.

# Testing done on: Slackware 11.0 - kernel 2.6.30
# Testing done on: Slack64-current  kernel=2.6.30.5
# Testing done on: Slack64-13.0     kernel=2.6.32.2
# Testing done on: Slack64-13.1+ (-current) kernel=2.6.35
# Testing hardware: MSI P6N-SLI-FI (MS-7350)
# Intel E2160 Core2 CPU
# nVidia chipset MCP51/430i BIOS 2.7
# Ethernet: Realtek 8211BL using forcedeth driver.
# Video: 2x eVGA eGeForce 7300/7200 PCI-E cards.
# Video: nVidia binary versions 185.18.31 through 256.35 (x86_64)
# DE: KDE 3.5.4 & xscreensaver for locking session.
# DE: XFCE in Slack64-current & xscreensaver for locking session
# DE: 2010: No more KDE - using small window manager now.
#--proposed changes (to do):---------------------------------
#--test 'suspend to disk' support (I don't use it yet)
#------------------------------------------------------------
#--<changelog:>     -----------------------------------------
# v1.01  - adjust 'Usage:' text; tidy some code.
#        - support _list_ of NICs; add logging yes/no option.
#        - divert net-restart output to $console.
# v1.02  - clean up some junk that was outputting to console.
#        - clarify comments & Usage:
#        - adjustable args for net & session-lock.
#        - add a bit more sanity checking.
# v1.03  - fix more ugly junk coming on screen after wake-up.
# v1.04  - kill undead forked process when cancel suspend.
#        - remove one function; put that code elsewhere.
# v1.05  - shorten help-page console output linewrap.
#        - clean code a bit.
# v1.10  - adjust/test for Slack64-current.
#        - clean code more.
#        - rename to /usr/bin/s2
# v1.11  - fixed POSIX compliance for shells other than Bash.
#        - fix console output so it doesn't scroll a mile down screen.
# v1.12  - check if user is root as required; or quit.
# v1.13  - fix 'help is displayed twice' when no args given.
# v1.14  - added code to detect which tty the script is called from
#          and return there upon resume. Thanks GazL & tredegar.
#        - tiny code adjustments.
# v1.15  - Fixed some logic errors for the "in????=??" delay settings areas
#        - which had escaped me previously.
#        - now disowning forked s2's so no crap on console upon resume.
#        - Observation: the code is getting convoluted. Needs a rework.
#--</changelog>
#-------------------------------------------------------------
#--<known bugs:>
# IF X is not running, using this script from a VT may result in no video
# after resuming. The machine is NOT hung - X can still be started normally
# (blindly) but the VT's seem to remain unusable. I may need to add some
# vbetool functionality to turn the video back on - or 'they' can fix that.
#--
# Upon resume, shell prompt is not quite returned to user. You gotta
# hit enter or whatever. Not sure why this is. If you fix it, let me know :-)
#--</known bugs>
#------------------------------------------------------------

setup () {
#-------------------------------adjustable stuff-------------
# unplug/reinsert any kernel modules you've determined
# cause problems suspending/resuming on your machine.
# If you use the hangcheck-timer, it MUST be a module and
# it MUST be removed before suspend, reinserted after resume.
# If hangcheck-timer is built static into the kernel, suspend
# will only work once; subsequent suspends will resume
# immediately all by themselves.
unplug_list="ohci_hcd forcedeth hangcheck-timer"
insert_list="ohci_hcd forcedeth" # if empty, unplug list is used
want_to_log_the_process='y' # change to y to log the suspend
# separate multiple NICs below with spaces like 'eth0 eth1'
# NICs using DHCP:
NIC='eth0' # stop this/these before suspending to ram/disk
#------------------------------non-adjustable stuff-----------
suspend2_log=/var/log/suspend2.log
log_pidfile=/var/run/suspend2_logpid
fork_pidfile=/var/run/suspend2_forkpid
pm_debug_exist=/sys/power/pm_test
version='1.15'
#--------------------------------adjustable stuff-------------
# Common paths to stuff - verify/adjust for your system:
kernel_log=/var/log/kernel
modprobe=/sbin/modprobe
hwclock=/sbin/hwclock
tail=/usr/bin/tail
ifconfig=/sbin/ifconfig
net_init_script=/etc/rc.d/rc.inet1
net_init_script_arg='restart'
session_locker=/usr/X11R6/bin/xscreensaver-command
session_locker_arg='-lock'
console=/dev/tty1
#-----pm debug (adjustable if you want to test stuff)---------
 debug_pm_does_exist () {
  # To test/debug your system's suspend abilities, read the kernel
  # documentation about enabling/using CONFIG_PM_DEBUG
  # note: only one line must be uncommented at any time.
  #
  echo none > /sys/power/pm_test # really suspend (default)
  #echo freezer > /sys/power/pm_test # least invasive test
  #echo devices > /sys/power/pm_test # test device susp/resume
  #echo platform > /sys/power/pm_test # only w/suspend to disk
  #echo processors > /sys/power/pm_test # test CPU susp/resume
  #echo core > /sys/power/pm_test # most invasive test
 }
[ -f $pm_debug_exist ] && debug_pm_does_exist
#---------------------------------------------end pm debug-----

} # end setup

# Do not edit below here unless you know what you're doing.
#--------------------------------------------------------------

usage () {
 unset list
  printf "\n s2: a suspend script by Sasha. Version $version (Orig. Dec 2009)\n"

  [ "$1" = 'error' ] && printf " Error: bad, missing, or extra parameter.\n"
  for i in standby mem disk; do
     [ "$(echo $methods | grep -o $i)" ] && eval $i='1' || unset i
  done;
cat << USAGE
 Usage:

 To suspend immediately, just specify the type of suspend you want, and
 optionally the 'lock' option, which locks your desktop session before
 suspending. If you want the machine to automatically suspend at a later time
 then use the additional options. All options are:

 -x | cancel    to abort any pending suspends.
 -l | lock      locks the desktop session before suspending.
 -m | mem       indicates you want 'suspend to ram'
 -d | disk      indicates you want 'suspend to disk'
 -s | standby   indicates you want 'suspend to standby'
  ? | status    shows any current pending suspend operation.
 inmins=mm      will cause a suspend after mm minutes.
 insecs=ss      causes a suspend after ss seconds.
 inhrs=hh       will suspend after hh hours.
 time=HHMM      allows a HHMM format of time-of-day to suspend at.
                NOTE: due to the nature of the "date" system command
                some adjustment is done depending on the time entered.
                If you get unsatisfactory results with the time=HHMM option
                give me an example and description of what happened and I will
                look into it.

 When a suspend instance has been created, you will see on the screen, an
 informational line, showing the actual command used to perform the operation,
 such as:

 Running s2 process: (18203) /bin/sh /usr/bin/s2 fork mem 7200 unlocked 7

 Above, the (18203) is the process ID of the running instance. The remainder of
 the line can be copied as-is, and used to silently start an s2 instance from
 cron or other means.

 As of this writing (version 1.1x), suspend to disk has not been tested by me
 at all. It should work fine - it's reputed to be less troublesome than suspend
 to ram. Standby and suspend to ram both work on my system.
 If you find a bug, i.e. something really dumb/obvious that I missed, point it
 out and I'll fix it.

 If you're so inclined, you can run this from a crontab or an icon/kicker
 button with a command something like: kdesu /path/to/script <args>

 Below shows what suspend methods are currently available on your machine
 and the rest of the possible arguments that s2 accepts:

USAGE

 printf " Usage: $(basename $0) $( [ "$standby" ] && list="standby";
                                       [ "$mem" ] && list="$list mem";
                                      [ "$disk" ] && list="$list disk";
 echo "$list" | sed 's/^[ ]//;s/ /|/g' ) [lock] [inmins=mm | insecs=ss | inhours=hh | time=HHMM]\n"
 printf " Usage: $(basename $0) [cancel] [status] [help]\n\n"
}

logging () {
[ "$want_to_log_the_process" = 'n' ] && return
case $1 in
  start) $tail -f $kernel_log > $suspend2_log &
	 echo $! > $log_pidfile ;;
  stop) if [ -f $log_pidfile ]; then
	deadlog=$(cat $log_pidfile)
	kill $deadlog > /dev/null 2>&1 &
	wait
	fi
	;;
esac;
}

get_jobs () {
 unset fpid running_jobs
 if [ -f $fork_pidfile ]; then
   fpid=$(cat $fork_pidfile); running_jobs=$(ps -p $fpid -o command= )
 fi;
}

message () {
 [ "$1" = 'S' ] && printf "\n$(date) ($(basename $0): Going into $action-sleep now.)\n" > $console
 [ "$1" = 'R' ] && printf "\n$(date) ($(basename $0): Waking up now.)\n" > $console
}

get_current_vt () {
 # Figure out what v/tty we're on when script is called
 # so we can return there upon resume:
 DISPL="$(who am i | grep -oE ':[0-9]+\.' | tr -d .)"
 curr_tty="$(tty | awk '/tty/{gsub ("[a-z/]","");print}')"
 if [ ! "$curr_tty" ]; then
   curr_tty="$(ps -ef | grep /usr/bin/X | \
                        grep -v 'xinit\|grep' | \
                        grep " $DISPL" | \
                        awk '/tty/{print $6}' | tr -d [a-z])"
 fi
 # if we still haven't got a $curr_tty then (until I get a better idea) set it to tty7
 [ ! "$curr_tty" ] && curr_tty='7'
 original_vt=$curr_tty
 #echo "$original_vt" #DEBUG
 #exit #DEBUG ONLY
}

get_current_vt_better () {
 # Thanks to LQ member 'GazL' for this nice efficient replacement for the
 # above function, which gets the current v/tty to return to upon resume:
read user tty month day time display << EOD
$(LANG=C who -m)
EOD

if [ "$display" = "" ] ; then
   where="$tty"
else
   where="${display%.*}"; where="${where#*:}"
   read X_pid < "/tmp/.X${where}-lock"
   where=$(ps h -p "${X_pid}" -o tty)
fi
[ ! "$where" ] && original_vt='7' || original_vt=${where//[a-z]}
 #echo "$original_vt" #DEBUG
 #exit #DEBUG ONLY
}

do_standby () {
 sleep $seconds; sync; sleep 1
 # 'standby' doesn't need any module-unplugging or NIC shutdown.
 chvt 1; message S
 [ "$lock" = 'lock' ] && $session_locker $session_locker_arg >/dev/null 2>&1
 logging start
 echo standby > /sys/power/state

# resuming now:

 $hwclock --hctosys # adjust OS clock
 message R
 logging stop
 chvt $original_vt
 rm -f $log_pidfile $fork_pidfile
} # end of 'do_standby'


do_suspend () {
 sleep $seconds; sync; sleep 1
 chvt 1; message S; sleep 2 # (legacy?) change to non-X console to prevent corrupt video
 [ "$lock" = 'lock' ] && $session_locker $session_locker_arg >/dev/null 2>&1
 logging start
 # take down NIC(s) (optional - we restart whole network later anyway)
 interface_list="$(echo $interfaces | sed 's/[ ]/\n/g')"
 for NICs in $(printf "$NIC"); do
   $ifconfig $NICs down
 done;
 # unplug modules known to give problems:
 for mod in $unplug_list; do
   [ "$(lsmod | grep $mod)" ] && $modprobe -r $mod 2>/dev/null
 done;
 echo $action > /sys/power/state

 # Resuming now;

 $hwclock --hctosys # adjust OS clock
 message R
 # reinsert removed modules
 [ ! "$insert_list" ] && insert_list="$unplug_list"
 for mod in $insert_list; do
   $modprobe $mod 2>/dev/null
 done;
 sleep 1 # let things settle
 # Kill any running dhcpcd & restart networking as during a cold boot:
 [ "$(ps ax | grep dhcpcd)" ] && killall -q dhcpcd
 $net_init_script $net_init_script_arg > $console
 logging stop
 chvt $original_vt
 rm -f $log_pidfile $fork_pidfile
} # end of 'do_suspend'

# end of function declarations & setup stuff;
# script entry point:

# check UID
[ $(id -u) != 0 ] && echo "s2 error: you must be UID=0 to run $0" && exit 1

# setup our variables and all that stuff:
setup

if [ "$1" = 'fork' ]; then
 # we're the forked, already-configured instance:
 seconds=$3; lock=$4; original_vt=$5
 case $2 in
   standby)
	do_standby >/dev/null 2>&1 & disown
	echo $! > $fork_pidfile
	exit 0
	;;
   *)
	action=$2
	do_suspend >/dev/null 2>&1 & disown
	echo $! > $fork_pidfile
	exit 0
	;;
 esac;

else # We haven't been set up yet, so deal with cmdline args:

 unset action units; seconds=$((0)); lock='unlocked'
 methods=$(cat /sys/power/state)

if [ $# -eq 0 ]; then
   usage error
   exit 1
fi

 for param in $*; do
  case $param in
    lock|-l) lock='lock' ;;
 standby|-s) [ ! "$action" -a "$(echo $methods | grep -o standby)" ] && action='standby' || usage error ;;
     mem|-m) [ ! "$action" -a "$(echo $methods | grep -o mem)" ] && action='mem' || usage error ;;
    disk|-d) [ ! "$action" -a "$(echo $methods | grep -o disk)" ] && action='disk' || usage error ;;
  status|'?') get_jobs
	   printf "\nRunning s2 process: $( [ "$running_jobs" ] && printf "($fpid) $running_jobs" || printf "None." )\n"
	   exit 0 ;;
  cancel|-x)
	logging stop; get_jobs
	if [ "$fpid" ]; then
	   bloody_die=$(ps ax | grep $(pgrep -P $fpid) | gawk '{/^.[:digit:]+[ ]$/;print $1}')
	   kill $fpid 2>/dev/null &
	   wait
           kill $bloody_die 2>/dev/null &
	   wait
           rm -f $fork_pidfile $log_pidfile
	fi;
	printf "\nAny pending s2 has been canceled.\n"
	exit 0
	;;
 inmins=*) if [ ! "$units" ]; then
               units='mins'; seconds=$(($(echo $param | gawk -F= '{/^inmins=[:digit:]+$/;print $2}')*60))
           else
               usage error; exit 1; fi; ;;
 insecs=*) if [ ! "$units" ]; then
               units='secs'; seconds=$(($(echo $param | gawk -F= '{/^insecs=[:digit:]+$/;print $2}')))
           else
               usage error; exit 1; fi; ;;
inhours=*) if [ ! "$units" ]; then
               units='hrs';  seconds=$(($(echo $param | gawk -F= '{/^inhours=[:digit:]+$/;print $2}')*3600))
           else
               usage error; exit 1; fi; ;;
   time=*)
	   if [ ! "$units" ]; then
                units='time'
	        timegiven="$(echo $param | gawk -F= '{/^time=[:digit:][:digit:][:digit:][:digit:]$/;print $2}')"
	        [ ! "$timegiven" ] && usage error && exit 1
	        unixtimethen=$(($(date -d "$timegiven" +%s)))
	        [ $unixtimethen -lt $(($(date +%s))) ] && unixtimethen=$((unixtimethen+86400))
	        seconds=$((unixtimethen-$(date +%s)))
           else
                usage error; exit 1; fi; ;;

  help|-h|-h*|h*) usage; exit 0 ;;
        *) usage error ; exit 1 ;;
  esac;
 done;


 get_jobs

 if [ "$running_jobs" ]; then
   printf "\nThere's already a suspend2 instance running. Cancel that one first.\n" && exit 1
 fi;

 if [ "$action" -a "$seconds" ]; then

   # If you have trouble with this function 'get_current_vt_better', please let me know,
   # and meanwhile, try the original function 'get_current_vt' instead;
   # Uncomment only one of the 2 lines below:
  # get_current_vt
   get_current_vt_better

   $0 fork $action $seconds $lock $original_vt
   $0 status
   exit 0
 else
   usage error; exit 1
 fi;
fi;

# EOF

alias standby='echo mem > /sys/power/state'