Bourne Shell Scripting: An Introduction

Mark Walsh and Andrew Cornes

Level One Associates Limited

Press the Enter key to continue....
Press the T key to toggle between the slides and the course notes....

Navigating This Presentation

There is a Control Area: to reveal it move the mouse into the lower right corner of the slide, the navigation icons will then appear.
The Other Navigation Controls are...
- Next slide: Space bar, return, right arrow, down arrow, page down, click any where in slide that isn't in the control area, or click the "arrow" in lower right corner control area
- Previous slide: Up arrow, left arrow, page up, or click the "arrow" in lower right corner control area
- Toggle the slide styles from slides to course notes: Click on the toggle button in the control area, or press t.
...plus more!
To invoke the navigation menu: use the menu in the control area

Shell Scripts

At its simplest, a shell script is simply a list of one or more Unix commands stored in an ordinary text file.
Once a shell script file has been created, the permissions need to be set so that it can be executed.
Having reached the stage of creating a shell script file and setting its permissions appropriately, the script can be executed by simply entering its name at the Unix command prompt.

[any material that should appear in print but not on the slide]

Shell Variables (1)

In common with most programming languages, the shell provides facilities for variables.
When you are first faced with a shell prompt after logging in, the shell will already have quite a few variables defined for system purposes.
The contents of these, (and, indeed any), shell variables can be displayed using the echo command.
Shell variables can have a new value assigned to them with the = symbol.

Shell Variables (2)

Apart from the system-related variables, other variables with names chosen by you can be manipulated in the same way.
Sometimes it is necessary to concatenate the contents of a shell variable with another string in a way which causes confusion for the shell.
Some system variables are read only, (meaning that they cannot have new values assigned to them), and if necessary, you can make your own variables read only as well.

Shell Variables (3)

When you create variables in a shell script, they are "local" to that script. Quite often, (and especially in the case of system variables changed in a script), they need to be visible to other commands and scripts run from the shell.
If you intend to create and use many shell scripts, it is probably a good idea to place them all in a particular directory, and to set the PATH variable to make executing them easier.
So that the environment is tailored to suit you, shell variables may be set in initialisation files.

Shell Script Parameters

Shell scripts are made much more powerful and versatile by the shell’s support for dealing with command line parameters.
Using shell script parameters, even the name of the script can be accessed.
In the same way as any unassigned variable is empty, once all of the command line arguments have been assigned to parameters, other parameters remain empty.

Alternative Variable Assignment

In addition to assigning a simple string to a variable, the shell supports two other ways of giving a value to a variable.
It is sometimes necessary to take user input while a shell script is running, (so that the user can specify some data), and have this input placed into a variable.
It can be useful to take the normal output from a command and store it in a variable instead of having that output displayed.

Flow Control - Status Variables

In addition to allowing simple sequences of ordinary Unix commands in shell scripts, the shell supports a number of special commands which allow flow of execution to be controlled.
To help support these flow control constructs, the shell offers Status Variables such as $?, $# and $*.

Flow Control (1) `if`

The shell provides if for choosing between two control paths. The if construct uses the exit status of other commands to make the choice.
The if construct may take one of the two following forms:

if exit_status then no_error/true commands fi if exit_status then no_error/true commands else error/false commands fi

The `test` Command

The test command is provided to allow you to find out information that would otherwise be hard to find. It communicates this information via its own exit status, therefore, it is ideal for use with the if construct.
The most common format of the test command is:

test –flag file

where -flag indicates the type of test, the file is the filename of the file to which the test should be applied.

The `test`Command flags

Command values for flag include:

-e file exists?
-f file is ordinary?
-d file is directory?
-r file is readable by you?
-w file is writable by you?
-x file is executable by you?

Flow Control (2) `while` and `until`

The shell provides while and until for looping based upon exit status.
The while has the following general form:

while exit_status do commands done

The until has the following general form:

until exit_status do commands done

Flow Control (3) `for`

The if, while and until constructs all use the exit status. The shell provides two more flow control constructs based upon string values.
The first that we will consider is for for construct, which is another looping construct.
The for construct has the following general form:

for variable in wordlist do commands done

Flow Control (4) `case`

The last flow control construct is case. This allows multiple choices, (whereas if only allows two choices), based upon string values.
The general format of the case construct is:

case string in expression_1) commands_1 ;; expression_2) commands_2 ;; *) default_commands ;; esac

Flow Control (4) Reference

EXIT Status

String

Choice

if exit_status then true_commands else false_commands fi

case string in exp_1) commands_1 ;; exp_2) commands_2 ;; *) default_cmds ;; esac

Loops

while exit_status do commands done

until exit_status do commands done

for var in list do commands done

Trapping signals

