LPI Linux Certification in a Nutshell (42 page)

An interactive textual user interface to the operating
system

In this role, the shell is a command interpreter and display
portal to the system. It offers you a communications channel to
the kernel and is often thought of as the “shell around the
kernel.” That’s where the name
shell
originates and is a good metaphor for conceptualizing how shells
fit into the overall Linux picture.

An operating environment

Shells set up an
environment
for the
execution of other programs, which affects the way some of them
behave. This environment consists of any number of
environment variables
, each of
which describes one particular environment property by defining a
name=value
pair. Other features such as
aliases
enhance your operating
environment by offering shorthand notations for commonly used
commands.

A facility for launching and managing commands and
programs

Shells are used not only by users but also by the system to
launch programs and support those programs with an operating
environment.

A programming language

Shells offer their own programming languages. At its
simplest, this feature allows user commands to be assembled into
useful sequences. At the other end of the spectrum, complete
programs can be written in shell languages, with loop control,
variables, and all of the capabilities of Linux’s rich set of
operating system commands.

• They are all distinct from the kernel and run as user
  programs.
  

• Each shell can be customized by tuning the shell’s operating
  environment.
  

• Shells are run for both interactive use by end users and
  noninteractive use by the system.
  

• A shell can be run from within another shell, enabling you to
  try a shell other than your default shell. To do this, you simply
  start the other shell from the command line of your current shell.
  In fact, this happens constantly on your system as scripts are
  executed and programs are launched. The new shell does not replace
  the shell that launched it; instead, the new shell is a process
  running with the original shell as a parent process. When you
  terminate the child shell, you go back to the original one.
  

• Shells use a series of
  configuration files
  in order to
  establish their operating
  environment
  .
  

• Shells pass on environment variables to child
  processes.
  

Bash is an
sh
-compatible shell that
incorporates useful features from the Korn shell
(
ksh
) and C shell (
csh
). It
is intended to conform to the IEEE POSIX P1003.2/ISO 9945.2 Shell and
Tools standard. It offers functional improvements over
sh
for both programming and interactive
use.

Many programs running under Linux require information
about you and your personal preferences to operate sensibly. Although
you could manually provide this information to each program you run,
much of the information you’d convey would be redundant because you’d
be telling every command you enter the same ancillary information at
each invocation. For example, you’d need to tell your paging program
about the size and nature of your terminal or terminal window each
time you use it. You would also need to give fully qualified directory
names for the programs you run.

Rather than force users to include so much detail to issue
commands, the shell handles much of this information for you
automatically. You’ve already seen that the shell creates an operating
environment for you. That
environment is made up of a series of
variables
, each of which has a value that is used
by programs and other shells. The two types of variables used by most
shells are:

To create a new
bash
shell variable, simply
enter a
name=value
pair on the command
line:

#
pi=3.14159

To see that this value is now assigned to the local variable
pi
, use the
echo
command to display its contents:

#
echo $pi
3.14159

The dollar sign preceding the variable name indicates that the
name will be replaced with the variable’s value. Without the dollar
sign,
echo
would just return the text that was
typed, which in this case is the variable name
pi
. At this point,
pi
is a local variable and is not available
to child shells or programs. To make it available to other shells or
programs, the variable must be exported to the environment:

#
export pi

Among the features missing from
sh
was the ability to easily make new commands or modify existing
commands.
bash
has the ability to set an alias
for commonly used commands or sequences of commands. For example, if
you habitually call for the older pager
more
but
actually prefer
less
, an alias can be handy to
get the desired behavior, regardless of the command you use:

$
alias more='less'

This has the effect of intercepting any command entries for
more
, substituting
less
. The
revised command is passed along to the shell’s command
interpreter.

Another common use for an alias is to modify a command slightly
so that its default behavior is more to your liking. Many people,
particularly when operating with superuser privileges, will use this
alias:

$
alias cp='cp -i'

With this alias in effect, the use of the
cp
(copy) command becomes safer, because with the
-i
option always enforced by the alias,
cp
prompts you for approval before overwriting a
file of the same name. Additional options you enter on the command
line are appended to the end of the new command, such that
cp -p
becomes
cp -i
-p
, and so on.

If the righthand side of the aliased command is bigger than a
single word or if it contains multiple commands (separated by
semicolons,
bash
’s command terminator), you
probably need to enclose it in single quotation marks to get your
point across. For example, suppose you wished to use a single alias to
pair two simple commands:

$
alias lsps=ls -l; ps

