Introduction
This book is about shell programming or to be more precise shell and Bourne

shell programming.

With LINUX now firmly taking its rightful place in the market as a viable and

robust operating system, shell programming has become even more popular. No-one

can say with any confidence how many LINUX users there are out there because

LINUX is free, though there is a growing number of third parties selling their

own LINUX variants. UNIX is still as popular as ever and growing despite a forecasted

demise by IT consultants a few years ago.

If you want to learn shell programming, then this is the book for you; even

if you are an intermediate shell user you will find the book a good learning

and reference tool as there are some handy administrative tips and one-liners

for you.

This book has been written from the outset with six main objectives in mind.

These are:
• Getting the reader up to speed quickly learning about shell tools and

shell programming.
• Using the book not only as a learning tool but also as a reference book.
• Using shell scripts to use your system more productively.
• Showing scripts that are clear and easily understandable.
• Making the chapters self-contained where possible for the subject covered,

for ease of use.
• Showing the reader not just shell scripting but also some administrative

tasks like rc.scripts and cgi scripts.

One of the annoying things about certain books on this topic was how some scripting

examples were made to look complicated just to save a few lines of extra code.

You won't find that sort of thing happening in this book: all the code in this

book is simple but effective.

If you're reading this, then you have probably already got your own reasons

for learning shell programming; great. If you want to know the main reasons

for learning shell programming they are:
• The shell is a programming language all on its own; it has iteration,

conditions and testing constructs and it's easy to use.
• You can create scripts quickly.
• You can automate boring manual tasks using scripts.

The Bourne shell
The Bourne shell is the standard shell shipped with all UNIX systems and is

linked into the LINUX bash shell. A book about shell programming that covers

all leading systems must cover the Bourne shell. There are other shells, mind

you, like bash, Korn, and the C shell. If you are familiar with the bash shell,

the scripts presented in this book will run on your system, because bash is

backward-compatible with Bourne. If you have the Korn shell, the syntax of the

shell is very close.

If you look at installation scripts you will find that over 95 per cent of them

are Bourne shell scripts. This is simply because the person who wrote the script

knows it will run on any UNIX or LINUX system.

Shell portability
When you write a script that you want to run on any system it has to be what

is called portable. Portability of scripts has two major issues:
• script syntax of the shell you are using;
• shell commands.

The first issue is practically already solved if you are going to program with

the Bourne shell: it has few or no portability problems.

Most shell scripts spend at least 20 per cent (or probably more) of their time

using shell commands such as cp, mv, mkdir etc. This is where the problems of

portability come in. Different system vendors have different command options

on their machines; coupled with this if you have UNIX then you are either a

SystemíV or BSD user. This book uses generic scripts and command examples.

I have only used options and commands that are common to both SystemíV

and BSD and in my opinion useful, throughout the book. Where there are slight

differences they are pointed out with an alternative command, but these are

few and far between.

Organization of the book
This book is organized as both a learning tool and a reference book, therefore

do not think that you have to read each chapter in sequential order. Feel free

to wander through the chapters or even start on the last chapter, if you want

to knock up some cgi-based HTML pages.

The book is split into five parts, and within those parts are chapters dealing

with different aspects of the shell and shell programming.

The book is full of complete working examples of scripts.

The shell
In Part 1 of this book we will cover the topics that show you how to list files

using patterns, and how to change directories quickly. When you create a file,

you want to make sure it has the right permissions and directories. This is

also covered. Coverage is also given to file operations such as umask and group

file ownerships.

To avoid endlessly searching for files you have created, a whole chapter is

devoted to the find command.

When your scripts are up and running you will at some point want to run them

during the night or late in the evening: you will discover how to do this in

the chapter dealing with running commands unattended.

The nitty-gritty of any shell is its ability to read commands into a file or

from a terminal and also display the output. This is also covered. You may want

to run certain commands only if the previous command succeeded -- no problem,

that's covered as well.

Text file filtering
Part 2 of the book covers all the major test filtering tools. Text filtering

includes all you need to know about filtering text before your scripts get hold

of the information, during the script execution and the output of the text.

Topics include awk, a language by itself; grep, a text file searching utility;