Shell scripts, like ordinary executables, can be stopped with <ctrl-c>. This causes one of several "signals" to be sent by the Unix kernel to the user's current running process.
Signals, including the <ctrl-c> interrupt signal, typically cause process termination, but shell scripts can arrange for alternative actions on receipt of a signal.
To specify such alternatives, the trap command can be used. It has the following general format:

trap "commands" signal_list

Execute Permission

An ordinary text editor, (such as vi), is typically used to create shell script files, but for short scripts, cat could be used as follows:

$ cat > lsl ls –l <ctrl-d>

Execute permission can be given for a shell script using chmod. For example, a chmod command for allowing the execution of the lsl script above would be:

chmod +x lsl

Shell Variables (1) - In Depth

A shell variable is simply a place in memory which has a name, and which stores a string of characters as its value.
Here are some examples of shell variables which are typically already set up by the time you are faced with your initial shell prompt after logging in:

PATH PS1 CWD UID

When you enter a command at the keyboard, the shell trys to execute the command with each of the elements of the PATH variable pre-appended to it until it finds the command and runs it or until it runs out places to try.

Shell Variables (3) - In Depth

This shell uses the contents of the PS1 variable as a command prompt. In the example on this course, its value would be "$" by default.
The CWD variable is used to store the absolute pathname of the Present Working Directory, (or "current working directory", as it is commonly known), as set by the cd command.
The UID holds the user identification number, (as appears in the /etc/passwd file), in textual form.

Shell Variables (4) - In Depth

As well as being able to display shell variables, the echo command can be used to display ordinary text. Here are some echo examples:

$ echo Hello, world Hello, world $ echo UID $ UID $ echo $UID 1000 $ echo The value of UID is $UID The value of UID is 1000

Notice how the dollar symbol, "$", needs to be used to refer to the contents of the variable named UID, rather than the characters "U", "I", and "D" themselves. In other words, "UID", is the variable, and "$UID" is its contents.

Shell Variables (5) - In Depth

As an example of shell variable assignment, the following sequence produces a new command prompt by assigning a different value to the PS1 shell variable:

$ PS1="What next?" What next? Echo Prompt is now $PS1 Prompt is now What next? What next?

Shell Variables (6) - In Depth

Here is an example of a variable with a user-chosen name being given a value and then being displayed:

$ myvar="pre" $ echo Value of myvar has been $myvar viously set Value of myvar has been pre viously set

Notice that in this example, and in the example on the previous slide, there are no spaces immediately on either side of the "=" symbol. Introducing any spaces here will cause syntax errors.
A variable which has not had a value assigned to it is empty:

$ echo Value of anyvar has been $anyvar viously set Value of anyvar has been viously set

Shell Variables (7) - In Depth

Concatenating the contents of shell variables with other strings can sometimes cause problems. If from the first example, you wished the message "Value of myvar has been previously set" to be displayed, you might try the following in vain:

$ echo Value of myvar has been $myvarvariously set Value of myvar has been set

If you haven't already guessed, this goes wrong because you are trying to access the contents of a variable called myvarviously which has not had a value assigned to it, and which is, therefore, empty.

Shell Variables (8) - In Depth

The workaround for this problem is to use curly brackets { and } around the variable name after the "$" symbol as follows:

$ myvar="pre" $ echo Value of my var has been ${myvar}viously set Value of myvar has been previously set

It doesn't make sense to change the value of the UID, and the following will not be allowed by the shell:

$ UID=2000

Your own variables can be made read only in the following way:

Shell Variables (8) - In Depth

To make shell variables available outside the script in which they were set, the export command should be used as follows:

$ PATH=/bin:/usr/bin:$HOME/bin:. $ export PATH

Notice the use of another system-orientated variable, HOME, which is used to store the user's home directory. Also notice that concatenating HOME with a string literal here is made simpler by the fact that a slash character, "/", which is not a valid variable name character, immediately follows the reference to the HOME variable.

Shell Variables (9) - In Depth

The previous assignment includes a bin directory in the user's home directory. This would be a useful place to put your own shell scripts so that they may be executed from whichever directory you happen to be in.
The natural place to put modifications to system variables is in the shell's initialisation files. The name of this file varies between shells, e.g. ".profile" or ".login". Also, when modifying variable here, it is often useful to give them a value based upon a value that is given to them in the system-wide initialisation file, as follows:

$ PATH=$PATH:$HOME/bin $ export PATH

Simple shell Scripts and Shell Variables

To begin with, generate the simple lsl shell script we saw earlier. Use either vi or cat. Once this has been done, set the permissions appropriately with chmod, and execute it.
Write a shell script called varval which displays the values of PATH, PS1, PWD and UID as in the following example:

$ varval PATH=/bin:/usr/bin:$HOME/bin:. PS1=$ PWD=/home/mark/scripts

On the command line, modify the PATH variable to include the directory which contains the varval shell script. Now, change the directory to somewhere else, and run varval again.