Your current
bash
process will interpret
this command not as a single alias but as two separate commands. First
the alias
lsps
will be created for
ls
-l
, and then a
ps
command will be
added for immediate execution. What you really want is:

$
alias lsps='ls -l; ps'

Now, entering the command
lsps
will be
aliased to
ls -l; ps
, and will correctly generate
ls
output immediately followed by
ps
output, as this example
shows:

$
lsps
total 1253
drwx------  5 root  root    1024 May 27 17:15 dir1
drwxr-xr-x  3 root  root    1024 May 27 22:41 dir2
-rw-r--r--  1 root  root   23344 May 27 22:44 file1
drwxr-xr-x  2 root  root   12288 May 25 16:13 dir3
PID TTY          TIME CMD
892 ttyp0    00:00:00 bash
1388 ttyp0    00:00:00 ps

Admittedly, this isn’t a very useful command, but it is built
upon in the next section.

After adding aliases, it may become easy to confuse which
commands are aliases or native. To list the aliases defined for your
current shell, simply enter the
alias
command by
itself. This results in a listing of all the aliases currently in
place:

$
alias
alias cp='cp -i'
alias lsps='ls -l;ps'
alias mv='mv -i'
alias rm='rm -i'

Note that aliases are local to your shell and are not passed
down to programs or to other shells. You’ll see how to ensure that
your aliases are always available in the section
Configuration files
.

Aliases are mainly used for simple command replacement. The
shell inserts your aliased text in place of your alias name before
interpreting the command. Aliases don’t offer logical constructs and
are limited to a few simple variable replacements. Aliases can also
get messy when the use of complicated quoting is necessary, usually to
prevent the shell from interpreting characters in your alias.

In addition to aliases,
bash
also
offers
functions
. They work in much the same way
as aliases, in that some function name of your choosing is assigned to
a more complex construction. However, in this case that construction
is a small program rather than a simple command substitution.
Functions have a simple syntax:

[
function
]
name
() {
command-list
; }

This declaration defines a function called
name
.
function
is optional, and the parentheses after
name
are required if
function
is omitted. The
body of the function is the
command-list
between the curly brackets (
{
and
}
). This list is a series of
commands, separated by semicolons or by newlines. The series of
commands is executed whenever
name
is
specified as a command. The simple
lsps
alias shown earlier could be
implemented as a function like this:

$
lsps () { ls -l; ps; }

Using this new function as a command yields exactly the same
result the alias did. However, if you implement this command as a
function, parameters can be added to the command. Here is a new
version of the same function, this time entered on multiple lines
(which eliminates the need for semicolons within the function):

$
lsps () {
>
ls -l $1
>
ps aux | grep `/bin/basename $1`
>
}

The
>
characters come from
bash
during interactive entry, indicating that
bash
is awaiting additional function commands or
the
}
character, which terminates
the function definition (this is called the secondary shell prompt).
This new function allows us to enter a single
argument
to the function, which is
inserted everywhere
$1
is found in
the function. These arguments are called
positional parameters
because each
one’s number denotes its position in the argument list. This example
uses only one positional parameter, but there can be many, and the
number of parameters is stored for your use in a special variable
$#
.

The command implemented in the previous example function now
prints to
STDOUT
a directory listing and process
status for any program given as an argument. For example, if the
Apache web server is running, the command:

$
lsps /usr/sbin/httpd

yields a directory listing for
/usr/sbin/httpd
and also displays all currently
running processes that match
httpd
:

-rwxr-xr-x 1 root root 317072 2010-01-22 14:31 /usr/sbin/httpd
root      1882  0.0  1.5  22664  8088 ?        Ss   Aug10   0:14 /usr/sbin/httpd
apache   20869  0.0  0.6  22664  3560 ?        S    04:27   0:00 /usr/sbin/httpd
apache   20870  0.0  0.6  22664  3560 ?        S    04:27   0:00 /usr/sbin/httpd
apache   20872  0.0  0.6  22664  3560 ?        S    04:27   0:00 /usr/sbin/httpd
apache   20874  0.0  0.6  22664  3560 ?        S    04:27   0:00 /usr/sbin/httpd
apache   20875  0.0  0.6  22664  3560 ?        S    04:27   0:00 /usr/sbin/httpd
apache   20876  0.0  0.6  22664  3560 ?        S    04:27   0:00 /usr/sbin/httpd
apache   20877  0.0  0.6  22664  3560 ?        S    04:27   0:00 /usr/sbin/httpd
apache   20878  0.0  0.6  22664  3560 ?        S    04:27   0:00 /usr/sbin/httpd