Linux Command

Editing the scripts you already have
Before we get to writing new scripts, I want to point out that you have some scripts of your own already. These scripts
were put into your home directory when your account was created, and are used to configure the behavior of your
sessions on the computer. You can edit these scripts to change things.
In this lesson, we will look at a couple of these scripts and learn a few important new concepts about the shell.
Commands, commands everywhere
Up to now, we really have not discussed exactly what commands are. Commands can be several different things.
Some commands are built into the shell itself. That is, the shell automatically understands a few commands on
its own. The commandscd and pwd are in this group. Commands implemented in the shell itself are called shell
builtins. To see a list of the commands built into bash, use the helpcommand.
The second type of commands is the executable programs. Most commands are in this group. Executable
programs are all the files in the directories included in your path.
The last two groups of commands are contained in your runtime environment. During your session, the system
is holding a number of facts about the world in its memory. This information is called theenvironment. The
environment contains such things as your path, your user name, the name of the file where your mail is
delivered, and much more. You can see a complete list of what is in your environment with the setcommand.
The two types of commands contained in the environment are aliases and shell functions.
Aliases
Now, before you become too confused about what I just said, let's make an alias. Make sure you are in your
home directory. Using your favorite text editor, open the file .bash_profile and add this line to the end of the
file:
alias l='ls -l'
The .bash_profile file is a shell script that is executed each time you log in. By adding the alias command to the
file, we have created a new command called "l" which will perform "ls -l". To try out your new command, log out
and log back in. Using this technique, you can create any number of custom commands for yourself. Here is
another one for you to try:
alias today='date +"%A, %B %-d, %Y"'