and sed, an in-line editor that lets you edit on the fly. We also cover sorting,

merging and pasting files and records. There is also a chapter on tr, the character

translation utility.

Login environment
Part 3 covers your login environment and how to customize it. Understand which

files are executed when you login. Learn all about local and global variables.

Uncover the mystery surrounding quoting, so you can use variables to their full

power.

Basic shell programming
Part 4 of the book is all about shell scripting. The basics are explained including

how to make a file executable and run it in the shell; different control constructs;

and how to test for different types of conditions and take action based on that

result. Once we have covered all the angles with working scripts we then look

at functions. Functions are pieces of reusable code, and we will see how to

use and share these functions between scripts.

Being able to pass arguments to a shell script is an important function. We

look at three different methods of using commands that are passed to scripts.

By now we are putting together competent scripts, so all that we need now is

some information on using colour and control characters -- guess what, we cover

that as well. No shell programming book should be without a file updating system,

and there's a whole chapter devoted to this subject in this book. We finish

off this part of the book looking at other built-in shell commands we have not

yet covered.

Better scripting skills
Is there really a subject such as better scripting skills? You bet there is.

That's what Part 5 of the book is all about. We look at the more advanced areas

of scripting, and we cover signals and traps, so your scripts can take action

if someone tries to kill them. We also look a bit more at here documents. What

are here documents, you might say? They let you give input into your scripts

or, to put it another way, the scripts get a touch of remote control.

Have you ever wondered how some programs get started automatically when a system

boots up? It's no secret; we will look at run levels and how to put an rc.script

together. If you follow the examples in this chapter you will have your own

scripts up and running when your machine boots up.

There's a chapter containing a small collection of smallish but favourite scripts,

which includes amongst others how to deny access to other users without touching

the /etc/passwd file. If you have ever wondered how to put html pages together,

send information to another page, or continuously refresh pages, we look at

cgi-bin scripting using not Perl but Bourne shell scripts.

There are also two appendices, AppendixíA which deals with the ASCII

chart, and AppendixíB which contains some useful shell commands commands.

Assumptions
I assume the person who is reading this book knows how to login into a shell,

change directories, and how to use a text editor.

If you want to try out the cgi scripts that are covered in Part 4, you should

really have a Web server installed and be able to run cgi scripts on your machine

(though this is not a 'must have' condition).

Conventions used in this book
Throughout this book the following conventions are used:
• CTRL-key
means hold the control key and the key specified. For instance CTRL-O means

hold down the control key as well as the letter O.
• This typeface
means a non-command example or text of special interest.
• This typeface
is used for all script listings.
• This typeface
is used for any command line or script input and output.

In the first two parts of the book, you will find text boxes that look like

this:
If it's LINUX thenÄ.Ä.Ä. These have been used to quickly point

out differences between the BSD/LINUX and SystemíV command that is currently

being described.

I have tested the scripts both on LINUX (Redhat) and on AIX, and some scripts

have also been tested on Data Generals.

I hope you enjoy the book, not only as a learning tool but also as a reference

tool. Enjoy and have fun. Stand-by to stand-to.

Any comments, or just to say hello, e-mail me at dtansley@my-Deja.

0201674726P04062001

With more and more systems being run under UNIX and Linux, the ability to program and customize the shell quickly and reliably to get the best out of any individual system is becoming a more and more important skill for anyone operating and maintaining these systems.

This comprehensive book is a practical, easy-to-use guide to programming and using the Bourne shell for beginners and experienced users - the Bourne shell is the standard shell for UNIX, and is also fully backward compatible to the Linux BASH shell. This book will fully illustrate the ability of the shell to unlock the real potential of UNIX and Linux, and aims to get the reader up, running and creating robust shell scripts for real tasks and situations as quickly as possible – shell scripts that will work on any mainstream UNIX or Linux machine.

If you are new to UNIX and Linux or if you are a power user in waiting then this book is for you. Most shell programming books merely annotate manual pages and syntax , but in this book users of all abilities will find plenty of practical working examples - all of which are available as full code script via an ftp site – as well as a host of tips, tricks and code one-liners, that will save you time on a day-to-day basis. The book is organized into self-contained chapters on individual topics for ease of reference.