#47 Validating the User Environment

Because people migrate their login, profile, and other shell environment customizations from one system to another, it's not uncommon to have progressive decay in these settings. Eventually, the PATH can include directories that aren't on the system, the PAGER can point to a nonexistent binary, and worse.

A sophisticated solution to this problem is first to check the PATH to ensure that it includes only valid directories on the system, and then to check each of the key helper application settings to ensure that they're either indicating a fully qualified file that exists or that they are specifying a binary that's in the PATH.

The Code

#!/bin/sh
# validator - Checks to ensure that the PATH contains only valid directories,
#   then checks that all environment variables are valid.
#   Looks at SHELL, HOME, PATH, EDITOR, MAIL, and PAGER.

errors=0

in_path()
{
  # Given a command and the PATH, try to find the command. Returns
  # 1 if found, 0 if not.  Note that this temporarily modifies the
  # IFS input field separator but restores it upon completion.
  cmd=$1    path=$2    retval=0

  oldIFS=$IFS; IFS=":"

  for directory in $path
  do
    if [ -x $directory/$cmd ] ; then
      retval=1      # if we're here, we found $cmd in $directory
    fi
  done
  IFS=$oldIFS
  return $retval
}

validate()
{
  varname=$1    varvalue=$2

  if [ ! -z $varvalue ] ; then
    if [ "${varvalue%${varvalue#?}}" = "/" ] ; then
      if [ ! -x $varvalue ] ; then
        echo "** $varname set to $varvalue, but I cannot find executable."
        errors=$(( $errors + 1 ))
      fi
    else
      if in_path $varvalue $PATH ; then
        echo "** $varname set to $varvalue, but I cannot find it in PATH."
        errors=$(( $errors + 1 ))
      fi
    fi
  fi
}

####### Beginning of actual shell script #######

if [ ! -x ${SHELL:?"Cannot proceed without SHELL being defined."} ] ; then
  echo "** SHELL set to $SHELL, but I cannot find that executable."
  errors=$(( $errors + 1 ))
fi

if [ ! -d ${HOME:?"You need to have your HOME set to your home directory"} ]
then
  echo "** HOME set to $HOME, but it's not a directory."
  errors=$(( $errors + 1 ))
fi

# Our first interesting test: are all the paths in PATH valid?

oldIFS=$IFS; IFS=":"     # IFS is the field separator. We'll change to ':'

for directory in $PATH
do
  if [ ! -d $directory ] ; then
      echo "** PATH contains invalid directory $directory"
      errors=$(( $errors + 1 ))
  fi
done

IFS=$oldIFS             # restore value for rest of script

# The following variables should each be a fully qualified path,
# but they may be either undefined or a progname.
#   Add additional variables as necessary for
# your site and user community.

validate "EDITOR" $EDITOR
validate "MAILER" $MAILER
validate "PAGER"  $PAGER

# And, finally, a different ending depending on whether errors > 0

if [ $errors -gt 0 ] ; then
  echo "Errors encountered. Please notify sysadmin for help."
else
  echo "Your environment checks out fine."
fi

exit 0

How It Works

The tests performed by this script aren't overly complex. To check that all the directories in PATH are valid, the code steps through each directory to ensure that it exists. Notice that the internal field separator (IFS) had to be changed to a colon so that the script would properly step through all of the PATH directories. By convention, the PATH variable uses a colon to separate each of its directories, as shown here:

$ echo $PATH
/bin/:/sbin:/usr/bin:/sw/bin:/usr/X11R6/bin:/usr/local/mybin

To validate that the environment variable values are valid, the validate() function first checks to see if each value begins with a /. If it does, the function checks to see if the variable is an executable. If it doesn't begin with a /, the script calls the in_path() function to see if the program is found in one of the directories in the current PATH.

The most unusual aspects of this script are its use of default values within some of the conditionals and its use of variable slicing. Its use of default values in the conditionals is exemplified by the following:

if [ ! -x ${SHELL:?"Cannot proceed without SHELL being defined."} ] ; then

The notation ${varname:?"errorMessage"} can be read as if varname exists, substitute its value; otherwise, fail with the error errorMessage.

The variable slicing notation, ${varvalue%${varvalue#?}}, is the POSIX sub-string function, producing only the first character of the variable varvalue. In this script, it's used to ascertain whether an environment variable has a fully qualified filename (one starting with / and specifying the path to the binary).

If your version of Unix/Linux doesn't support either of these notations, they can be replaced in a straightforward fashion. For example, instead of ${SHELL:?No Shell} you could substitute

if [ -z $SHELL ] ; then
  echo "No Shell" >&2; exit 1
fi

And instead of {varvalue%${varvalue#?}}, you could use the following code to accomplish the same result:

$(echo $varvalue | cut -c1)

Running the Code

This is code that users can run to check their own environment. There are no starting arguments.

The Results

$ validator
** PATH contains invalid directory /usr/local/mybin
** MAILER set to /usr/local/bin/elm, but I cannot find executable.
Errors encountered. Please notify sysadmin for help.