This alias creates a new command called "today" that will display today's date with nice formatting.
By the way, the aliascommand is just another shell builtin. You can create your aliases directly at the command
prompt; however they will only remain in effect during your current shell session. For example:
[me@linuxbox me]$ alias l='ls -l'
Shell functions
Aliases are good for very simple commands, but if you want to create something more complex, you should try
shell functions. Shell functions can be thought of as "scripts within scripts" or little sub-scripts. Let's try one.
Open .bash_profile with your text editor again and replace the alias for "today" with the following:
function today {
echo "Today's date is:"
date +"%A, %B %-d, %Y"
Believe it or not, function is a shell builtin too, and as with alias, you can enter shell functions directly at the
command prompt.
[me@linuxbox me]$ function today {
> echo "Today's date is:"
> date +"%A, %B %-d, %Y"
>}
[me@linuxbox me]$
type
Since there are many types of commands, it can become confusing to tell what is an alias, a shell function or an
executable file. To determine what a command is, use the typecommand. type will display what type of
command it is. It can be used as follows:
[me@linuxbox me]$ type command
.bashrc
Though placing your aliases and shell functions in your .bash_profile will work, it is not considered good form.
There is a separate file named .bashrc that is intended to be used for such things. You may notice a piece of
code near the beginning of your .bash_profilethat looks something like this:
if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi
This script fragment checks to see if there is a.bashrc file in your home directory. If one is found, then the script
will read its contents. If this code is in your.bash_profile, you should edit the.bashrc file and put your aliases and
shell functions there.
Previous | Contents | Top | Next
________________________________________
© 2000-2013, William E. Shotts, Jr. Verbatim copying and distribution of this entire article is permitted in any
medium, provided this copyright notice is preserved.
Linux® is a registered trademark of Linus Torvalds.
• LinuxCommand
• Learning the shell
• Writing shell scripts
• Script library
• SuperMan pages
• Who, What, Where, Why
________________________________________
• Tips, News And Rants Previous | Contents | Next
Here Scripts
In the following lessons, we will construct a useful application. This application will produce an HTML document
that contains information about your system. I spent a lot of time thinking about how to teach shell
programming, and the approach I have come up with is very different from most approaches that I have seen.
Most favor a rather systematic treatment of the many features, and often presume experience with other
programming languages. Although I do not assume that you already know how to program, I realize that many
people today know how to write HTML, so our first program will make a web page. As we construct our script,
we will discover step by step the tools needed to solve the problem at hand.
Writing an HTML file with a script
As you may know, a well formed HTML file contains the following content:
<HTML>
<HEAD>
<TITLE>
The title of your page
</TITLE>
</HEAD>
<BODY>
Your page content goes here.
</BODY>
</HTML>
Now, with what we already know, we could write a script to produce the above content:
#!/bin/bash
# make_page - A script to produce an HTML file
echo "<HTML>"
echo "<HEAD>"
echo " <TITLE>"
echo " The title of your page"
echo " </TITLE>"
echo "</HEAD>"
echo ""
echo "<BODY>"
echo " Your page content goes here."
echo "</BODY>"
echo "</HTML>"
This script can be used as follows:
[me@linuxbox me]$ make_page > page.html
It has been said that the greatest programmers are also the laziest. They write programs to save themselves
work. Likewise, when clever programmers write programs, they try to save themselves typing.
The first improvement to this script will be to replace the repeated use of the echo command with ahere script,
thusly:
#!/bin/bash
cat << _EOF_
<HTML>
<HEAD>
<TITLE>
</TITLE>
</HEAD>
<BODY>
</BODY>
</HTML>
_EOF_
A here script (also sometimes called a here document) is an additional form of I/O redirection. It provides a way
to include content that will be given to the standard input of a command. In the case of the script above, the cat
command was given a stream of input from our script to its standard input.
A here script is constructed like this:
command << token
content to be used as command's standard input
token
token can be any string of characters. I use "_EOF_" (EOF is short for "End Of File") because it is traditional, but
you can use anything, as long as it does not conflict with a bash reserved word. The token that ends the here
script must exactly match the one that starts it, or else the remainder of your script will be interpreted as more
standard input to the command.
There is one additional trick that can be used with a here script. Often you will want to indent the content
portion of the here script to improve the readability of your script. You can do this if you change the script as
follows:
#!/bin/bash
cat <<- _EOF_
<HTML>
<HEAD>
<TITLE>
</TITLE>
</HEAD>
<BODY>
</BODY>
</HTML>
_EOF_
Changing the the "<<" to "<<-" causes bash to ignore the leading tabs (but not spaces) in the here script. The
output from the cat command will not contain any of the leading tab characters.
O.k., let's make our page. We will edit our page to get it to say something:
#!/bin/bash
cat <<- _EOF_
<HTML>
<HEAD>
<TITLE>
My System Information
</TITLE>
</HEAD>
<BODY>
<H1>My System Information</H1>
</BODY>
</HTML>
_EOF_
In our next lesson, we will make our script produce real information about the system.
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
• Tips, News And Rants Previous | Contents | Next
Substitutions - Part 1
#!/bin/bash
cat <<- _EOF_
<HTML>
<HEAD>
<TITLE>
My System Information
</TITLE>
</HEAD>
<BODY>
<H1>My System Information</H1>
</BODY>
</HTML>
_EOF_
Now that we have our script working, let's improve it. First off, we'll make some changes because we want to be
lazy. In the script above, we see that the phrase "My System Information" is repeated. This is wasted typing (and
extra work!) so we improve it like this:
#!/bin/bash
title="My System Information"
cat <<- _EOF_
<HTML>
<HEAD>
<TITLE>
$title
</TITLE>
</HEAD>
<BODY>
<H1>$title</H1>
</BODY>
</HTML>
_EOF_
As you can see, we added a line to the beginning of the script and replaced the two occurrences of the phrase
"My System Information" with$title.
Variables
What we have done is to introduce a very fundamental idea that appears in almost every programming
language, variables. Variables are areas of memory that can be used to store information and are referred to by
a name. In the case of our script, we created a variable called "title" and placed the phrase "My System
Information" into memory. Inside the here script that contains our HTML, we use "$title" to tell the shell to
substitute the contents of the variable.
As we shall see, the shell performs various kinds of substitutions as it processes commands. Wildcards are an
example. When the shell reads a line containing a wildcard, it expands the meaning of the wildcard and then
continues processing the command line. To see this in action, try this:
[me@linuxbox me]$ echo *
Variables are treated in much the same way by the shell. Whenever the shell sees a word that begins with a "$",
it tries to find out what was assigned to the variable and substitutes it.
How to create a variable
To create a variable, put a line in your script that contains the name of the variable followed immediately by an
equal sign ("="). No spaces are allowed. After the equal sign, assign the information you wish to store. Note that
no spaces are allowed on either side of the equal sign.
Where does the variable's name come from?
You make it up. That's right; you get to choose the names for your variables. There are a few rules.
1. It must start with a letter.
2. It must not contain embedded spaces. Use underscores instead.
3. Don't use punctuation marks.
4. Don't use a name that is already a word understood by bash. These are called reserved words and
should not be used as variable names. If you use one of these words, bash will get confused. To see a list of
reserved words, use the help command.
How does this increase our laziness?
The addition of the title variable made our life easier in two ways. First, it reduced the amount of typing we had
to do. Second and more important, it made our script easier to maintain.
As you write more and more scripts (or do any other kind of programming), you will learn that programs are
rarely ever finished. They are modified and improved by their creators and others. After all, that's what open
source development is all about. Let's say that you wanted to change the phrase "My System Information" to
"Linuxbox System Information." In the previous version of the script, you would have had to change this in two
locations. In the new version with the title variable, you only have to change it in one place. Since our script is so
small, this might seem like a trivial matter, but as scripts get larger and more complicated, it becomes very
important. Take a look at some of the scripts in the Script Library to get a sense of what large scripts look like.
Environment Variables
When you start your shell session, some variables are already ready for your use. They are defined in scripts that
run each time a user logs in. To see all the variables that are in your environment, use the printenvcommand.
One variable in your environment contains the host name for your system. We will add this variable to our script
like so:
#!/bin/bash
title="System Information for"
cat <<- _EOF_
<HTML>
<HEAD>
<TITLE>
$title $HOSTNAME
</TITLE>
</HEAD>
<BODY>
<H1>$title $HOSTNAME</H1>
</BODY>
</HTML>
_EOF_
Now our script will always include the name of the machine on which we are running. Note that, by convention,
environment variables names are uppercase.
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
• Tips, News And Rants
Previous | Contents | Next
Substitutions - Part 2
In our last lesson, we learned how to create variables and perform substitutions with them. In this lesson, we
will extend this idea to show how we can substitute the results from a command.
When we last left our script, it could create an HTML page that contained a few simple lines of text, including
the host name of the machine which we obtained from the environment variable HOSTNAME. Next, we will add
a timestamp to the page to indicate when it was last updated, along with the user that did it.
#!/bin/bash
title="System Information for"

cat <<- _EOF_
<HTML>
<HEAD>
<TITLE>
$title $HOSTNAME
</TITLE>
</HEAD>
<BODY>
<H1>$title $HOSTNAME</H1>
<P>Updated on $(date +"%x %r %Z") by $USER
</BODY>
</HTML>
_EOF_
As you can see, we employed another environment variable, USER, to get the user name. In addition, we used
this strange looking thing:
$(date +"%x %r %Z")
The characters "$( )" tell the shell, "substitute the results of the enclosed command." In our script, we want the
shell to insert the results of the command date +"%x %r %Z"which expresses the current date and time. The date
command has many features and formatting options. To look at them all, try this:
[me@linuxbox me]$ date --help | less
Be aware that there is an older, alternate syntax for "$(command)" that uses the backtick character " ` ". This
older form is compatible with the original Bourne shell (sh). I tend not to use the older form since I am teaching
bash here, not sh, and besides, I think backticks are ugly. The bash shell fully supports scripts written for sh, so
the following forms are equivalent:
$(command)
`command`
--help and other tricks

How do you learn about commands? Well, besides reading about them on LinuxCommand.org, you might try
using the man page for the command in question. The SuperMan Pages on LinuxCommand.org contain a
complete set for popular Linux distribution. But what if the command doesn't have a man page?
The first thing to try is "--help". All of the tools written by the GNU Project from the Free Software Foundation
implement this option. To get a brief list of the command's options, just type:
[me@linuxbox me]$ command --help
Many commands (besides the GNU tools) will either accept the --help option or will consider it an invalid option
and will display a usage message which you may find equally useful.
If the results of the --help option scroll off the screen, pipe the results into less to view it like this:
[me@linuxbox me]$ command --help | less
Some commands don't have help messages or don't use --help to invoke them. On these mysterious commands,
I use this trick:
First, find out where the executable file is located (this trick will only work with programs, not shell builtins). This
is easily done by typing:
[me@linuxbox me]$ which command
The which command will tell you the path and file name of the executable program. Next, use the strings
command to display text that may be embedded within the executable file. For example, if you wanted to look
inside the bash program, you would do the following:
[me@linuxbox me]$ which bash
/bin/bash
[me@linuxbox me]$ strings /bin/bash
The strings command will display any human readable content buried inside the program. This might include
copyright notices, error messages, help text, etc.
Finally, if you have a very inquisitive nature, get the command's source code and read that. Even if you cannot
fully understand the programming language in which the command is written, you may be able to gain valuable
insight by reading the author's comments in the program's source.
Assigning a command's result to a variable
You can also assign the results of a command to a variable:
right_now=$(date +"%x %r %Z")
You can even nest the variables (place one inside another), like this:
right_now=$(date +"%x %r %Z")
time_stamp="Updated on $right_now by $USER"

Constants
As the name variable suggests, the content of a variable is subject to change. This means that it is expected that
during the execution of your script, a variable may have its content modified by something you do.
On the other hand, there may be values that, once set, should never be changed. These are calledconstants. I
bring this up because it is a common idea in programming. Most programming languages have special facilities
to support values that are not allowed to change. Bash also has these facilities but, to be honest, I never see it
used. Instead, if a value is intended to be a constant, it is simply given an uppercase name. Environment
variables are usually considered constants since they are rarely changed. Like constants, environment variables
are given uppercase names by convention. In the scripts that follow, I will use this convention - uppercase
names for constants and lowercase names for variables.
So with everything we know, our program looks like this:
#!/bin/bash
TITLE="System Information for $HOSTNAME"
RIGHT_NOW=$(date +"%x %r %Z")
TIME_STAMP="Updated on $RIGHT_NOW by $USER"
cat <<- _EOF_
<HTML>
<HEAD>
<TITLE>
$TITLE
</TITLE>
</HEAD>
<BODY>
<H1>$TITLE</H1>
<P>$TIME_STAMP
</BODY>
</HTML>
_EOF_
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Quoting
We are going to take a break from our script to discuss something we have been doing but have not explained
yet. In this lesson we will coverquoting. Quoting is used to accomplish two goals:
1. To control (i.e., limit) substitutions and
2. To perform grouping of words.
We have already used quoting. In our script, the assignment of text to our constants was performed with
quoting:

In this case, the text is surrounded by double quote characters. The reason we use quoting is to group the words
together. If we did not use quotes, bash would think all of the words after the first one were additional
commands. Try this:
[me@linuxbox me]$ TITLE=System Information for $HOSTNAME
Single and double quotes
The shell recognizes both single and double quote characters. The following are equivalent:
var="this is some text"
var='this is some text'
However, there is an important difference between single and double quotes. Single quotes limit substitution.
As we saw in the previous lesson, you can place variables in double quoted text and the shell still performs
substitution. We can see this with the echocommand:
[me@linuxbox me]$ echo "My host name is $HOSTNAME."
My host name is linuxbox.
If we change to single quotes, the behavior changes:
[me@linuxbox me]$ echo 'My host name is $HOSTNAME.'
My host name is $HOSTNAME.
Double quotes do not suppress the substitution of words that begin with "$" but they do suppress the expansion
of wildcard characters. For example, try the following:
[me@linuxbox me]$ echo *
[me@linuxbox me]$ echo "*"
Quoting a single character
There is another quoting character you will encounter. It is the backslash. The backslash tells the shell to "ignore
the next character." Here is an example:
[me@linuxbox me]$ echo "My host name is \$HOSTNAME."
My host name is $HOSTNAME.
By using the backslash, the shell ignored the "$" symbol. Since the shell ignored it, it did not perform the
substitution on $HOSTNAME. Here is a more useful example:
[me@linuxbox me]$ echo "My host name is \"$HOSTNAME\"."
My host name is "linuxbox".
As you can see, using the \" sequence allows us to embed double quotes into our text.
Other backslash tricks
If you look at the manpages for any program written by the GNU project, you will notice that in addition to
command line options consisting of a dash and a single letter, there are also long option names that begin with
two dashes. For example, the following are equivalent:
ls -r
ls --reverse
Why do they support both? The short form is for lazy typists on the command line and the long form is for
scripts. I sometimes use obscure options, and I find the long form useful if I have to review my script again
months after I wrote it. Seeing the long form helps me understand what the option does, saving me a trip to the
manpage. A little more typing now, a lot less work later. Laziness is maintained.
As you might suspect, using the long form options can make a single command line very long. To combat this
problem, you can use a backslash to get the shell to ignore a newline character like this:
ls -l \
--reverse \
--human-readable \
--full-time
Using the backslash in this way allows us to embed newlines in our command. Note that for this trick to work,
the newline must be typed immediately after the backslash. If you put a space after the backslash, the space will
be ignored, not the newline. Backslashes are also used to insert special characters into our text. These are
calledbackslash escape characters. Here are the common ones:
Escape Character Name Possible Uses
\n newlineAdding blank lines to text
\t tab Inserting horizontal tabs to text
\a alert Makes your terminal beep
\\ backslash Inserts a backslash
\f formfeed Sending this to your printer ejects the page

The use of the backslash escape characters is very common. This idea first appeared in the C programming
language. Today, the shell, C++, perl, python, awk, tcl, and many other programming languages use this concept.
Using the echo command with the -e option will allow us to demonstrate:
[me@linuxbox me]$ echo -e "Inserting several blank lines\n\n\n"
Inserting several blank lines
[me@linuxbox me]$ echo -e "Words\tseparated\tby\thorizontal\ttabs."
Words separated by horizontal tabs
[me@linuxbox me]$ echo -e "\aMy computer went \"beep\"."
My computer went "beep".
[me@linuxbox me]$ echo -e "DEL C:\\WIN2K\\LEGACY_OS.EXE"
DEL C:\WIN2K\LEGACY_OS.EXE
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Shell Functions
As programs get longer and more complex, they become more difficult to design, code, and maintain. As with
any large endeavor, it is often useful to break a single, large task into a number of smaller tasks.
In this lesson, we will begin to break our single monolithic script into a number of separate functions.
To get familiar with this idea, let's consider the description of an everyday task -- going to the market to buy
food. Imagine that we were going to describe the task to a man from Mars.
Our first top-level description might look like this:
1. Leave house
2. Drive to market
3. Park car
4. Enter market
5. Purchase food
6. Drive home
7. Park car
8. Enter house
This description covers the overall process of going to the market; however a man from Mars will probably
require additional detail. For example, the "Park car" sub task could be described as follows:
1. Find parking space
2. Drive car into space
3. Turn off motor
4. Set parking brake
5. Exit car
6. Lock car
Of course the task "Turn off motor" has a number of steps such as "turn off ignition" and "remove key from
ignition switch," and so on.
This process of identifying the top-level steps and developing increasingly detailed views of those steps is called
top-down design. This technique allows you to break large complex tasks into many small, simple tasks.
As our script continues to grow, we will use top down design to help us plan and code our script.
If we look at our script's top-level tasks, we find the following list:
1. Open page
2. Open head section
3. Write title
4. Close head section
5. Open body section
6. Write title
7. Write time stamp
8. Close body section
9. Close page
All of these tasks are implemented, but we want to add more. Let's insert some additional tasks after task 7:
7. Write time stamp
8. Write system release info
9. Write up-time
10. Write drive space
11. Write home space
12. Close body section
13. Close page
It would be great if there were commands that performed these additional tasks. If there were, we could use
command substitution to place them in our script like so:
#!/bin/bash
# system_page - A script to produce a system information HTML file
##### Constants
##### Main
cat <<- _EOF_
<html>
<head>
<title>$TITLE</title>
</head>
<body>
<h1>$TITLE</h1>
<p>$TIME_STAMP</p>
$(system_info)
$(show_uptime)
$(drive_space)
$(home_space)
</body>
</html>
_EOF_
While there are no commands that do exactly what we need, we can create them using shell functions.
As we learned in lesson 2, shell functions act as "little programs within programs" and allow us to follow top-
down design principles. To add the shell functions to our script, we change it so:
#!/bin/bash
# system_page - A script to produce an system information HTML file
##### Constants
##### Functions
function system_info
function show_uptime
function drive_space
}
function home_space
##### Main
cat <<- _EOF_
<html>
<head>
</head>
<body>
<h1>$TITLE</h1>
<p>$TIME_STAMP</p>
$(system_info)
$(show_uptime)
$(drive_space)
$(home_space)
</body>
</html>
_EOF_
A couple of important points about functions: First, they must appear before you attempt to use them. Second,
the function body (the portions of the function between the { and } characters) must contain at least one valid
command. As written, the script will not execute without error, because the function bodies are empty. The
simple way to fix this is to place a returnstatement in each function body. After you do this, our script will
execute successfully again.
Keep your scripts working
When you are developing a program, it is is often a good practice to add a small amount of code, run the script,
add some more code, run the script, and so on. This way, if you introduce a mistake into your code, it will be
easier to find and correct.
As you add functions to your script, you can also use a technique called stubbing to help watch the logic of your
script develop. Stubbing works like this: imagine that we are going to create a function called "system_info" but
we haven't figured out all of the details of its code yet. Rather than hold up the development of the script until
we are finished with system_info, we just add an echo command like this:
# Temporary function stub
echo "function system_info"
This way, our script will still execute sucessfully, even though we do not yet have a finished system_info
function. We will later replace the temporary stubbing code with the complete working version.
The reason we use an echo command is so we get some feedback from the script to indicate that the functions
are being executed.
Let's go ahead and write stubs for our new functions and keep the script working.
#!/bin/bash
# system_page - A script to produce an system information HTML file
##### Constants

