13.2. The Environment

The environment of a process consists of variables, open files, the current working directory, functions, resource limits, signals, and so forth. It defines those features that are inherited from one shell to the next and the configuration for the working environment. The configuration for the user's shell is defined in the shell initialization files.

13.2.1 The Initialization Files

The bash shell has a number of startup files that are sourced. Sourcing a file causes all settings in the file to become part of the current shell; that is, a subshell is not created. (The source command is discussed in "The source or dot Command" on page 773.) The initialization files are sourced depending on the whether the shell is a login shell, an interactive shell (but not the login shell), or a noninteractive shell (a shell script).

When you log on, the .bash_profile in the user's home directory is sourced. It sets the user's aliases and functions and then sets user-specific environment variables and startup scripts.

If the user doesn't have a .bash_profile, but does have a file called .bash_login, that file will be sourced, and if he doesn't have a .bash_login, but does have a .profile, it will be sourced.

The /etc/profile File

The /etc/profile file is a systemwide initialization file set up by the system administrator to perform tasks when the user logs on. It is executed when bash starts up. It is also available to all Bourne and Korn shell users on the system and normally performs such tasks as checking the mail spooler for new mail and displaying the message of the day from the /etc/motd file. (The following examples will make more sense after you have completed this chapter.)

Example 13.4.

(Sample /etc/profile)

# /etc/profile

# Systemwide environment and startup programs

# Functions and aliases go in /etc/bashrc

1   PATH="$PATH:/usr/X11R6/bin"

2   PS1="[\u@\h \W]\\$ "

3   ulimit -c 1000000

4   if [ `id -gn` = `id -un` -a `id -u` -gt 14 ]; then

5       umask 002

    else

        umask 022

    fi

6   USER=`id -un`

7   LOGNAME=$USER

8   MAIL="/var/spool/mail/$USER"

9   HOSTNAME=`/bin/hostname`

10  HISTSIZE=1000

11  HISTFILESIZE=1000

12  export PATH PS1 HOSTNAME HISTSIZE HISTFILESIZE USER LOGNAME MAIL

