Server Fault is a question and answer site for system and network administrators. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

I'm trying to write a script, that will install a bunch of software, I'd like to not have to run everything as root, so I'd like to be able to prompt for a password and then go about the install, using sudo or su to get privileges when I need them.

I was doing a sudo -v to prompt for a password at the beginning of the script, and then just using sudo normally later on. This works great until I get to a single install that takes over the timeout.

I'd rather not have to permanently increase the timeout, is there a way I can increase sudo's timeout for the current session only?

share|improve this question
up vote 7 down vote accepted

You can setup a loop that runs in the background to periodically execute "sudo -v", the trick of course is getting the loop to cleanly terminate when your script terminates. So there has to be some type of communication between the two processes; tmp files are fine for this, and they can easily be cleaned up after the script runs, too. (An install script usually does this, anyway.)

For example (remove the 'echo' statements to use this; these just show it "working"):


echo "========= running script $$ ========"
echo $$ >> $sudo_stat
trap 'rm -f $sudo_stat >/dev/null 2>&1' 0
trap "exit 2" 1 2 3 15

sudo_me() {
 while [ -f $sudo_stat ]; do
  echo "checking $$ ...$(date)"
  sudo -v
  sleep 5
 done &

echo "=setting up sudo heartbeat="
sudo -v

echo "=running setup=" | tee $log
while [ -f $log ]
 echo "running setup $$ ...$(date) ===" | tee -a $log
 sleep 2

# finish sudo loop
rm $sudo_stat

Then you'll see... (note: the pid is put into the tmp file, just so you can easily kill it. It's not necessary, though):

$ ./
========= running script 6776 ========
=setting up sudo heartbeat=
[sudo] password for user: 
=running setup=
checking 6776 ...Wed May  4 16:31:47 PDT 2011
running setup 6776 ...Wed May  4 16:31:48 PDT 2011 ===
running setup 6776 ...Wed May  4 16:31:50 PDT 2011 ===
running setup 6776 ...Wed May  4 16:31:52 PDT 2011 ===
checking 6776 ...Wed May  4 16:31:53 PDT 2011
running setup 6776 ...Wed May  4 16:31:54 PDT 2011 ===
<ctrl-c>  (cleans up files, then exits)
share|improve this answer

I liked michael_n's answer, but had the most irrational desire not to use a temp file. Maybe this can provide some perspective.

My solution was:

function sudo_ping() {
    if [[ ! -z $SUDO_PID ]]; then
        if [[ $1 -eq stop ]]; then
            echo "Stopping sudo ping in PID = $SUDO_PID"
            kill $SUDO_PID
            echo "Already sudo pinging in PID = $SUDO_PID"

    echo "Starting background sudo ping..."
    sudo -v
    if [[ $? -eq 1 ]]; then
        echo "Oops, wrong password."
    sudo echo "ok"

    while true; do
        echo 'Sudo ping!'
        sudo -v
        sleep 1
    done &
    sudo echo "Sudo pinging in PID = $SUDO_PID"

    # Make sure we don't orphan our pinger
    trap "sudo_ping stop" 0
    trap "exit 2" 1 2 3 15

sleep 5
echo "Goodbye!"

Again, the echo's are extraneous...

$ ./ 
Starting background sudo ping...
Sudo ping!
Sudo pinging in PID = 47531
Sudo ping!
Sudo ping!
Sudo ping!
Sudo ping!
Stopping sudo ping in PID = 47531

Again, ctrl-c works too...

$ ./ 
Starting background sudo ping...
Sudo ping!
Sudo pinging in PID = 47599
Sudo ping!
^CStopping sudo ping in PID = 47599
share|improve this answer
And a more succinct solution: – Gregory Perkins Sep 10 '12 at 18:09
How does this not have 1000+ upvotes??? The succinct version is awesome. (But a better example would help, I think.) – MountainX Jun 26 '13 at 0:52

Based on this gist, I've made a concise and clean version:

# Prevent sudo timeout
sudo -v # ask for sudo password up-front
while true; do
  # Update user's timestamp without running a command
  sudo -nv; sleep 1m
  # Exit when the parent process is not running any more. In fact this loop
  # would be killed anyway after being an orphan(when the parent process
  # exits). But this ensures that and probably exit sooner.
  kill -0 $$ 2>/dev/null || exit
done &
share|improve this answer

According to the sudo man page:

   -v          If given the -v (validate) option, sudo will update the user's time stamp,
               prompting for the user's password if necessary.  This extends the sudo timeout for
               another 15 minutes (or whatever the timeout is set to in sudoers) but does not run
               a command.

So I guess that if you add some sudo -v in more points of your setup script to validate the session (and not only at the beginning) you will get what you want, since each time it will increase the timeout (it only asks the password again if the timeout is reached). The only problem will be if there's a command on your script that takes more time than the timeout (so even if you validate right after it the timeout will expire before it completing for another validation), but this is a very specific case.

What happens is that just using sudo doesn't increase the timeout, and sudo -v doesn't execute a command, so you have to use sudo -v more times to validate the session.

share|improve this answer
Yeah, thanks. The problem is my sudo timeout is closer to 5 minutes, and I have single make install commands that go long past that. – Arelius May 4 '11 at 19:31
Hmm. Well. There's not much to do aside from increasing the timeout then. There's no way to set it temporarily. – coredump May 4 '11 at 23:22

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.