##### Functions
echo "function system_info"
echo "function show_uptime"
echo "function drive_space"
function home_space
{
echo "function home_space"
##### Main
cat <<- _EOF_
<html>
<head>
</head>
<body>
<h1>$TITLE</h1>
<p>$TIME_STAMP</p>
$(system_info)
$(show_uptime)
$(drive_space)
$(home_space)
</body>
</html>
_EOF_
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Some Real Work
In this lesson, we will develop some of our shell functions and get our script to produce some useful
information.
show_uptime
The show_uptime function will display the output of the uptime command. The uptime command outputs
several interesting facts about the system, including the length of time the system has been "up" (running) since
its last re-boot, the number of users and recent system load.
[me@linuxbox me]$ uptime
9:15pm up 2 days, 2:32, 2 users, load average: 0.00, 0.00, 0.00
To get the output of the uptime command into our HTML page, we will code our shell function like this,
replacing our temporary stubbing code with the finished version:
echo "<h2>System uptime</h2>"

echo "<pre>"
uptime
echo "</pre>"
As you can see, this function outputs a stream of text containing a mixture of HTML tags and command output.
When the substitution takes place in the main body of the our program, the output from our function becomes
part of the here script.
drive_space
The drive_space function will use the dfcommand to provide a summary of the space used by all of the mounted
file systems.
[me@linuxbox me]$ df
Filesystem 1k-blocks Used Available Use% Mounted on
/dev/hda2 509992 225772 279080 45% /
/dev/hda1 23324 1796 21288 8% /boot
/dev/hda3 15739176 1748176 13832360 12% /home
/dev/hda5 3123888 3039584 52820 99% /usr
In terms of structure, the drive_space function is very similar to the show_uptime function:
echo "<h2>Filesystem space</h2>"
echo "<pre>"
df
echo "</pre>"
home_space
The home_space function will display the amount of space each user is using in his/her home directory. It will
display this as a list, sorted in descending order by the amount of space used.
function home_space
echo "<h2>Home directory space by user</h2>"
echo "<pre>"
echo "Bytes Directory"
du -s /home/* | sort -nr
echo "</pre>"
Note that in order for this function to successfully execute, the script must be run by the superuser, since the
ducommand requires superuser privileges to examine the contents of the /home directory.
system_info
We're not ready to finish the system_info function yet. In the meantime, we will improve the stubbing code so it
produces valid HTML:
echo "<h2>System release info</h2>"
echo "<p>Function not yet implemented</p>"
________________________________________

• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Flow Control - Part 1
In this lesson, we will look at how to add intelligence to our scripts. So far, our script has only consisted of a
sequence of commands that starts at the first line and continues line by line until it reaches the end. Most
programs do more than this. They make decisions and perform different actions depending onconditions.
The shell provides several commands that we can use to control the flow of execution in our program. These
include:
• if
• exit
• for
• while
• until
• case
• break
• continue
if
The first command we will look at is if. The ifcommand is fairly simple on the surface; it makes a decision based
on a condition. The if command has three forms:
# First form
if condition ; then
commands
fi
# Second form
if condition ; then
commands
else
commands
fi
# Third form
if condition ; then
commands
elif condition ; then
commands
fi
In the first form, if the condition is true, then commands are performed. If the condition is false, nothing is done.
In the second form, if the condition is true, then the first set of commands is performed. If the condition is false,
the second set of commands is performed.
In the third form, if the condition is true, then the first set of commands is performed. If the condition is false,
and if the second condition is true, then the second set of commands is performed.
What is a "condition"?
To be honest, it took me a long time to really understand how this worked. To help answer this, there is yet
another basic behavior of commands we must discuss.
Exit status
A properly written Unix application will tell the operating system if it was successful or not. It does this by means
of an exit status. The exit status is a numeric value in the range of 0 to 255. A "0" indicates success; any other
value indicates failure. Exit status provides two important features. First, it can be used to detect and handle
errors and second, it can be used to perform true/false tests.
It is easy to see that handling errors would be valuable. For example, in our script we will want to look at what
kind of hardware is installed so we can include it in our report. Typically, we will try to query the hardware, and
if an error is reported by whatever tool we use to do the query, our script will be able to skip the portion of the
script which deals with the missing hardware.
We can also use the exit status to perform simple true/false decisions. We will cover this next.
test
The test command is used most often with the ifcommand to perform true/false decisions. The command is
unusual in that it has two different syntactic forms:
# First form
test expression
# Second form
[ expression ]
The test command works simply. If the given expression is true, test exits with a status of zero; otherwise it exits
with a status of 1.
The neat feature of testis the variety of expressions you can create. Here is an example:
if [ -f .bash_profile ]; then
echo "You have a .bash_profile. Things are fine."
else
echo "Yikes! You have no .bash_profile!"
fi
In this example, we use the expression " -f .bash_profile ". This expression asks, "Is .bash_profile a file?" If the
expression is true, then testexits with a zero (indicating true) and the if command executes the command(s)
following the word then. If the expression is false, thentest exits with a status of one and the if command
executes the command(s) following the word else.
Here is a partial list of the conditions thattest can evaluate. Since test is a shell builtin, use "help test" to see a
complete list.
Expression Description
-d file True if file is a directory.
-e file True if file exists.
-f file True if file exists and is a regular file.
-L file True if file is a symbolic link.
-r file True if file is a file readable by you.
-w file True if file is a file writable by you.
-x file True if file is a file executable by you.
file1 -nt file2 True if file1 is newer than (according to modification time) file2
file1 -ot file2 True if file1 is older than file2
-z string True if string is empty.
-n string True if string is not empty.
string1 = string2 True if string1 equals string2.
string1 != string2 True if string1 does not equal string2.
Before we go on, I want to explain the rest of the example above, since it also reveals more important ideas.
In the first line of the script, we see the if command followed by the test command, followed by a semicolon,
and finally the word then. I chose to use the [ expression ] form of the test command since most people think it's
easier to read. Notice that the spaces between the "[" and the beginning of the expression are required.
Likewise, the space between the end of the expression and the trailing "]".
The semicolon is a command separator. Using it allows you to put more than one command on a line. For
example:
[me@linuxbox me]$ clear; ls
will clear the screen and execute the ls command.
I use the semicolon as I did to allow me to put the word then on the same line as the if command, because I
think it is easier to read that way.
On the second line, there is our old friend echo. The only thing of note on this line is the indentation. Again for
the benefit of readability, it is traditional to indent all blocks of conditional code; that is, any code that will only
be executed if certain conditions are met. The shell does not require this; it is done to make the code easier to
read.
In other words, we could write the following and get the same results:
# Alternate form
if [ -f .bash_profile ]
then
echo "You have a .bash_profile. Things are fine."
else
echo "Yikes! You have no .bash_profile!"
fi
# Another alternate form
if [ -f .bash_profile ]
then echo "You have a .bash_profile. Things are fine."
else echo "Yikes! You have no .bash_profile!"
fi
exit
In order to be good script writers, we must set the exit status when our scripts finish. To do this, use the exit
command. The exit command causes the script to terminate immediately and set the exit status to whatever
value is given as an argument. For example:
exit 0
exits your script and sets the exit status to 0 (success), whereas
exit 1
exits your script and sets the exit status to 1 (failure).
Testing for root
When we last left our script, we required that it be run with superuser privileges. This is because the
home_space function needs to examine the size of each user's home directory, and only the superuser is
allowed to do that.
But what happens if a regular user runs our script? It produces a lot of ugly error messages. What if we could put
something in the script to stop it if a regular user attempts to run it?
The id command can tell us who the current user is. When executed with the "-u" option, it prints the numeric
user id of the current user.
[me@linuxbox me]$ id -u
501
[me@linuxbox me]$ su
Password:
[root@linuxbox me]# id -u
If the superuser executes id -u, the command will output "0." This fact can be the basis of our test:
if [ $(id -u) = "0" ]; then
echo "superuser"
fi
In this example, if the output of the commandid -u is equal to the string "0", then print the string "superuser."
While this code will detect if the user is the superuser, it does not really solve the problem yet. We want to stop
the script if the user is not the superuser, so we will code it like so:
if [ $(id -u) != "0" ]; then
echo "You must be the superuser to run this script" >&2
exit 1
fi
With this code, if the output of the id -u command is not equal to "0", then the script prints a descriptive error
message, exits, and sets the exit status to 1, indicating to the operating system that the script executed
unsuccessfully.
Notice the ">&2" at the end of the echo command. This is another form of I/O direction. You will often notice
this in routines that display error messages. If this redirection were not done, the error message would go to
standard output. With this redirection, the message is sent to standard error. Since we are executing our script
and redirecting its standard output to a file, we want the error messages separated from the normal output.
We could put this routine near the beginning of our script so it has a chance to detect a possible error before
things get under way, but in order to run this script as an ordinary user, we will use the same idea and modify
the home_spacefunction to test for proper privileges instead, like so:
function home_space
# Only the superuser can get this information
if [ "$(id -u)" = "0" ]; then
echo "<pre>"
echo "</pre>"
fi
} # end of home_space
This way, if an ordinary user runs the script, the troublesome code will be passed over, rather than executed and
the problem will be solved.
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Stay Out Of Trouble
by William Shotts, Jr.
Now that our scripts are getting a little more complicated, I want to point out some common mistakes that you
might run into. To do this, create the following script called trouble.bash. Be sure to enter it exactly as written.
#!/bin/bash
number=1
if [ $number = "1" ]; then
echo "Number equals 1"
else
echo "Number does not equal 1"
fi
When you run this script, it should output the line "Number equals 1" because, well, number equals 1. If you
don't get the expected output, check your typing; you made a mistake.
Empty variables
Edit the script to change line 3 from:
number=1
to:
number=
and run the script again. This time you should get the following:
[me@linuxbox me]$ ./trouble.bash
/trouble.bash: [: =: unary operator expected.
Number does not equal 1
As you can see, bashdisplayed an error message when we ran the script. You probably think that by removing
the "1" on line 3 it created a syntax error on line 3, but it didn't. Let's look at the error message again:
./trouble.bash: [: =: unary operator expected
We can see that ./trouble.bash is reporting the error and the error has to do with "[". Remember that "[" is an
abbreviation for the test shell builtin. From this we can determine that the error is occurring on line 5 not line 3.
First, let me say there is nothing wrong with line 3. number= is perfectly good syntax. You will sometimes want
to set a variable's value to nothing. You can confirm the validity of this by trying it on the command line:
[me@linuxbox me]$ number=
[me@linuxbox me]$
See, no error message. So what's wrong with line 5? It worked before.
To understand this error, we have to see what the shell sees. Remember that the shell spends a lot of its life
substituting text. In line 5, the shell substitutes the value of number where it sees $number. In our first try
(when number=1), the shell substituted 1 for $number like so:
if [ 1 = "1" ]; then
However, when we set number to nothing (number=), the shell saw this after the substitution:
if [ = "1" ]; then
which is an error. It also explains the rest of the error message we received. The "=" is a binary operator; that is,
it expects two items to operate upon - one on each side. What the shell was trying to tell us was that there was
only one item and there should have been a unary operator (like "!") that only operates on a single item.
To fix this problem, change line 5 to read:
if [ "$number" = "1" ]; then
Now when the shell performs the substitution it will see:
if [ "" = "1" ]; then
which correctly expresses our intent.
This brings up an important thing to remember when you are writing your scripts. Consider what happens if a
variable is set to equal nothing.
Missing quotes
Edit line 6 to remove the trailing quote from the end of the line:
echo "Number equals 1
and run the script again. You should get this:
./trouble.bash: line 8: unexpected EOF while looking for matching "
./trouble.bash: line 10 systax error: unexpected end of file
Here we have another case of a mistake in one line causing a problem later in the script. What happens is the
shell keeps looking for the closing quotation mark to tell it where the end of the string is, but runs into the end
of the file before it finds it.
These errors can be a real pain to find in a long script. This is one reason you should test your scripts frequently
when you are writing them so there is less new code to test. I also find that text editors with syntax highlighting
(like nedit or kate) make these kinds of bugs easier to find.
Isolating problems
Finding bugs in your programs can sometimes be very difficult and frustrating. Here are a couple of techniques
that you will find useful:
Isolate blocks of code by "commenting them out." This trick involves putting comment characters at the
beginning of lines of code to stop the shell from reading them. Frequently, you will do this to a block of code to
see if a particular problem goes away. By doing this, you can isolate which part of a program is causing (or not
causing) a problem.
For example, when we were looking for our missing quotation we could have done this:
#!/bin/bash
number=1
echo "Number equals 1
#else
# echo "Number does not equal 1"
fi
By commenting out the elseclause and running the script, we could show that the problem was not in the else
clause even though the error message suggested that it was.
Use echo commands to verify your assumptions. As you gain experience tracking down bugs, you will discover
that bugs are often not where you first expect to find them. A common problem will be that you will make a
false assumption about the performance of your program. You will see a problem develop at a certain point in
your program and assume that the problem is there. This is often incorrect, as we have seen. To combat this,
you should place echo commands in your code while you are debugging, to produce messages that confirm the
program is doing what is expected. There are two kinds of messages that you should insert.
The first type simply announces that you have reached a certain point in the program. We saw this in our earlier
discussion on stubbing. It is useful to know that program flow is happening the way we expect.
The second type displays the value of a variable (or variables) used in a calculation or test. You will often find
that a portion of your program will fail because something that you assumed was correct earlier in your program
is, in fact, incorrect and is causing your program to fail later on.
Watching your script run
It is possible to have bash show you what it is doing when you run your script. To do this, add a "-x" to the first
line of your script, like this:
#!/bin/bash -x
Now, when you run your script, bash will display each line (with substitutions performed) as it executes it. This
technique is calledtracing. Here is what it looks like:
+ number=1
+ '[' 1 = 1 ']'
+ echo 'Number equals 1'
Number equals 1
Alternately, you can use the set command within your script to turn tracing on and off. Use set -x to turn tracing
on and set +x to turn tracing off. For example.:
#!/bin/bash
number=1
set -x
echo "Number equals 1"
else
echo "Number does not equal 1"
fi
set +x
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Keyboard Input and Arithmetic
Up to now, our scripts have not been interactive. That is, they did not require any input from the user. In this
lesson, we will see how your scripts can ask questions, and get and use responses.
read
To get input from the keyboard, you use the read command. The read command takes input from the keyboard
and assigns it to a variable. Here is an example:
#!/bin/bash
echo -n "Enter some text > "
read text
echo "You entered: $text"
As you can see, we displayed a prompt on line 3. Note that "-n" given to the echo command causes it to keep
the cursor on the same line; i.e., it does not output a carriage return at the end of the prompt.
Next, we invoke the readcommand with "text" as its argument. What this does is wait for the user to type
something followed by a carriage return (the Enter key) and then assign whatever was typed to the variabletext.
Here is the script in action:
[me@linuxbox me]$ read_demo.bash
Enter some text > this is some text
You entered: this is some text

If you don't give the readcommand the name of a variable to assign its input, it will use the environment
variableREPLY.
The read command also takes some command line options. The two most interesting ones are -t and -s. The -t
option followed by a number of seconds provides an automatic timeout for the read command. This means that
theread command will give up after the specified number of seconds if no response has been received from the
user. This option could be used in the case of a script that must continue (perhaps resorting to a default
response) even if the user does not answer the prompts. Here is the -t option in action:
#!/bin/bash
echo -n "Hurry up and type something! > "
if read -t 3 response; then
echo "Great, you made it in time!"
else
echo "Sorry, you are too slow!"
fi
The -s option causes the user's typing not to be displayed. This is useful when you are asking the user to type in
a password or other security related information.
Arithmetic
Since we are working on a computer, it is natural to expect that it can perform some simple arithmetic. The shell
provides features forinteger arithmetic.
What's an integer? That means whole numbers like 1, 2, 458, -2859. It does not mean fractional numbers like
0.5, .333, or 3.1415. If you must deal with fractional numbers, there is a separate program called bc which
provides an arbitrary precision calculator language. It can be used in shell scripts, but is beyond the scope of this
tutorial.
Let's say you want to use the command line as a primitive calculator. You can do it like this:
[me@linuxbox me]$ echo $((2+2))
As you can see, when you surround an arithmetic expression with the double parentheses, the shell will perform
arithmetic evaluation.
Notice that whitespace is not very important:
[me@linuxbox me]$ echo $((2+2))
4
[me@linuxbox me]$ echo $(( 2+2 ))
[me@linuxbox me]$ echo $(( 2 + 2 ))
The shell can perform a variety of common (and not so common) arithmetic operations. Here is an example:
#!/bin/bash
first_num=0
second_num=0
echo -n "Enter the first number --> "
read first_num
echo -n "Enter the second number -> "
read second_num
echo "first number + second number = $((first_num + second_num))"
echo "first number - second number = $((first_num - second_num))"
echo "first number * second number = $((first_num * second_num))"
echo "first number / second number = $((first_num / second_num))"
echo "first number % second number = $((first_num % second_num))"
echo "first number raised to the"
echo "power of the second number = $((first_num ** second_num))"
Notice how the leading "$" is not needed to reference variables inside the arithmetic expression such as
"first_num + second_num".
Try this program out and watch how it handles division (remember this is integer division) and how it handles
large numbers. Numbers that get too large overflow like the odometer in a car when you exceed the number of
miles it was designed to count. It starts over but first it goes through all the negative numbers because of how
integers are represented in memory. Division by zero (which is mathematically invalid) does cause an error.
I'm sure that you recognize the first four operations as addition, subtraction, multiplication and division, but that
the fifth one may be unfamiliar. The "%" symbol represents remainder (also known as modulo). This operation
performs division but instead of returning a quotient like division, it returns the remainder. While this might not
seem very useful, it does, in fact, provide great utility when writing programs. For example, when a remainder
operation returns zero, it indicates that the first number is an exact multiple of the second. This can be very
handy:
#!/bin/bash
number=0
echo -n "Enter a number > "
read number
echo "Number is $number"
if [ $((number % 2)) -eq 0 ]; then
echo "Number is even"
else
echo "Number is odd"
fi
Or, in this program that formats an arbitrary number of seconds into hours and minutes:
#!/bin/bash
seconds=0
echo -n "Enter number of seconds > "
read seconds
hours=$((seconds / 3600))
seconds=$((seconds % 3600))
minutes=$((seconds / 60))
seconds=$((seconds % 60))
echo "$hours hour(s) $minutes minute(s) $seconds second(s)"
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Hold on to your hats. This lesson is going to be a big one!
More branching
In the previous lesson on flow control we learned about the if command and how it is used to alter program flow
based on a condition. In programming terms, this type of program flow is calledbranching because it is like
traversing a tree. You come to a fork in the tree and the evaluation of a condition determines which branch you
take.
There is a second and more complex kind of branching called a case. A case is multiple-choice branch. Unlike the
simple branch, where you take one of two possible paths, a case supports several possible outcomes based on
the evaluation of a condition.
You can construct this type of branch with multiple if statements. In the example below, we evaluate some input
from the user:
#!/bin/bash
echo -n "Enter a number between 1 and 3 inclusive > "
read character
if [ "$character" = "1" ]; then
echo "You entered one."
else
echo "You entered two."
else
echo "You entered three."
else
echo "You did not enter a number"
echo "between 1 and 3."
fi
fi
fi
Not very pretty.
Fortunately, the shell provides a more elegant solution to this problem. It provides a built-in command called
case, which can be used to construct an equivalent program:
#!/bin/bash
echo -n "Enter a number between 1 and 3 inclusive > "
read character
case $character in
1 ) echo "You entered one."
;;
2 ) echo "You entered two."
;;
3 ) echo "You entered three."
;;
* ) echo "You did not enter a number"
echo "between 1 and 3."
esac
The case command has the following form:
case word in
patterns ) statements ;;
esac
case selectively executes statements if word matches a pattern. You can have any number of patterns and
statements. Patterns can be literal text or wildcards. You can have multiple patterns separated by the "|"
character. Here is a more advanced example to show what I mean:
#!/bin/bash
echo -n "Type a digit or a letter > "
read character
case $character in
# Check for letters
[a-z] | [A-Z] ) echo "You typed the letter $character"
;;
# Check for digits
[0-9] ) echo "You typed the digit $character"
;;
# Check for anything else
*) echo "You did not type a letter or a digit"
esac
Notice the special pattern "*". This pattern will match anything, so it is used to catch cases that did not match
previous patterns. Inclusion of this pattern at the end is wise, as it can be used to detect invalid input.
Loops
The final type of program flow control we will discuss is called looping. Looping is repeatedly executing a section
of your program based on a condition. The shell provides three commands for looping: while,until and for. We
are going to cover while and untilin this lesson and for in a future lesson.
The while command causes a block of code to be executed over and over, as long as a condition is true. Here is a
simple example of a program that counts from zero to nine:
#!/bin/bash
number=0
while [ $number -lt 10 ]; do
echo "Number = $number"
number=$((number + 1))
done
On line 3, we create a variable callednumber and initialize its value to 0. Next, we start the whileloop. As you can
see, we have specified a condition that tests the value of number. In our example, we test to see if number has a
value less than 10.
Notice the word do on line 4 and the word done on line 7. These enclose the block of code that will be repeated
as long as the condition is met.
In most cases, the block of code that repeats must do something that will eventually change the outcome of the
condition, otherwise you will have what is called an endless loop; that is, a loop that never ends.
In the example, the repeating block of code outputs the value of number (the echo command on line 5) and
increments number by one on line 6. Each time the block of code is completed, the condition is tested again.
After the tenth iteration of the loop, number has been incremented ten times and the condition is no longer
true. At that point, the program flow resumes with the statement following the word done. Sincedone is the last
line of our example, the program ends.
The until command works exactly the same way, except the block of code is repeated as long as the condition is
false. In the example below, notice how the condition has been changed from the whileexample to achieve the
same result:
#!/bin/bash
number=0
until [ $number -ge 10 ]; do
echo "Number = $number"
number=$((number + 1))
done
Building a menu
One common way of presenting a user interface for a text based program is by using a menu. A menu is a list of
choices from which the user can pick.
In the example below, we use our new knowledge of loops and cases to build a simple menu driven application:
#!/bin/bash
selection=
until [ "$selection" = "0" ]; do
echo ""
echo "PROGRAM MENU"
echo "1 - display free disk space"
echo "2 - display free memory"
echo ""
echo "0 - exit program"
echo ""
echo -n "Enter selection: "
read selection
echo ""
case $selection in
1 ) df ;;
2 ) free ;;
0 ) exit ;;
* ) echo "Please enter 1, 2, or 0"
esac
done
The purpose of the untilloop in this program is to re-display the menu each time a selection has been
completed. The loop will continue until selection is equal to "0," the "exit" choice. Notice how we defend against
entries from the user that are not valid choices.
To make this program better looking when it runs, we can enhance it by adding a function that asks the user to
press the Enter key after each selection has been completed, and clears the screen before the menu is displayed
again. Here is the enhanced example:
#!/bin/bash
function press_enter
echo ""
echo -n "Press Enter to continue"

read
clear
selection=
until [ "$selection" = "0" ]; do
echo ""
echo "PROGRAM MENU"
echo "1 - display free disk space"
echo "2 - display free memory"
echo ""
echo "0 - exit program"
echo ""
echo -n "Enter selection: "
read selection
echo ""
case $selection in
1 ) df ; press_enter ;;
2 ) free ; press_enter ;;
0 ) exit ;;
* ) echo "Please enter 1, 2, or 0"; press_enter
esac
done
When your computer hangs...

We have all had the experience of an application (or in the case of legacy systems, the entire computer) hanging.
Hanging is when a program suddenly seems to stop and become unresponsive. While you might think that the
program has stopped, in most cases, the program is still running but its program logic is stuck in an endless loop.
Imagine this situation: you have an external device attached to your computer, such as a USB disk drive but you
forgot to turn it on. You try and use the device but the application hangs instead. When this happens, you could
picture the following dialog going on between the application and the interface for the device:
Application: Are you ready?
Interface: Device not ready.
and so on, forever.
Well-written software tries to avoid this situation by instituting a timeout. This means that the loop is also
counting the number of attempts or calculating the amount of time it has waited for something to happen. If the
number of tries or the amount of time allowed is exceeded, the loop exits and the program generates an error
and exits.
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Positional Parameters
When we last left our script, it looked something like this:
#!/bin/bash
##### Constants
##### Functions

} # end of system_info
echo "<pre>"
uptime
echo "</pre>"
} # end of show_uptime
echo "<pre>"
df
echo "</pre>"
} # end of drive_space
function home_space

if [ "$(id -u)" = "0" ]; then
echo "<pre>"
echo "</pre>"
fi
##### Main
cat <<- _EOF_
<html>
<head>
</head>
<body>
<h1>$TITLE</h1>
<p>$TIME_STAMP</p>
$(system_info)
$(show_uptime)
$(drive_space)
$(home_space)
</body>
</html>
_EOF_
We have most things working, but there are several more features I want to add:
1. I want to specify the name of the output file on the command line, as well as set a default output file
name if no name is specified.
2. I want to offer an interactive mode that will prompt for a file name and warn the user if the file exists
and prompt the user to overwrite it.
3. Naturally, we want to have a help option that will display a usage message.
All of these features involve using command line options and arguments. To handle options on the command
line, we use a facility in the shell called positional parameters. Positional parameters are a series of special
variables ($0 through $9) that contain the contents of the command line.
Let's imagine the following command line:
[me@linuxbox me]$some_program word1 word2 word3
If some_program were a bash shell script, we could read each item on the command line because the positional
parameters contain the following:
• $0 would contain "some_program"
• $1 would contain "word1"
Here is a script you can use to try this out:
#!/bin/bash
echo "Positional Parameters"
echo '$0 = ' $0
echo '$1 = ' $1
echo '$2 = ' $2
echo '$3 = ' $3

Detecting command line arguments
Often, you will want to check to see if you have arguments on which to act. There are a couple of ways to do
this. First, you could simply check to see if $1 contains anything like so:
#!/bin/bash
if [ "$1" != "" ]; then
echo "Positional parameter 1 contains something"
else
echo "Positional parameter 1 is empty"
fi
Second, the shell maintains a variable called$# that contains the number of items on the command line in
addition to the name of the command ($0).
#!/bin/bash
if [ $# -gt 0 ]; then
echo "Your command line contains $# arguments"
else
echo "Your command line contains no arguments"
fi
Command line options
As we discussed before, many programs, particularly ones from the GNU Project, support both short and long
command line options. For example, to display a help message for many of these programs, you may use either
the "-h" option or the longer "--help" option. Long option names are typically preceded by a double dash. We
will adopt this convention for our scripts.
Here is the code we will use to process our command line:
interactive=
filename=~/system_page.html
while [ "$1" != "" ]; do
case $1 in
-f | --file ) shift
filename=$1
;;
-i | --interactive ) interactive=1
;;
-h | --help ) usage
exit
;;
*) usage
exit 1
esac
shift
done
This code is a little tricky, so bear with me as I attempt to explain it.
The first two lines are pretty easy. We set the variable interactive to be empty. This will indicate that the
interactive mode has not been requested. Then we set the variablefilename to contain a default file name. If
nothing else is specified on the command line, this file name will be used.
After these two variables are set, we have default settings, in case the user does not specify any options.
Next, we construct a whileloop that will cycle through all the items on the command line and process each one
with case. The case will detect each possible option and process it accordingly.
Now the tricky part. How does that loop work? It relies on the magic of shift.
shift is a shell builtin that operates on the positional parameters. Each time you invoke shift, it "shifts" all the
positional parameters down by one. $2 becomes $1, $3becomes $2, $4 becomes$3, and so on. Try this:
#!/bin/bash
echo "You start with $# positional parameters"
# Loop until all parameters are used up
while [ "$1" != "" ]; do
echo "Parameter 1 equals $1"
echo "You now have $# positional parameters"
# Shift all the parameters down by one
shift
done
Getting an option's argument
Our "-f" option takes a required argument, a valid file name. We use shift again to get the next item from the
command line and assign it tofilename. Later we will have to check the content of filename to make sure it is
valid.
Integrating the command line processor into the script
We will have to move a few things around and add a usage function to get this new routine integrated into our
script. We'll also add some test code to verify that the command line processor is working correctly. Our script
now looks like this:
#!/bin/bash
##### Constants

##### Functions
echo "<pre>"
uptime
echo "</pre>"
} # end of show_uptime
echo "<pre>"
df
echo "</pre>"
} # end of drive_space
function home_space
if [ "$(id -u)" = "0" ]; then
echo "<pre>"
echo "</pre>"
fi
function write_page
cat <<- _EOF_
<html>
<head>
</head>
<body>
<h1>$TITLE</h1>
<p>$TIME_STAMP</p>
$(system_info)
$(show_uptime)
$(drive_space)
$(home_space)
</body>
</html>
_EOF_
function usage
echo "usage: system_page [[[-f file ] [-i]] | [-h]]"
##### Main
interactive=
filename=~/system_page.html
while [ "$1" != "" ]; do
case $1 in
-f | --file ) shift
filename=$1
;;
-i | --interactive ) interactive=1
;;
-h | --help ) usage
exit
;;
*) usage
exit 1
esac
shift
done
# Test code to verify command line processing
if [ "$interactive" = "1" ]; then
echo "interactive is on"
else
echo "interactive is off"
fi
echo "output file = $filename"
# Write page (comment out until testing is complete)
# write_page > $filename

Adding interactive mode
The interactive mode is implemented with the following code:
if [ "$interactive" = "1" ]; then
response=
echo -n "Enter name of output file [$filename] > "
read response
if [ -n "$response" ]; then
filename=$response
fi
if [ -f $filename ]; then
echo -n "Output file exists. Overwrite? (y/n) > "
read response
if [ "$response" != "y" ]; then
echo "Exiting program."
exit 1
fi
fi
fi
First, we check if the interactive mode is on, otherwise we don't have anything to do. Next, we ask the user for
the file name. Notice the way the prompt is worded:
echo -n "Enter name of output file [$filename] > "

We display the current value of filenamesince, the way this routine is coded, if the user just presses the enter
key, the default value offilename will be used. This is accomplished in the next two lines where the value of
response is checked. Ifresponse is not empty, thenfilename is assigned the value ofresponse. Otherwise,
filename is left unchanged, preserving its default value.
After we have the name of the output file, we check if it already exists. If it does, we prompt the user. If the user
response is not "y," we give up and exit, otherwise we can proceed.
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Now that you have learned about positional parameters, it is time to cover the remaining flow control
statement, for. Likewhile and until, for is used to construct loops. forworks like this:
for variable in words; do
statements
done
In essence, for assigns a word from the list of words to the specified variable, executes the statements, and
repeats this over and over until all the words have been used up. Here is an example:
#!/bin/bash
for i in word1 word2 word3; do
echo $i
done
In this example, the variable i is assigned the string "word1", then the statement echo $i is executed, then the
variable i is assigned the string "word2", and the statement echo $iis executed, and so on, until all the words in
the list of words have been assigned.
The interesting thing about for is the many ways you can construct the list of words. All kinds of substitutions
can be used. In the next example, we will construct the list of words from a command:
#!/bin/bash
count=0
for i in $(cat ~/.bash_profile); do
count=$((count + 1))
echo "Word $count ($i) contains $(echo -n $i | wc -c) characters"
done
Here we take the file .bash_profile and count the number of words in the file and the number of characters in
each word.
So what's this got to do with positional parameters? Well, one of the features of for is that it can use the
positional parameters as the list of words:
#!/bin/bash
for i in $@; do
echo $i
done
The shell variable $@ contains the list of command line arguments. This technique is a very common approach
to processing a list of files on the command line. Here is a another example:
#!/bin/bash
for filename in $@; do
result=
if [ -f $filename ]; then
result="$filename is a regular file"
else
if [ -d $filename ]; then
result="$filename is a directory"
fi
fi
if [ -w $filename ]; then
result="$result and it is writable"
else
result="$result and it is not writable"
fi
echo "$result"
done
Try this script. Give it a list of files or a wildcard like "*" to see it work.
Here is another example script. This one compares the files in two directories and lists which files in the first
directory are missing from the second.
#!/bin/bash
# cmp_dir - program to compare two directories
# Check for required arguments

if [ $# -ne 2 ]; then
echo "usage: $0 directory_1 directory_2" 1>&2
exit 1
fi
# Make sure both arguments are directories
if [ ! -d $1 ]; then
echo "$1 is not a directory!" 1>&2
exit 1
fi
if [ ! -d $2 ]; then
echo "$2 is not a directory!" 1>&2
exit 1
fi
# Process each file in directory_1, comparing it to directory_2
missing=0
for filename in $1/*; do
fn=$(basename "$filename")
if [ -f "$filename" ]; then
if [ ! -f "$2/$fn" ]; then
echo "$fn is missing from $2"
missing=$((missing + 1))
fi
fi
done
echo "$missing files missing"
Now on to the real work. We are going to improve the home_space function in our script to output more
information. You will recall that our previous version looked like this:
function home_space
if [ "$(id -u)" = "0" ]; then
echo "<pre>"
echo "</pre>"
fi
Here is the new version:
function home_space
echo "<pre>"
format="%8s%10s%10s %-s\n"
printf "$format" "Dirs" "Files" "Blocks" "Directory"
printf "$format" "----" "-----" "------" "---------"
if [ $(id -u) = "0" ]; then
dir_list="/home/*"
else
dir_list=$HOME
fi
for home_dir in $dir_list; do
total_dirs=$(find $home_dir -type d | wc -l)
total_files=$(find $home_dir -type f | wc -l)
total_blocks=$(du -s $home_dir)
printf "$format" $total_dirs $total_files $total_blocks
done
echo "</pre>"
This improved version introduces a new commandprintf, which is used to produce formatted output according
to the contents of a format string. printf comes from the C programming language and has been implemented in
many other programming languages including C++, perl, awk, java, PHP, and of course, bash. You can read more
about printf format strings at:
• GNU Awk User's Guide - Control Letters
• GNU Awk User's Guide - Format Modifiers
We also introduce the find command. find is used to search for files or directories that meet specific criteria. In
thehome_space function, we use find to list the directories and regular files in each home directory. Using the
wc command, we count the number of files and directories found.
The really interesting thing abouthome_space is how we deal with the problem of superuser access. You will
notice that we test for the superuser with id and, according to the outcome of the test, we assign different
strings to the variabledir_list, which becomes the list of words for the for loop that follows. This way, if an
ordinary user runs the script, only his/her home directory will be listed.
Another function that can use a for loop is our unfinishedsystem_info function. We can build it like this:
# Find any release files in /etc
if ls /etc/*release 1>/dev/null 2>&1; then

echo "<pre>"
for i in /etc/*release; do
# Since we can't be sure of the
# length of the file, only
# display the first line.
head -n 1 $i
done
uname -orp
echo "</pre>"
fi
In this function, we first determine if there are any release files to process. The release files contain the name of
the vendor and the version of the distribution. They are located in the/etc directory. To detect them, we
perform an ls command and throw away all of its output. We are only interested in the exit status. It will be true
if any files are found.
Next, we output the HTML for this section of the page, since we now know that there are release files to
process. To process the files, we start a for loop to act on each one. Inside the loop, we use the head command
to return the first line of each file.
Finally, we use the uname command with the "o", "r", and "p" options to obtain some additional information
from the system.
________________________________________

• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Errors and Signals and Traps (Oh My!) - Part 1
In this lesson, we're going to look at handling errors during the execution of your scripts.
The difference between a good program and a poor one is often measured in terms of the program's
robustness. That is, the program's ability to handle situations in which something goes wrong.
Exit status
As you recall from previous lessons, every well-written program returns an exit status when it finishes. If a
program finishes successfully, the exit status will be zero. If the exit status is anything other than zero, then the
program failed in some way.
It is very important to check the exit status of programs you call in your scripts. It is also important that your
scripts return a meaningful exit status when they finish. I once had a Unix system administrator who wrote a
script for a production system containing the following 2 lines of code:
# Example of a really bad idea
cd $some_directory
rm *
Why is this such a bad way of doing it? It's not, if nothing goes wrong. The two lines change the working
directory to the name contained in $some_directory and delete the files in that directory. That's the intended
behavior. But what happens if the directory named in$some_directory doesn't exist? In that case, the
cdcommand will fail and the script executes the rm command on the current working directory. Not the
intended behavior!
By the way, my hapless system administrator's script suffered this very failure and it destroyed a large portion of
an important production system. Don't let this happen to you!
The problem with the script was that it did not check the exit status of the cd command before proceeding with
therm command.
Checking the exit status
There are several ways you can get and respond to the exit status of a program. First, you can examine the
contents of the $?environment variable. $? will contain the exit status of the last command executed. You can
see this work with the following:
[me] $ true; echo $?
[me] $ false; echo $?
The true and false commands are programs that do nothing except return an exit status of zero and one,
respectively. Using them, we can see how the $? environment variable contains the exit status of the previous
program.
So to check the exit status, we could write the script this way:
# Check the exit status
cd $some_directory
if [ "$?" = "0" ]; then
rm *
else
echo "Cannot change directory!" 1>&2
exit 1
fi
In this version, we examine the exit status of the cd command and if it's not zero, we print an error message on
standard error and terminate the script with an exit status of 1.
While this is a working solution to the problem, there are more clever methods that will save us some typing.
The next approach we can try is to use the if statement directly, since it evaluates the exit status of commands it
is given.
Using if, we could write it this way:
# A better way
if cd $some_directory; then
rm *
else
echo "Could not change directory! Aborting." 1>&2
exit 1
fi
Here we check to see if the cd command is successful. Only then does rm get executed; otherwise an error
message is output and the program exits with a code of 1, indicating that an error has occurred.
An error exit function
Since we will be checking for errors often in our programs, it makes sense to write a function that will display
error messages. This will save more typing and promote laziness.
# An error exit function
function error_exit
echo "$1" 1>&2
exit 1
# Using error_exit
if cd $some_directory; then
rm *
else
error_exit "Cannot change directory! Aborting."
fi
AND and OR lists
Finally, we can further simplify our script by using the AND and OR control operators. To explain how they work,
I will quote from the bash man page:
"The control operators && and || denote AND lists and OR lists, respectively. An AND list has the form
command1 && command2
command2 is executed if, and only if, command1returns an exit status of zero.
An OR list has the form
command1 || command2
command2 is executed if, and only if, command1returns a non-zero exit status. The return status of AND and OR
lists is the exit status of the last command executed in the list."
Again, we can use the true and false commands to see this work:
[me] $ true || echo "echo executed"
[me] $ false || echo "echo executed"
echo executed
[me] $ true && echo "echo executed"
echo executed
[me] $ false && echo "echo executed"
[me] $
Using this technique, we can write an even simpler version:
# Simplest of all
cd $some_directory || error_exit "Cannot change directory! Aborting"
rm *
If an exit is not required in case of error, then you can even do this:
# Another way to do it if exiting is not desired

cd $some_directory && rm *
I want to point out that even with the defense against errors we have introduced in our example for the use of
cd, this code is still vulnerable to a common programming error, namely, what happens if the name of the
variable containing the name of the directory is misspelled? In that case, the shell will interpret the variable as
empty and the cd succeed, but it will change directories to the user's home directory, so beware!
Improving the error exit function
There are a number of improvements that we can make to theerror_exit function. I like to include the name of
the program in the error message to make clear where the error is coming from. This becomes more important
as your programs get more complex and you start having scripts launching other scripts, etc. Also, note the
inclusion of the LINENO environment variable which will help you identify the exact line within your script where
the error occurred.
#!/bin/bash
# A slicker error handling routine
# I put a variable in my scripts named PROGNAME which
# holds the name of the program being run. You can get this
# value from the first item on the command line ($0).
PROGNAME=$(basename $0)
function error_exit
# ----------------------------------------------------------------
# Function for exit due to fatal program error
# Accepts 1 argument:
# string containing descriptive error message
# ----------------------------------------------------------------
echo "${PROGNAME}: ${1:-"Unknown Error"}" 1>&2
exit 1
# Example call of the error_exit function. Note the inclusion
# of the LINENO environment variable. It contains the current
# line number.
echo "Example of error with line number and message"
error_exit "$LINENO: An error has occurred."
The use of the curly braces within the error_exit function is an example of parameter expansion. You can
surround a variable name with curly braces (as with ${PROGNAME}) if you need to be sure it is separated from
surrounding text. Some people just put them around every variable out of habit. That usage is simply a style
thing. The second use,${1:-"Unknown Error"} means that if parameter 1 ($1) is undefined, substitute the string
"Unknown Error" in its place. Using parameter expansion, it is possible to perform a number of useful string
manipulations. You can read more about parameter expansion in the bash man page under the topic
"EXPANSIONS".
________________________________________
• LinuxCommand
• Script library
• SuperMan pages
________________________________________
Errors and Signals and Traps (Oh, My!) - Part 2
Errors are not the only way that a script can terminate unexpectedly. You also have to be concerned with
signals. Consider the following program:
#!/bin/bash
echo "this script will endlessly loop until you stop it"
while true; do
: # Do nothing
done
After you launch this script it will appear to hang. Actually, like most programs that appear to hang, it is really
stuck inside a loop. In this case, it is waiting for the true command to return a non-zero exit status, which it
never does. Once started, the script will continue until bash receives a signal that will stop it. You can send such
a signal by typing ctrl-c which is the signal called SIGINT (short for SIGnal INTerrupt).
Cleaning up after yourself
OK, so a signal can come along and make your script terminate. Why does it matter? Well, in many cases it
doesn't matter and you can ignore signals, but in some cases it will matter.
Let's take a look at another script:
#!/bin/bash
# Program to print a text file with headers and footers
TEMP_FILE=/tmp/printfile.txt
pr $1 > $TEMP_FILE
echo -n "Print file? [y/n]: "
read
if [ "$REPLY" = "y" ]; then
lpr $TEMP_FILE
fi
This script processes a text file specified on the command line with the prcommand and stores the result in a
temporary file. Next, it asks the user if they want to print the file. If the user types "y", then the temporary file is
passed to the lpr program for printing (you may substitute less for lpr if you don't actually have a printer
attached to your system.)
Now, I admit this script has a lot of design problems. While it needs a file name passed on the command line, it
doesn't check that it got one, and it doesn't check that the file actually exists. But the problem I want to focus on
here is the fact that when the script terminates, it leaves behind the temporary file.
Good practice would dictate that we delete the temporary file $TEMP_FILE when the script terminates. This is
easily accomplished by adding the following to the end of the script:
rm $TEMP_FILE
This would seem to solve the problem, but what happens if the user types ctrl-c when the "Print file? [y/n]:"
prompt appears? The script will terminate at the read command and the rm command is never executed.
Clearly, we need a way to respond to signals such as SIGINT when the ctrl-c key is typed.
Fortunately, bash provides a method to perform commands if and when signals are received.
trap
The trap command allows you to execute a command when a signal is received by your script. It works like this:
trap arg signals
"signals" is a list of signals to intercept and "arg" is a command to execute when one of the signals is received.
For our printing script, we might handle the signal problem this way:
#!/bin/bash
trap "rm $TEMP_FILE; exit" SIGHUP SIGINT SIGTERM
pr $1 > $TEMP_FILE
read
lpr $TEMP_FILE
fi
rm $TEMP_FILE
Here we have added a trap command that will execute "rm $TEMP_FILE" if any of the listed signals is received.
The three signals listed are the most common ones that you will encounter, but there are many more that can
be specified. For a complete list, type "trap -l". In addition to listing the signals by name, you may alternately
specify them by number.
Signal 9 From Outer Space
There is one signal that you cannot trap: SIGKILL or signal 9. The kernel immediately terminates any process sent
this signal and no signal handling is performed. Since it will always terminate a program that is stuck, hung, or
otherwise screwed up, it is tempting to think that it's the easy way out when you have to get something to stop
and go away. Often you will see references to the following command which sends the SIGKILL signal:
kill -9
However, despite its apparent ease, you must remember that when you send this signal, no processing is done
by the application. Often this is OK, but with many programs it's not. In particular, many complex programs (and
some not-so-complex) create lock files to prevent multiple copies of the program from running at the same
time. When a program that uses a lock file is sent a SIGKILL, it doesn't get the chance to remove the lock file
when it terminates. The presence of the lock file will prevent the program from restarting until the lock file is
manually removed.
Be warned. Use SIGKILL as a last resort.
A clean_up function
While the trap command has solved the problem, we can see that it has some limitations. Most importantly, it
will only accept a single string containing the command to be performed when the signal is received. You could
get clever and use ";" and put multiple commands in the string to get more complex behavior, but frankly, it's
ugly. A better way would be to create a function that is called when you want to perform any actions at the end
of your script. In my scripts, I call this function clean_up.
#!/bin/bash
function clean_up {
# Perform program exit housekeeping
rm $TEMP_FILE
exit
trap clean_up SIGHUP SIGINT SIGTERM
pr $1 > $TEMP_FILE
read
lpr $TEMP_FILE
fi
clean_up
The use of a clean up function is a good idea for your error handling routines too. After all, when your program
terminates (for whatever reason), you should clean up after yourself. Here is finished version of our program
with improved error and signal handling:
#!/bin/bash
# Usage: printfile file
# Create a temporary file name that gives preference
# to the user's local tmp directory and has a name
# that is resistant to "temp race attacks"
if [ -d "~/tmp" ]; then
TEMP_DIR=~/tmp
else
TEMP_DIR=/tmp
fi
TEMP_FILE=$TEMP_DIR/printfile.$$.$RANDOM
PROGNAME=$(basename $0)
function usage {
# Display usage message on standard error
echo "Usage: $PROGNAME file" 1>&2
function clean_up {
# Perform program exit housekeeping

# Optionally accepts an exit status
rm -f $TEMP_FILE
exit $1
function error_exit {
# Display error message and exit
echo "${PROGNAME}: ${1:-"Unknown Error"}" 1>&2
clean_up 1
trap clean_up SIGHUP SIGINT SIGTERM
if [ $# != "1" ]; then
usage
error_exit "one file to print must be specified"
fi
if [ ! -f "$1" ]; then
error_exit "file $1 cannot be read"
fi
pr $1 > $TEMP_FILE || error_exit "cannot format file"
read

lpr $TEMP_FILE || error_exit "cannot print file"
fi
clean_up
Creating safe temporary files
In the program above, there a number of steps taken to help secure the temporary file used by this script. It is a
Unix tradition to use a directory called /tmp to place temporary files used by programs. Everyone may write files
into this directory. This naturally leads to some security concerns. If possible, avoid writing files in the /tmp
directory. The preferred technique is to write them in a local directory such as ~/tmp (a tmp subdirectory in the
user's home directory.) If you must write files in/tmp, you must take steps to make sure the file names are not
predictable. Predictable file names allow an attacker to create symbolic links to other files that the attacker
wants you to overwrite.
A good file name will help you figure out what wrote the file, but will not be entirely predictable. In the script
above, the following line of code created the temporary file $TEMP_FILE:
TEMP_FILE=$TEMP_DIR/printfile.$$.$RANDOM
The $TEMP_DIR variable contains either /tmp or ~/tmp depending on the availability of the directory. It is
common practice to embed the name of the program into the file name. We have done that with the string
"printfile". Next, we use the $$ shell variable to embed the process id (pid) of the program. This further helps
identify what process is responsible for the file. Surprisingly, the process id alone is not unpredictable enough to
make the file safe, so we add the $RANDOM shell variable to append a random number to the file name. With
this technique, we create a file name that is both easily identifiable and unpredictable.
________________________________________

Linux Command

Uploaded by

Copyright:

Available Formats

Linux Command

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Linux Command

Uploaded by

Copyright:

Available Formats

Editing the scripts you already have

Commands, commands everywhere

alias l='ls -l'

alias today='date +"%A, %B %-d, %Y"'

[me@linuxbox me]$ alias l='ls -l'

echo "Today's date is:"

date +"%A, %B %-d, %Y"

[me@linuxbox me]$ function today {

> echo "Today's date is:"

> date +"%A, %B %-d, %Y"

[me@linuxbox me]$ type command

Previous | Contents | Top | Next

Linux® is a registered trademark of Linus Torvalds.

• Learning the shell

• Writing shell scripts

• Who, What, Where, Why

• Tips, News And Rants Previous | Contents | Next

Writing an HTML file with a script

The title of your page

Your page content goes here.

# make_page - A script to produce an HTML file

echo " <TITLE>"

echo " The title of your page"

echo " </TITLE>"

echo " Your page content goes here."

This script can be used as follows:

[me@linuxbox me]$ make_page > page.html

# make_page - A script to produce an HTML file

cat << _EOF_

The title of your page

Your page content goes here.

A here script is constructed like this:

command << token

content to be used as command's standard input

# make_page - A script to produce an HTML file

cat <<- _EOF_

The title of your page

# make_page - A script to produce an HTML file

cat <<- _EOF_

<H1>My System Information</H1>

Linux® is a registered trademark of Linus Torvalds.

• Learning the shell

• Writing shell scripts

• Who, What, Where, Why

• Tips, News And Rants Previous | Contents | Next

# make_page - A script to produce an HTML file

cat <<- _EOF_

<H1>My System Information</H1>

# make_page - A script to produce an HTML file

title="My System Information"

cat <<- _EOF_

[me@linuxbox me]$ echo *

How to create a variable

Where does the variable's name come from?

1. It must start with a letter.

2. It must not contain embedded spaces. Use underscores instead.

3. Don't use punctuation marks.

How does this increase our laziness?

# make_page - A script to produce an HTML file

title="System Information for"