Shell Script Parameters

It is very common for the commands that you use at the shell prompt to make use of command line parameters. In the case of cp command for example:

$ cp crucial.txt safe.txt

The filenames crucial.txt and safe.txt need to accessed by the cp command for it to perform the copy operation. In some instances, even the command name itself needs to accessed by the program, e.g. vi and view.
Within a shell script, the notation $0, $1, $2 and so on, can be used to access the values of command line arguments.

Shell Scripts Parameters

From the cp example on the previous slide:

$0 has a value cp
$1 has a value crucial.txt
$2 has a value safe.txt
Other parameters, such as $3, are empty, just like the unassigned variables that we have already encountered.

Using our lsl example from earlier, the following command would only give a long directory listing of the /bin directory if /bin happened to the current working directory:

$ lsl /bin

Shell Scripts Parameters

So that lsl will respond in a fashion more like we would expect, the lsl shell script could be rewritten the following way:

ls –l $1

This will mean that the string "/bin" will be substituted into the ls command in the script to produce:

$ ls –l /bin

Alternative Variable Assignment

Here is an example of a shell script which reads some text from the user and then displays it:

echo –n "Enter some text: " read text echo You typed $text

Normally, when echo is used, it automatically adds a newline character to the end of the line. When –n is used as above, echo does not add a newline. This means that subsequent characters displayed will appear on the same line. This is useful in the above example, because it makes the "Enter some test:" string look like a prompt.

Alternative Variable Assignment

Input text can be split up into words for you:

echo –n "Enter some text: " read first second restofinput echo First word: $first echo Second word: $second echo Rest of input: $restofinput

Alternative Variable Assignment

What will happen when two, three and four words are entered as input?
The following sequence shows assignment via "command substitution":

/home/mark/bin $ currentdir=`pwd` $ echo $currentdir /home/mark/bin

Because of the backquotes, "`", to enclose the string pwd, the pwd string is executed as a command, and its output, ("/home/mark/bin" in our example), is stored in the currentdir variable.

Flow control - Status Variables

In common with other high level programming languages, the shell supports conditional constructs, (if and case), and iterative constructs, (while, until and for).
The Status Variables have the following meanings:

$? This variable holds the "exit status" returned by the last command executed by the shell.
$# This holds the number of command line parameters that were passed to the current script.
$* This variable contains a list of all command line arguments apart from the command name, (i.e., the contents of $1, $2 etc.), that were passed to the current script.
$$ This contains the process identification number, (PID), of the current shell. This is often used for generating temporary files with unique names within a shell.

Flow control - Status Variables

Here is an examples of $?:

$ cd /notexit sh: /noexist: No such file or directory $ echo $? 1 $ echo $? 0

Flow control - Status Variables

Here is an examples of $#:

S cat > nargs echo $# <ctrl-d> $ chmod +x nargs $ nargs one two three 3

Flow control - Status Variables

Here is an examples of $*:

$ cat > showargs echo $* <ctrl-d> $ chmod +x showargs $ showargs one two three one two three

Flow Control (1) - In Depth

To show if in action, here is a shell script which will take a username on the command line, and report back saying whether that user exists on the system:

# Usage: exists username if grep "^$1:" /etc/passwd > /dev/null 2> /dev/null then echo The user $1 exists exit 0 else echo The user $1 does not exist exit 1 fi

Flow Control (1) - In Depth

There are one or two, (or three), new things to point out. Firstly, note the use of a hash symbol, "#", to allow the inclusion of comments into shell scripts. Secondly, notice how a command's exit status is checked by including its invocation directly in the if construct. Thirdly, notice the use of exit to terminate the shell script and provide an exit status to any other program which calls exists
Another script, then, could use exists in the following way:

if exists mark then commands fi

The `test` Command - In Depth

As an example of test, the following shell script will test for the existence of a command line specified file, and display a message appropriately:

if test –e $1 then echo The file $1 exists else echo The file $1 does not exist fi

The `test` Command - In Depth

Here is a fuller list of what test can do:

-d file True if file exists and is a directory
-e file True if file exists.
-f file True if file exists and is a regular file.
-r file True if file exists and is readable.
-s file True if file exists and has a size greater than zero bytes.
-w file True if file exists and is writable.
-x file True if file exists and is executable.

The `test` Command - In Depth

file1 –nt file2 True if file1 is newer (according to modification date) than file2.
file1 –ot file2 True if file1 is older than file2.
-z string True if length of the string is zero
-n string True if the length of the string is non-zero.
string1 = string2 True if string1 is lexically the same as string2

Practical

Parameters and Status Variables
Write a shell script called chkpath which displays "0", (a no-error exit status), if the pathname included on its command line appears in the PATH variable, or a "1", (an error exit status), otherwise. With PATH having the following example value:

/bin:/usr/bin:/home/mark/bin:.

chkpath's output would appear like this:

$ chkpath /usr/bin 0 $ chkpath /bad_dir 1

Flow Control (2) - In Depth

Here is a simple example of a while construct:

while test –e $1 do sleep 2 done echo File $1 does not exist

This fragment of a shell script will sit in the while loop until the file whose name has been passed as an argument on the command line doesn't exist anymore. Rather than sit on a "busy" loop – which uses up a relatively large amount of processing power – the use of sleep 2 causes it to only check for the file"s existence every 2 seconds.

Flow Control (2) - In Depth

The following until example will continue looping until a user named scs is added to the /etc/passwd file outside of the shell script in which the until appears.
This code may seem not to have very much use – particularly as it doesn"t attempt to delete the file itself. However, it is quite common to stop more that one access at one time to a particular file by using a "lock" file. So, when the program wishes to access the one-at-a-time file, it will create a lock file, use the protected file, then remove the lock file afterwards. Another program could use the code fragment above to make sure it doesn't proceed until the first process removes the lock file ($1).

Flow Control (2) - In Depth

The until construct is basically the same as while, except that instead of continuing to loop while the conditional part is true, (i.e., no errors – or zero – as an exit status), until continues looping while the conditional part is false, (i.e., an error value – or non-zero – as an exit status).

until grep "^scs:" /etc/passwd > /dev/null 2> /dev/null do sleep 5 done

Practical

Modify the previous chkpath script so that no output is displayed, but whether the parameter-specified pathname appears in the PATH variable can be determined by its exit status. An exit status of 0 means that the pathname was found, and an exit status of 1 means that the pathname was not found.
Write a shell script called addpath which appends a parameter-specified pathname onto the end of the PATH variable if the path doesn’t already appear. Use chkpath to determine whether the new pathname needs appending. An exit status of 0 should be produced if the pathname was added, and an exit status of 1 should be produced if the pathname was already present in PATH.

Practical

Write a script called doubleln which reads lines of standard input until end-of-file, and outputs those line with a blank line immediately afterwards, thus having the effect of double line spacing the text. Because doubleln uses standard input and standard output, I/O redirection can be applied to it, and it can be used in pipelines:

$ doubleln <congrats.txt Congratulations on your choice of the Armstrong and Mason virus security product. If installed with care, it will give years of trouble-free protection. $ ls –l | doubleln -rw-r--r-- 1 mark 1000 92365 Dec 3 20:37 bugs.txt -rw-r--r-- 1 mark 1000 152 Dec 3 20:37 congrats.txt $

Flow Control (3) - In Depth

Here is a simple example of a for-based loop:

for i in 1 2 3 4 5 do echo Value of 1 is $1 done

This, as you might expect, produces the following output:

Value of i is 1 Value of i is 2 Value of i is 3 Value of i is 4 Value of i is 5

Flow Control (3) - In Depth

We have already seen how to use a pre-known number of command line arguments. The for construct provides a simple mechanism for dealing with an unknown number of command line arguments using the $* status variable we saw earlier.

The following example will display all the command line arguments, each on a separate line:

for i in $* do echo $i done

This may seem to be of limited value until you know how the shell deals with wild-cards on the command line. To find out, try a wild-card filename specification on the previous shell script.

Flow Control (3) - In Depth

You will find that, in response to a wild card such a *.txt, the shell will find all of the filenames which match the specification, and pass all their names on the command line. So a command line which calls a shell script in the following way:
will give the full list of filename which have a .txt extension to the script. Hence, script may believe that it was called with a command line something like this: $ script andrew.txt mark.txt scs.txt
where andrew.txt, mark.txt and scs.txt are all of the files that the shell found which matched the *.txt wild-card specification.

Flow Control (4) - In Depth

Here is an example of the case construct in a shell script called append which can take one or two command line arguments. If it is given one, it will append any text entered from the keyboard until end of file onto the file named on the command line, if two, it will append the contents of a file named by the second argument onto the file named by the first.

Flow Control (4) - In Depth

If append is supplied the wrong argument, (none or three, say), a "usage" message will be displayed to inform the user of how append can be used:

case $# in 1) cat >> $1 ;; 2) cat >> $1 < $2 ;; *) echo Usage: append out_file [in_file] ;; esac exit 0

The "usage" message uses square brackets, "[ ]" to represent optionality as is common in Unix documentation.

Practical

Flow Control using String Values

Add code to both chkpath and addpath so that if a single pathname is not specified on the command line, then they have an exit status of –1.
Write a shell script called fsize which lists the name and size, (in bytes), of all the files listed on its command line. Output from fsize could look something like this:

$ fsize am_virus *.txt am_virus 132991 bugs.txt 92365 congrats.txt 152

The fsize script should produce an appropriate exit status for errors or success.

Web Based Training