13  for i in /etc/profile.d/*.sh ; do

14      if [ -x $i ]; then

15           . $i

        fi

16  done

17  unset i #

EXPLANATION

The ~/.bash_profile File

If the ~/.bash_profile is found in the user's home directory, it is sourced after the /etc/profile. If ~/.bash_profile doesn't exist, bash will look for another user-defined file, ~./bash_login, and source it, and if ~./bash_login doesn't exist, it will source the ~/.profile, if it exists. Only one of the three files (~/.bash_profile, ~/.bash_login, or ~/.profile) will be sourced. Bash will also check to see if the user has a .bashrc file and then source it.

Example 13.5.

(Sample .bash_profile)

    # .bash_profile

    # The file is sourced by bash only when the user logs on.



    # Get the aliases and functions

1   if [ -f ~/.bashrc ]; then

2       . ~/.bashrc

    fi



    # User-specific environment and startup programs

3   PATH=$PATH:$HOME/bin

4   ENV=$HOME/.bashrc     # or BASH_ENV=$HOME/.bashrc

5   USERNAME="root"

6   export USERNAME ENV PATH

7   mesg n

8   if [ $TERM = linux ]

    then

        startx    # Start the X Window system

    fi

EXPLANATION

The BASH_ENV (ENV) Variable

Before bash version 2.0, the BASH_ENV file was simply called the ENV file (same as in Korn shell). The BASH_ENV (ENV) variable is set in the ~/.bash_profile. It is assigned the name of a file that will be executed every time an interactive bash shell or bash script is started. The BASH_ENV (ENV) file will contain special bash variables and aliases. The name is conventionally .bashrc, but you can call it anything you want. The BASH_ENV (ENV) file is not processed when the privileged option is on (bash –p or set –o privileged) or the ––norc command-line option is used (bash –norc or bash ––norc if using bash 2.x+).

The .bashrc File

The BASH_ENV (ENV) variable is assigned (by convention) the name .bashrc. This file is automatically sourced every time a new or interactive bash shell or bash script starts. It contains settings that pertain only to the bash shell.

Example 13.6.

(Sample .bashrc)

# If the .bashrc file exists, it is in the user's home directory.

# It contains aliases (nicknames for commands) and user-defined functions.



# .bashrc

# User-specific aliases and functions



1   set -o vi

2   set -o noclobber

3   set -o ignoreeof

4   alias rm='rm -i'

    alias cp='cp -i'

    alias mv='mv -i'

5   stty erase ^h

    # Source global definitions

6   if [ -f /etc/bashrc ]; then

        . /etc/bashrc

    fi

7   case "$-" in

8       *i*) echo This is an interactive bash shell

            ;;

9       *)   echo This shell is noninteractive

             ;;

    esac

10  history_control=ignoredups

11  function cd { builtin cd $1; echo $PWD; }

EXPLANATION

The /etc/bashrc File

Systemwide functions and aliases can be set in the /etc/bashrc file. The primary prompt is often set here.

Example 13.7.

(Sample /etc/bashrc)



    # Systemwide functions and aliases

    # Environment stuff goes in /etc/profile



    # For some unknown reason bash refuses to inherit

    # PS1 in some circumstances that I can't figure out.

    # Putting PS1 here ensures that it gets loaded every time.



1   PS1="[\u@\h \W]\\$ "

2   alias which="type -path"

EXPLANATION

The ~/.profile File

The .profile file is a user-defined initialization file. It is found in the user's home directory, and sourced once at login if running sh (Bourne shell). Because this file is used by the Bourne shell, it should not contain any bash-specific settings. If running bash, .profile will be run if bash cannot find any other of the initialization files listed previously. It allows a user to customize and modify his or her shell environment. Environment and terminal settings are normally put here, and if a window application or database application is to be initiated, it is started here.

Example 13.8.

(Sample .profile)

# A login initialization file sourced when running as sh or the #.bash_profile or

# .bash_login are not found.



1   TERM=xterm

2   HOSTNAME=`uname -n`

3   EDITOR=/bin/vi

4   PATH=/bin:/usr/ucb:/usr/bin:/usr/local:/etc:/bin:/usr/bin:.

5   PS1="$HOSTNAME $ > "

6   export TERM HOSTNAME EDITOR PATH PS1

7   stty erase ^h

8   go () { cd $1; PS1=`pwd`; PS1=`basename $PS1`; }

9   trap '$HOME/.logout' EXIT

10  clear

EXPLANATION

The ~/.bash–logout File

When the user logs out (exits the login shell), if a file called ~/.bash_logout exists, it is sourced. This file normally contains commands to clean up temporary files, truncate the history file, record the time of logout, and perform other housekeeping tasks.

Options to Prevent Startup Files from Being Executed

If bash is invoked with the ––noprofile option (for example, bash ––noprofile), then the /etc/profile, ~/.bash_profile, ~/.bash_login, or ~/.profile startup files will not be sourced.

If invoked with the –p option (e.g., bash –p), bash will not read the user's ~/.profile file.

If bash is invoked as sh (Bourne shell), it tries to mimic the behavior of the Bourne shell as closely as possible. For a login shell, it attempts to source only /etc/profile and ~/.profile, in that order. The –noprofile option may still be used to disable this behavior. If the shell is invoked as sh, it does not attempt to source any other startup files.

The .inputrc File

Another default initalization file, .inputrc, is also read when bash starts up. This file, if it exists in the user's home directory, contains variables to customize keystroke behavior and settings that bind strings, macros, and control functions to keys. The names for the key bindings and what they do are found in the Readline library, a library that is used by applications that manipulate text. The bindings are used particularly by the built-in emacs and vi editors when performing command-line editing. (See "Command-Line Editing" on page 793 for more on readline.)

13.2.2 Setting bash Options with the Built-In set and shopt Commands

The set –o Options

The set command can take options when the –o switch is used. Options allow you to customize the shell environment. They are either on or off, and are normally set in the BASH_ENV (ENV) file. Many of the options for the set command are set with an abbreviated form. For example, set –o noclobber can also be written, set –C. (See Table 13.1.)

FORMAT

set -o option  # Turns on the option.

set +o option  # Turns off the option.

set -[a-z]  # Abbreviation for an option; the minus turns it on.

set +[a-z]  # Abbreviation for an option; the plus turns it off.

Example 13.9.

1   set -o allexport

2   set +o allexport

3   set -a

4   set +a

EXPLANATION

Example 13.10.

1 $ set -o

  braceexpand            on

  errexit                off

  hashall                on

  histexpand             on

  keyword                off

  monitor                on

  noclobber              off

  noexec                 off

  noglob                 off

  notify                 off





  nounset                off

  onecmd                 off

  physical               off

  privileged             off

  verbose                off

  xtrace                 off

  history                on

  ignoreeof              off

  interactive-comments   on

  posix                  off

  emacs                  off

  vi                     on



2   $ set -o noclobber

3   $ date > outfile

4   $ ls > outfile

    bash: outfile: Cannot clobber existing file.

5   $ set +o noclobber

6   $ ls > outfile

7   $ set -C

EXPLANATION

The shopt Built-In (Version 2.x+)

The shopt (shell options) built-in command is used in newer versions of bash as an alternative to the set command. In many ways shopt duplicates the set built-in command, but it adds more options for configuring the shell. See Table 13.27 on page 855 for a list of all the shopt options. In the following example, shopt with the –p option prints all the available options settings. The –u switch indicates an unset option and –s indicates one that is currently set.

Example 13.11.

1   $ shopt -p

    shopt -u cdable_vars

    shopt -u cdspell

    shopt -u checkhash

    shopt -u checkwinsize

    shopt -s cmdhist

    shopt -u dotglob

    shopt -u execfail

    shopt -s expand_aliases

    shopt -u extglob

    shopt -u histreedit

    shopt -u histappend

    shopt -u histverify

    shopt -s hostcomplete

    shopt -u huponexit

    shopt -s interactive_comments

    shopt -u lithist

    shopt -u mailwarn

    shopt -u nocaseglob

    shopt -u nullglob

    shopt -s promptvars

    shopt -u restricted_shell

    shopt -u shift_verbose

    shopt -s sourcepath

2   $ shopt -s cdspell

3   $ shopt -p cdspell

    shopt -s cdspell

4   $ cd /hame

    /home

5   $ pwd

    /home

6   $ cd /ur/lcal/ban

    /usr/local/man

7   $ shopt -u cdspell

8   $ shopt -p cdspell

    shopt -u cdspell

Table 13.27. The shopt Command Options

Option	Meaning
cdable_vars	If an argument to the cd built-in command is not a directory, it is assumed to be the name of a variable whose value is the directory to change to.
cdspell	Corrects minor errors in the spelling of a directory name in a cd command. The errors checked for are transposed characters, a missing character, and a character too many. If a correction is found, the corrected path is printed, and the command proceeds. Only used by interactive shells.
checkhash	Bash checks that a command found in the hash table exists before trying to execute it. If a hashed command no longer exists, a normal path search is performed.
checkwinsize	Bash checks the window size after each command and, if necessary, updates the values of LINES and COLUMNS.
cmdhist	Bash attempts to save all lines of a multiple-line command in the same history entry. This allows easy re-editing of multiline commands.
dotglob	Bash includes filenames beginning with a dot (.) in the results of filename expansion.
execfail	A noninteractive shell will not exit if it cannot execute the file specified as an argument to the exec built-in command. An interactive shell does not exit if exec fails.
expand_aliases	Aliases are expanded. Enabled by default.
extglob	The extended pattern-matching features (regular expression metacharacters derived from Korn shell for filename expansion) are enabled.
histappend	The history list is appended to the file named by the value of the HISTFILE variable when the shell exits, rather than overwriting the file.
histreedit	If readline is being used, a user is given the opportunity to re-edit a failed history substitution.
histverify	If set, and readline is being used, the results of history substitution are not immediately passed to the shell parser. Instead, the resulting line is loaded into the readline editing buffer, allowing further modification.
hostcomplete	If set, and readline is being used, bash will attempt to perform hostname completion when a word containing @ is being completed. Enabled by default.
huponexit	If set, bash will send SIGHUP (hangup signal) to all jobs when an interactive login shell exits.
interactive_comments	Allows a word beginning with # to cause that word and all remaining characters on that line to be ignored in an interactive shell. Enabled by default.
lithist	If enabled, and the cmdhist option is enabled, multiline commands are saved to the history with embedded newlines rather than using semicolon separators where possible.
mailwarn	If set, and a file that bash is checking for mail has been accessed since the last time it was checked, the message The mail in mailfile has been read is displayed.
nocaseglob	If set, bash matches filenames in a case-insensitive fashion when performing filename expansion.
nullglob	If set, bash allows filename patterns that match no files to expand to a null string, rather than themselves.
promptvars	If set, prompt strings undergo variable and parameter expansion after being expanded. Enabled by default.
restricted_shell	The shell sets this option if it is started in restricted mode. The value may not be changed. This is not reset when the startup files are executed, allowing the startup files to discover whether or not a shell is restricted.
shift_verbose	If this is set, the shift built-in prints an error message when the shift count exceeds the number of positional parameters.
sourcepath	If set, the source built-in uses the value of PATH to find the directory containing the file supplied as an argument. Enabled by default.
source	A synonym for dot (.).

EXPLANATION

13.2.3 The Prompts

When used interactively, the shell prompts you for input. When you see the prompt, you know that you can start typing commands. The bash shell provides four prompts: the primary prompt is a dollar sign ($); the secondary prompt is a right angle bracket symbol (>); the third and fourth prompts, PS3 and PS4, respectively, will be discussed later. The prompts are displayed when the shell is running interactively. You can change these prompts.

The variable PS1 is set to a string containing the primary prompt. Its value, the dollar sign, appears when you log on and waits for user input, normally a UNIX/Linux command. The variable PS2 is the secondary prompt, initially set to the right angle bracket character (>). It appears if you have partially typed a command and then pressed Enter. You can change the primary and secondary prompts.

The Primary Prompt

The dollar sign (or bash $) is the default primary prompt. You can change your prompt. Normally, prompts are defined in /etc/bashrc or the user initialization file, .bash_profile, or .profile (Bourne shell).

Example 13.12.

1   $ PS1="$(uname -n) > "

2   chargers >

EXPLANATION

Setting the Prompt with Special Escape Sequences

By inserting special backslash/escape sequences into the prompt string, you can customize the prompts. Table 13.2 lists the special sequences.

Example 13.13.

1   $  PS1="[\u@\h \W]\\$ "

    [ellie@homebound ellie]$

2   $  PS1="\W:\d> "

    ellie:Tue May 18>

EXPLANATION

The Secondary Prompt

The PS2 variable is assigned a string called the secondary prompt. Its value is displayed to standard error, which is the screen by default. This prompt appears when you have not completed a command or more input is expected. The default secondary prompt is >.

Example 13.14.

1   $ echo "Hello

2   > there"

3   Hello

    there

4   $



5   $ PS2="––––> "

6   $ echo 'Hi

7   ––––––>

    ––––––>

    ––––––> there'

     Hi





    there

    $





8   $ PS2="\s:PS2 > "

    $ echo 'Hello

    bash:PS2 > what are

    bash:PS2 > you

    bash:PS2 > trying to do?

    bash:PS2 > '

    Hello

    what are

    you

    trying to do?

    $

EXPLANATION

13.2.4 The Search Path

Bash uses the PATH variable to locate commands typed at the command line. The path is a colon-separated list of directories used by the shell when searching for commands. The default path is system-dependent, and is set by the administrator who installs bash. The path is searched from left to right. The dot at the end of the path represents the current working directory. If the command is not found in any of the directories listed in the path, the shell sends to standard error the message filename: not found. The path is normally set in the .bash_profile if running the bash shell or .profile file if using sh, the Bourne shell.

If the dot is not included in the path and you are executing a command or script from the current working directory, the name of the script must be preceded with a ./, such as ./program_name, so that shell can find the program.

Example 13.15.

(Printing the PATH)

1   $ echo $PATH

    /usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin:.



(Setting the PATH)

2   $ PATH=$HOME:/usr/ucb:/usr:/usr/bin:/usr/local/bin:

3   $ export PATH

4   $ runit

    bash: runit: command not found

5   $ ./runit

    < program starts running here >

EXPLANATION

13.2.5 The hash Command

The hash command controls the internal hash table used by the shell to improve efficiency in searching for commands. Instead of searching the path each time a command is entered, the first time you type a command, the shell uses the search path to find the command, and then stores it in a table in the shell's memory. The next time you use the same command, the shell uses the hash table to find it. This makes it much faster to access a command than having to search the complete path. If you know that you will be using a command often, you can add the command to the hash table. You can also remove commands from the table. The output of the hash command displays the number of times the shell has used the table to find a command (hits) and the full pathname of the command. The hash command with the –r option clears the hash table. An argument of –– disables option checking for the rest of the arguments. Hashing is automatically implemented by bash. Although you can turn it off, if there isn't any compelling reason to do so, don't.

Example 13.16.

(Printing the PATH)



(Command line)

1   hash

    hits    command

    1       /usr/bin/mesg

    4       /usr/bin/man

    2       /bin/ls

2   hash -r

3   hash

    No commands in hash table

4   hash find

    hits    command

    0       /usr/bin/find

EXPLANATION

13.2.6 The source or dot Command

The source command (from the C shell) is a built-in bash command. The dot command, simply a period (from the Bourne shell), is another name for source. Both commands take a script name as an argument. The script will be executed in the environment of the current shell; that is, a child process will not be started. All variables set in the script will become part of the current shell's environment. Likewise, all variables set in the current shell will become part of the script's environment. The source (or dot) command is normally used to re-execute any of the initialization files, such as .bash_profile, .profile, and so on, if they have been modified. For example, if one of the settings, such as the EDITOR or TERM variable, has been changed in the .bash_profile since you logged on, you can use the source command to re-execute commands in the .bash_profile without logging out and then logging back on. A file, such as .bash_profile, or for that matter any shell script, does not need execute permissions to be sourced with either the dot or the source commands.

Example 13.17.

$ source .bash_profile

$ . .bash_profile

EXPLANATION

The source or dot command executes the initialization file, .bash_profile, within the context of the current shell. Local and global variables are redefined within this shell. The dot command makes it unnecessary to log out and then log back in again after the file has been modified.^[a]

^[a] If the .bash_profile were executed directly as a script, a child shell would be started. Then the variables would be set in the child shell, and when the child shell exited, the parent shell would not have any of the settings available to it.