Please contact or Mt Xia for assistance with all your shell programming needs.
sh(1) sh(1)
NAME
sh, Rsh - The Bourne shell, an interactive command interpreter and command
programming language
SYNOPSIS
sh [-ir] [+ | -aefhkntuvx] [file] [argument ...] [-ccommand_string | -s]
Rsh [-ir] [+ | -aefhkntuvx] [file] [argument ...] [-ccommand_string | -s]
The shell carries out commands either interactively from a keyboard or from
a file.
DESCRIPTION
The Bourne shell is a command programming language that executes commands
read from a terminal or a file. Rsh is a restricted version of the stan-
dard command interpreter sh; Rsh is used to set up login names and execu-
tion environments whose capabilities are more controlled than those of the
standard shell. This allows you to create user environments that have a
limited set of privileges and capabilities. (See Restricted Shell for more
information.)
A
script, a shell procedure, or a command file.
A simple command is a sequence of words separated by spaces or tabs. A
word is a sequence of characters that contains no unquoted spaces or tabs.
The first word in the sequence (numbered as 0), usually specifies the name
of a command. Any remaining words, with a few exceptions, are passed to
that command. A space refers to both spaces and tabs.
The value of a simple command is its exit value if it ends normally, or
(octal) 200 added to the signal number if it terminates due to a signal.
For a list of status values, see the signal() system call.
A pipeline is a sequence of one or more commands separated by a | (vertical
bar) or, for historical compatibility, by a ^ (circumflex). In a pipeline,
the standard output of each command becomes the standard input of the next
command. Each command runs as a separate process, and the shell waits for
the last command to end. A filter is a command that reads its standard
input, transforms it in some way, then writes it to its standard output. A
pipeline normally consists of a series of filters. Although the processes
in a pipeline (except the first process) can execute in parallel, they are
synchronized to the extent that each program needs to read the output of
its predecessor.
The exit value of a pipeline is the exit value of the last command.
A list is a sequence of one or more pipelines separated by ; (semicolon), &
(ampersand), && (two ampersands), or || (two vertical bars) and optionally
ended by a ; (semicolon), an & (ampersand), a |& (coprocess), or a newline.
These separators and terminators have the following effects:
; Causes sequential execution of the preceding pipeline; the shell waits
for the pipeline to finish.
& Causes asynchronous execution of the preceding pipeline; the shell does
not wait for the pipeline to finish.
&& Causes the list following it to be executed only if the preceding pipe-
line returns a 0 (zero) exit value.
|| Causes the list following it to be executed only if the preceding pipe-
line returns a nonzero exit value.
The cd command is an exception; if it returns a nonzero exit value, no
subsequent commands in a list are executed, regardless of the separator
characters.
The ; and & separators have equal precedence, as do && and ||. The
single-character separators have lower precedence than the double-character
separators. An unquoted newline character following a pipeline functions
the same as a ; (semicolon).
The shell treats as a comment any word that begins with a # character and
ignores that word and all characters following up to the next newline char-
acter.
Shell Flow Control Statements
Unless otherwise stated, the value returned by a statement is that of the
last simple command executed in the statement.
for identifier [in word ...] do list done
For each word, sets identifier to word and executes the commands in
list. If you omit in word ..., then the for command executes list for
each positional parameter that is set. Execution ends when there are
no more words in the list.
case word in [pattern [ | pattern ] ...) list ;;] ... esac
Executes the commands in the list associated with the first pattern
that matches word. Uses the same character-matching notation in pat-
terns that you use for filename substitution (see Filename Substitu-
tion), except that you do not need to match explicitly a / (slash), a
leading . (dot), or a . (dot) immediately following a / (slash).
if list then list [elif list then list] ... [else list] fi
Executes the list following the if keyword. If it returns a 0 (zero)
exit value, executes the list following the first then. Otherwise,
executes the list following elif (if there is an elif), and if its exit
value is 0 (zero), executes the next then. Failing that, executes the
list following the else. If no else list or then list is executed, the
if command returns a 0 (zero) exit value.
while list do list done
Executes the list following the while. If the exit value of the last
command in the list is 0 (zero), executes the list following do. Con-
tinues looping through the lists until the exit value of the last com-
mand in the while list is nonzero. If no commands in the do list are
executed, the while command returns a 0 (zero) exit value.
until list do list done
Executes the list following the until. If the exit value of the last
command in the list is nonzero, executes the list following do. Con-
tinues looping through the lists until the exit value of the last com-
mand in the until list is 0 (zero). If no commands in the do list are
executed, the until command returns a 0 (zero) exit value.
(list)
Executes the commands in list in a subshell.
{ list; }
Executes the commands in list in the current shell process; does not
spawn a subshell.
name () { list; }
Defines a function that is referenced by name. The body of the func-
tion is the list of commands between the braces.
The following reserved words are recognized only when they appear without
quotes as the first word of a command.
if esac
then case
else for
elif while
fi until
do done
{ }
Command Execution
Each time the shell executes a command, it carries out the substitutions
discussed in the following text. If the command name matches one of the
built-in commands discussed in Built-In Commands, it executes it in the
shell process. If the command name does not match a built-in command but
matches the name of a defined function, it executes the function in the
shell process. The shell sets the positional parameters to the parameters
of the function.
If the command name matches neither a built-in command nor the name of a
defined function and the command names an executable file that is a com-
piled (binary) program, the shell (as parent) spawns a new (child) process
that immediately runs the program. If the file is marked executable but is
not a compiled program, the shell assumes that it is a shell script. In
this case, the shell spawns another instance of itself (a subshell), to
read the file and execute the commands included in it (note how this
differs from the execution of functions). The shell also executes a com-
mand enclosed in parentheses in a subshell. From the perspective of an end
user, a compiled program is run in exactly the same way as a shell script.
The shell normally searches for commands in two places in the file system.
The shell first looks for the command in the current directory; if it does
not find the command there, it looks in the /usr/bin directory. This
search order is in effect if the PATH environment variable is not set (or
is set to :/usr/bin, as is the case by default on many systems).
You can also give a specific pathname when you invoke a command, for exam-
ple /usr/bin/sort, in which case the shell does not search any directories
other than the one you specify in the pathname. If the command name con-
tains a / (slash), the shell does not use the search path (note that the
restricted shell will not execute such commands). You can give a full
pathname that begins with the root directory (as in /usr/bin/sort), or a
pathname relative to the current directory, for example bin/myfile. In
this last case, the shell looks in the current directory for a directory
named bin and in that directory for myfile.
You can change the particular sequence of directories searched by resetting
the PATH variable (see Variables Used by the Shell).
The shell remembers the location in the search path of each executed com-
mand (to avoid unnecessary exec commands later). If the command was found
in a relative directory (one whose name does not begin with /), the shell
must redetermine its location whenever the current directory changes. The
shell forgets all remembered locations whenever you change the PATH vari-
able or execute the hash -r command (see Built-In Commands).
Signals
The shell ignores SIGINT and SIGQUIT signals for an invoked command if the
command is terminated with a & (that is, if it is running in the back-
ground). Otherwise, signals have the values inherited by the shell from
its parent, with the exception of signal 11 (see also the built-in trap
command in Built-In Commands).
Initialization Files
When you log in, the shell is called to read your commands. Before it does
that, however, it checks to see if a file named /etc/profile exists on the
system, and if it does, it reads commands from it (this file sets variables
needed by all users). After this, the shell looks for a file named .pro-
file in your login directory. If it finds one, it executes commands from
it. Finally, the shell is ready to read commands from your standard input.
Filename Substitution
Command arguments are very often filenames. You can automatically produce
a list of filenames as arguments on a command line by specifying a pattern
that the shell matches against the filenames in a directory.
Most characters in such a pattern match themselves, but you can also use
some special pattern-matching characters in your pattern. These special
characters are as follows:
. Matches any single character, except a newline character.
* Matches any string, including the null string.
? Matches any one character.
[ ...]
Matches any one of the characters enclosed in brackets.
[! ...]
Matches any character other than those that follow the exclamation
point within brackets.
Inside brackets, a pair of characters separated by a - (dash) specifies a
set of all characters lexically within the inclusive range of that pair
according to the current collating sequence. The LANG and LC_COLLATE
environment variables control the collating sequence.
The current collating sequence groups characters into equivalence classes
for the purpose of defining the endpoints of a range of characters. For
example, if the collating sequence defines the lexical order to be AaBbCc
... and groups uppercase and lowercase characters into equivalence classes,
then all the following have the same effect: [a-c], [A-C], [a-C], and
[A-c].
Pattern matching has some restrictions. If the first character of a
filename is a . (dot), it can be matched only by a pattern that begins with
a dot. For example, * (asterisk) matches the filenames myfile and your-
file, but not the filenames .myfile and .yourfile. To match these files,
use a pattern such as the following:
.*file
If a pattern does not match any filenames, then the pattern itself is
returned as the result of the attempted match.
File and directory names should not contain the characters *, ?, [, or ],
because this requires quoting those names in order to refer to the files
and directories.
Shell Variables and Command-Line Substitutions
The shell has several mechanisms for creating variables (assigning a string
value to a name). Certain variables, positional parameters and keyword
parameters, are normally set only on a command line. Other variables are
simply names to which you or the shell can assign string values.
Positional Parameters
When you run a shell script, the shell implicitly creates positional param-
eters that reference each word on the command line by its position on the
command line. The word in position 0 (the procedure name), is called $0,
the next word (the first parameter) is called $1, and so on up to $9. To
refer to command-line parameters numbered higher than 9, use the built-in
shift command (see Built-In Commands).
You can also assign values to these positional parameters explicitly by
using the built-in set command (see Built-In Commands).
When an argument for a position is not specified, its positional parameter
is set to null.
Positional parameters are global and can be passed to nested shell scripts.
User-Defined Variables
The shell also recognizes alphanumeric variables to which string values can
be assigned. You assign a string value to a name, as follows:
name=string
A name is a sequence of letters, digits, and underscores that begins with
an underscore or a letter. To use the value that you have assigned to a
variable, add a $ (dollar sign) to the beginning of its name. Thus, $name
yields the value string. Note that no spaces surround the = (equal sign)
in an assignment statement. (Positional parameters cannot appear in an
assignment statement; they can only be set as described earlier.) You can
put more than one assignment on a command line, but remember: the shell
performs the assignments from right to left.
If you surround string with quotes, either " " (double) or ' ' (single),
the shell does not treat spaces, tabs, semicolons, and newline characters
within it as word delimiters but embeds them literally in the string.
If you surround string with double quotes, the shell still recognizes vari-
able names in the string and performs variable substitution; that is, it
replaces references to positional parameters and other variable names that
are prefaced by $ with their corresponding values, if any. The shell also
performs command substitution (see Command Substitution) within strings
that are surrounded by double quotes.
If you surround string with single quotes, the shell does no variable or
command substitution within the string. The following sequence illustrates
this difference:
You enter:
stars=*****
asterisks1="Add $stars"
asterisks2='Add $stars'
echo $asterisks1
The system displays:
Add *****
You enter:
echo $asterisks2
The system displays:
Add $stars
The shell does not reinterpret spaces in assignments after variable substi-
tution (see Interpretation of Spaces). Thus, the following assignments
result in $first and $second having the same value:
first='a string with embedded spaces'
second=$first
When you reference a variable, you can enclose the variable name (or the
digit designating a positional parameter) in { } (braces) to delimit the
variable name from any following string. In particular, if the character
immediately following the name is a letter, digit, or underscore and the
variable is not a positional parameter, then the braces are required:
You enter:
a='This is a'
echo "${a}n example"
The system displays:
This is an example
You enter:
echo "$a test"
The system displays:
This is a test
See Conditional Substitution for a different use of braces in variable sub-
stitutions.
A Command's Environment
All the variables (with their associated values) that are known to a com-
mand at the beginning of its execution constitute its environment. This
environment includes variables that a command inherits from its parent pro-
cess and variables specified as keyword parameters on the command line that
calls the command.
The shell passes to its child processes the variables that were named as
arguments to the built-in export command. The export command places the
named variables in the environments of both the shell and all its future
child processes.
Keyword parameters are variable-value pairs that appear in the form of
assignments, normally before the procedure name on a command line (but see
also the -k flag, discussed under the set command in Built-In Commands).
Such variables are placed in the environment of the procedure being called.
For example, given the following simple procedure that echoes the values of
two variables (saved in a command file named key_command):
# cat key_command
echo $a $b
#
the following command lines produce the output shown:
You enter:
a=key1 b=key2 key_command
The system displays:
key1 key2
You enter:
The system displays:
tom john
A procedure's keyword parameters are not included in the parameter count
stored in $#.
A procedure can access the values of any variables in its environment; how-
ever, if it changes any of these values, these changes are not reflected in
the shell environment. They are local to the procedure in question. To
place these changes in the environment that the procedure passes to its
child processes, you must export these values within that procedure.
To obtain a list of variables that were made exportable from the current
shell, enter:
export
(You will also get a list of variables that were made read only.) To get a
list of name-value pairs in the current environment, enter:
env
Conditional Substitution
Normally, the shell replaces $variable with the string value assigned to
variable, if there is one. However, there is a special notation that
allows conditional substitution, depending on whether the variable is set
and is not null. By definition, a variable is set if it was assigned a
value. The value of a variable can be the null string, which you can
assign to a variable in any one of the following ways:
A=
bcd=""
Efg=''
set '' ""
The first three of these examples assign the null string to each of the
corresponding variable names. The last example sets the first and second
positional parameters to the null string and unsets all other positional
parameters.
The following is a list of the available expressions you can use to perform
conditional substitution:
${ variable-string }
If the variable is set, substitute the value of variable in place of
this expression. Otherwise, replace this expression with the value of
string.
${ variable:-string }
If the variable is set and is not null, substitute the value of vari-
able in place of this expression. Otherwise, replace this expression
with the value of string.
${ variable=string }
If the variable is set, substitute the value of variable in place of
this expression. Otherwise, set variable to string and then substitute
the value of the variable in place of this expression. You cannot
assign values to positional parameters in this fashion.
${ variable:=string }
If the variable is set and is not null, substitute the value of vari-
able in place of this expression. Otherwise, set variable to string
and then substitute the value of the variable in place of this expres-
sion. You cannot assign values to positional parameters in this
fashion.
${ variable?string }
If the variable is set, substitute the value of variable in place of
this expression. Otherwise, display a message of the form:
variable: string
and exit from the current shell, unless the shell is the login shell.
If you do not specify string, the shell displays the following message:
variable: parameter null or not set
${ variable:?string }
in place of this expression. Otherwise, display a message of the form:
variable: string
and exit from the current shell, unless the shell is the login shell.
If you do not specify string, the shell displays the following message:
variable: parameter null or not set
${ variable+string }
If the variable is set, substitute the value of string in place of this
expression. Otherwise, substitute the null string.
${ variable:+string }
If the variable is set and not null, substitute the value of string in
place of this expression. Otherwise, substitute the null string.
In conditional substitution, the shell does not evaluate string until it
uses it as a substituted string, so that, in the following example, the
shell executes the pwd command only if d is not set or is null:
echo ${ d:-`pwd` }
Variables Used by the Shell
The shell uses the following variables. The shell sets some of them, and
you can set or reset all of them.
CDPATH
The search path for the cd (change directory) command.
HOME
The name of your login directory, the directory that becomes the
current directory upon completion of a login. The login program ini-
tializes this variable. The cd command uses the value of $HOME as its
default value. If you use this variable in your shell scripts rather
than using the full pathname, your procedures run even if your login
directory is changed or if another user runs them.
LANG
Specifies the locale of your system, which is comprised of three parts:
language, territory, and codeset. The default locale is the C locale,
which specifies the value English for language, U.S. for territory, and
ASCII for codeset. The locale specified for the LANG variable controls
the language applied to messages. Unless set explicitly, the
LC_COLLATE, LC_CTYPE, LC_MESSAGES, LC_MONETARY, LC_NUMERIC, and LC_TIME
variables also derive their settings from the locale set for LANG.
LC_COLLATE
Specifies the collating sequence to use when sorting names and when
character ranges occur in patterns. The default value is the collating
sequence for American English. If absent, the collating sequence may
be taken from the LANG variable. If both LC_COLLATE and LANG are
absent, the ANSI C collating sequence is used.
LC_CTYPE
Specifies the character classification information to use on your sys-
tem. The default value is American English.
LC_MESSAGES
Specifies the language that the system expects for user input of yes
and no strings. The default value is American English.
LC_MONETARY
Specifies the monetary format for your system. The default value is
the monetary format for American English.
LC_NUMERIC
Specifies the numeric format for your system. The default value is the
numeric format for American English.
LC_TIME
Specifies the date and time format for your system. The default value
is the date and time format for American English.
LOGNAME
Your login name, marked readonly in the /etc/profile file.
MAIL
The pathname of the file used by the mail system to detect the arrival
of new mail. If MAIL is set, the shell periodically checks the modifi-
cation time of this file and displays the value of $MAILMSG, if this
time changes and the length of the file is greater than 0 (zero).
Set MAIL in your .profile file. The value normally assigned to it by
users of the mail or mailx commands is /var/spool/mail/$LOGNAME.
MAILCHECK
The number of seconds that the shell lets elapse before checking again
for the arrival of mail in the files specified by the MAILPATH or MAIL
variables. The default value is 600 seconds (10 minutes). If you set
MAILCHECK to 0 (zero), the shell checks before each prompt.
MAILPATH
A list of filenames separated from one another by a : (colon). If you
set this variable, the shell informs you of the arrival of mail in any
of the files specified in the list. You can follow each filename by a
% (percent sign) and a message to be displayed when mail arrives. Oth-
erwise, the shell uses the value of MAILMSG or, by default, the message
you have mail.
When MAILPATH is set, these files are checked instead of the file set
by MAIL. To check the files set by MAILPATH and the file set by MAIL,
specify the MAIL file in your list of MAILPATH files.
MAILMSG
The mail notification message. If you explicitly set MAILMSG to a null
string (MAILMSG=""), no message is displayed.
NLSPATH
Specifies a list of directories to search to find message catalogs.
PATH
An ordered list of directory pathnames separated by colons. The shell
searches these directories in the specified order when it looks for
commands. A null string anywhere in the list represents the current
directory.
PATH is normally initialized in the /etc/profile file, usually to
:/usr/bin (by definition, a null string is assumed in front of the
leading colon). You can reset this variable to suit your own needs.
Thus, if you wish to search your current directory last rather than
first, you would enter:
PATH=/usr/bin:
If you have a personal directory of commands (say, $HOME/bin) that you
want searched before the standard system directories, set your PATH as
follows:
PATH=$HOME/bin:/usr/bin:
The best place to set your PATH to something other than the default
value is in your .profile file (see The .profile File). You cannot
reset PATH if you are executing commands under the restricted shell
(Rsh).
PS1 The string to be used as the primary system prompt. An interactive
shell displays this prompt string when it expects input. The default
value of PS1 is $ followed by a space.
PS2 The value of the secondary prompt string. If the shell expects more
input when it encounters a newline character in its input, it prompts
with the value of PS2. The default value of PS2 is > followed by a
space.
IFS The characters that are internal field separators (the characters that
the shell uses during interpretation of spaces, see Interpretation of
Spaces). The shell initially sets IFS to include the space, tab, and
newline characters.
SHACCT
The name of a file that you own. If this variable is set, the shell
writes an accounting record in the file for each shell script executed.
You can use accounting programs such as acctcom and acctcms to analyze
the data collected.
SHELL
A pathname whose simple part (the part after the last /) contains an r
if you want the shell to become restricted when invoked. This should
be set and exported by the $HOME/.profile file of each restricted
login.
TIMEOUT
A number of minutes. After the shell displays its prompt, you have
TIMEOUT minutes to enter a command. If you fail to do so, the shell
exits; in the login shell, such an exit is a logout. Setting TIMEOUT
to 0 (zero) inhibits automatic logout.
Predefined Special Variables
Several variables have special meanings; the following are set only by the
shell:
$# The number of positional parameters passed to the shell, not counting
the name of the shell script itself. The $# variable thus yields the
number of the highest-numbered positional parameter that is set. One
of the primary uses of this variable is to check for the presence of
the required number of arguments.
$? The exit value of the last command executed. Its value is a decimal
string. Most commands return 0 (zero) to indicate successful comple-
tion. The shell itself returns the current value of $? as its exit
value.
$$ The process number of the current process. Because process numbers are
unique among all existing processes, this string of up to five digits
is often used to generate unique names for temporary files. The fol-
lowing example illustrates the recommended practice of creating tem-
porary files in a directory used only for that purpose:
temp=$HOME/temp/$$
ls >$temp
.
.
.
rm $temp
$! The process number of the last process run in the background (using the
& terminator). Again, this is a string of up to five digits.
$- A string consisting of the names of the execution flags (see Built-In
Commands) currently set in the shell.
Command Substitution
To capture the output of any command as an argument to another command,
place that command line within ` ` (grave accents). This concept is known
as command substitution. The shell first executes the command or commands
enclosed within the grave accents, and then replaces the whole expression,
grave accents and all, with their output. This feature is often used in
assignment statements:
today=`date`
This statement assigns the string representing the current date to the
today variable. The following assignment saves, in the files variable, the
number of files in the current directory:
files=`ls | wc -l`
You perform command substitution on any command that writes to standard
output by enclosing that command in grave accents. You can nest command
substitutions by preceding each of the inside sets of grave accents with a
\ (backslash):
logmsg=`echo Your login directory is \`pwd\``
You can also give values to shell variables indirectly by using the built-
in read command. The read command takes a line from standard input (usu-
ally your keyboard), and assigns consecutive words on that line to any
variables named:
read first middle last
Thus, read will accept the following input line
Jane C. Chen
and it will have the same effect as if you had entered
first=Jane init=C. last=Chen
The read command assigns any excess words to the last variable.
Quoting Mechanisms
The following characters have a special meaning to the shell and cause ter-
mination of a word unless quoted:
; & ( ) | ^ < >