BASH SCRIPTING NOTES AND TIPS

Chapter 1: Bash basics

Using and . Each time you user a command in a string user
format aaa command aaa. If you put string value will accept
special characters like +,% etc and .

Chapter 2: Script basics: writing and debugging.

# bash x (will debug a script issue). You can edit script to run in
debug mode : #!/bin/bash x .

See script ~/SCRIPTS/echoscript.sh and echoscript2.sh

SAMBA server)

(on

Chapter 3: The Bash Environment: initialization files, variables,

quoting characters, shell expansion order, aliases, options.
Exporting variables - A subshell can change variables it inherited
from the parent, but the changes made by the child don't affect the
parent.
Reserved variables
Bourne shell reserved variables

Bash uses certain shell variables in the same way as the Bourne shell. In some cases,
Bash assigns a default value to the variable. The table below gives an overview of
these plain shell variables:
Table 3-1. Reserved Bourne shell variables
Variable
name

Definition

CDPATH

A colon-separated list of directories used as a search path for

the cd built-in command.

HOME

The current user's home directory; the default for the cd built-in. The
value of this variable is also used by tilde expansion.

IFS

A list of characters that separate fields; used when the shell splits words
2

Variable
name

Definition
as part of expansion.

MAIL

If this parameter is set to a file name and the MAILPATH variable is not
set, Bash informs the user of the arrival of mail in the specified file.

MAILPATH

A colon-separated list of file names which the shell periodically checks

for new mail.

OPTARG

The value of the last option argument processed by the getopts builtin.

OPTIND

The index of the last option argument processed by the getopts builtin.

PATH

A colon-separated list of directories in which the shell looks for

commands.

PS1

The primary prompt string. The default value is "'\s-\v\$ '".

PS2

The secondary prompt string. The default value is "'> '".

Bash reserved variables

These variables are set or used by Bash, but other shells do not normally treat them
specially.
Table 3-2. Reserved Bash variables
Variable name

Definition

auto_resume

This variable controls how the shell interacts with the user and
job control.

BASH

The full pathname used to execute the current instance of Bash.

BASH_ENV

If this variable is set when Bash is invoked to execute a shell

script, its value is expanded and used as the name of a startup
file to read before executing the script.

BASH_VERSION

The version number of the current instance of Bash.

BASH_VERSINFO A read-only array variable whose members hold version

Variable name

Definition
information for this instance of Bash.

COLUMNS

Used by the select built-in to determine the terminal width when

printing selection lists. Automatically set upon receipt of
a SIGWINCH signal.

COMP_CWORD

An index into ${COMP_WORDS} of the word containing the current

cursor position.

COMP_LINE

The current command line.

COMP_POINT

The index of the current cursor position relative to the beginning

of the current command.

COMP_WORDS

An array variable consisting of the individual words in the current

command line.

COMPREPLY

An array variable from which Bash reads the possible

completions generated by a shell function invoked by the
programmable completion facility.

DIRSTACK

An array variable containing the current contents of the directory

stack.

EUID

The numeric effective user ID of the current user.

FCEDIT

The editor used as a default by the -e option to the fc built-in

command.

FIGNORE

A colon-separated list of suffixes to ignore when performing file

name completion.

FUNCNAME

The name of any currently-executing shell function.

GLOBIGNORE

A colon-separated list of patterns defining the set of file names to

be ignored by file name expansion.

GROUPS

An array variable containing the list of groups of which the

current user is a member.

histchars

Up to three characters which control history expansion, quick

substitution, and tokenization.

HISTCMD

The history number, or index in the history list, of the current

command.
4

Variable name

Definition

HISTCONTROL

Defines whether a command is added to the history file.

HISTFILE

The name of the file to which the command history is saved. The
default value is ~/.bash_history.

HISTFILESIZE

The maximum number of lines contained in the history file,

defaults to 500.

HISTIGNORE

A colon-separated list of patterns used to decide which command

lines should be saved in the history list.

HISTSIZE

The maximum number of commands to remember on the history

list, default is 500.

HOSTFILE

Contains the name of a file in the same format as /etc/hosts that

should be read when the shell needs to complete a hostname.

HOSTNAME

The name of the current host.

HOSTTYPE

A string describing the machine Bash is running on.

IGNOREEOF

Controls the action of the shell on receipt of an EOF character as

the sole input.

INPUTRC

The name of the Readline initialization file, overriding the

default /etc/inputrc.

LANG

Used to determine the locale category for any category not

specifically selected with a variable starting with LC_.

LC_ALL

This variable overrides the value of LANG and any

other LC_ variable specifying a locale category.

LC_COLLATE

This variable determines the collation order used when sorting

the results of file name expansion, and determines the behavior
of range expressions, equivalence classes, and collating
sequences within file name expansion and pattern matching.

LC_CTYPE

This variable determines the interpretation of characters and the

behavior of character classes within file name expansion and
pattern matching.

LC_MESSAGES

This variable determines the locale used to translate doublequoted strings preceded by a "$" sign.

Variable name

Definition

LC_NUMERIC

This variable determines the locale category used for number

formatting.

LINENO

The line number in the script or shell function currently

executing.

LINES

Used by the select built-in to determine the column length for

printing selection lists.

MACHTYPE

A string that fully describes the system type on which Bash is

executing, in the standard GNU CPU-COMPANY-SYSTEM format.

MAILCHECK

How often (in seconds) that the shell should check for mail in the
files specified in the MAILPATH or MAIL variables.

OLDPWD

The previous working directory as set by the cd built-in.

OPTERR

If set to the value 1, Bash displays error messages generated by

the getopts built-in.

OSTYPE

A string describing the operating system Bash is running on.

PIPESTATUS

An array variable containing a list of exit status values from the

processes in the most recently executed foreground pipeline
(which may contain only a single command).

POSIXLY_CORREC If this variable is in the environment when bash starts, the shell
T
enters POSIX mode.
PPID

The process ID of the shell's parent process.

PROMPT_COMMA If set, the value is interpreted as a command to execute before

the printing of each primary prompt (PS1).
ND
PS3

The value of this variable is used as the prompt for

the select command. Defaults to "'#? '"

PS4

The value is the prompt printed before the command line is

echoed when the -x option is set; defaults to "'+ '".

PWD

The current working directory as set by the cd built-in command.

RANDOM

Each time this parameter is referenced, a random integer

between 0 and 32767 is generated. Assigning a value to this
variable seeds the random number generator.
6

Variable name

Definition

REPLY

The default variable for the read built-in.

SECONDS

This variable expands to the number of seconds since the shell

was started.

SHELLOPTS

A colon-separated list of enabled shell options.

SHLVL

Incremented by one each time a new instance of Bash is started.

TIMEFORMAT

The value of this parameter is used as a format string specifying

how the timing information for pipelines prefixed with
the time reserved word should be displayed.

TMOUT

If set to a value greater than zero, TMOUT is treated as the default

timeout for the read built-in. In an interative shell, the value is
interpreted as the number of seconds to wait for input after
issuing the primary prompt when the shell is interactive. Bash
terminates after that number of seconds if input does not arrive.

UID

The numeric, real user ID of the current user.

Check the Bash man, info or doc pages for extended information. Some variables are
read-only, some are set automatically and some lose their meaning when set to a
different value than the default.
Special parameters

The shell treats several parameters specially. These parameters may only be
referenced; assignment to them is not allowed.
Table 3-3. Special bash variables
Charac
Definition
ter

$*

Expands to the positional parameters, starting from one. When the

expansion occurs within double quotes, it expands to a single word with
the value of each parameter separated by the first character of
the IFSspecial variable.

$@

Expands to the positional parameters, starting from one. When the

expansion occurs within double quotes, each parameter expands to a
separate word.
7

Charac
Definition
ter
$#

Expands to the number of positional parameters in decimal.

$?

Expands to the exit status of the most recently executed foreground

pipeline.

$-

A hyphen expands to the current option flags as specified upon invocation,

by the set built-in command, or those set by the shell itself (such as the i).

$$

Expands to the process ID of the shell.

$!

Expands to the process ID of the most recently executed background

(asynchronous) command.

$0

Expands to the name of the shell or shell script.

$_

The underscore variable is set at shell startup and contains the absolute
file name of the shell or script being executed as passed in the argument
list. Subsequently, it expands to the last argument to the previous
command, after expansion. It is also set to the full pathname of each
command executed and placed in the environment exported to that
command. When checking mail, this parameter holds the name of the mail
file.
$* vs. $@

The implementation of "$*" has always been a problem and realistically should have
been replaced with the behavior of "$@". In almost every case where coders use "$*",
they mean "$@". "$*" Can cause bugs and even security holes in your software.

The positional parameters are the words following the name of a shell script. They are
put into the variables $1, $2, $3 and so on. As long as needed, variables are added to an
internal array. $# holds the total number of parameters, as is demonstrated with this
simple script:
#!/bin/bash
# positional.sh
# This script reads 3 positional parameters and prints them out.
POSPAR1="$1"
POSPAR2="$2"
POSPAR3="$3"

echo
echo
echo
echo
echo

"$1 is the first positional parameter, \$1."

"$2 is the second positional parameter, \$2."
"$3 is the third positional parameter, \$3."
"The total number of positional parameters is $#."

Upon execution one could give any numbers of arguments:

franky ~> positional.sh one two three four five
one is the first positional parameter, $1.
two is the second positional parameter, $2.
three is the third positional parameter, $3.
The total number of positional parameters is 5.
franky ~> positional.sh one two
one is the first positional parameter, $1.
two is the second positional parameter, $2.
is the third positional parameter, $3.
The total number of positional parameters is 2.

Some examples on the other special parameters:

franky ~> grep dictionary /usr/share/dict/words
dictionary
franky ~> echo $_
/usr/share/dict/words
franky ~> echo $$
10662
franky ~> mozilla &
[1] 11064
franky ~> echo $!
11064
franky ~> echo $0
bash
franky ~> echo $?
0
franky ~> ls doesnotexist
ls: doesnotexist: No such file or directory
franky ~> echo $?
1
franky ~>

User franky starts entering the grep command, which results in the assignment of
the _ variable. The process ID of his shell is 10662. After putting a job in the
background, the ! holds the process ID of the backgrounded job. The shell running
is bash. When a mistake is made, ? holds an exit code different from 0 (zero).
Redirections
If you want to redirect std out,err,input into a black hole use
2> /dev/null
Escape characters are used to remove the special meaning
from a single character. A non-quoted backslash, \, is used as
an escape character in Bash.
& will run in background
&& means AND
&> FILE
- both standard output and standard error to be
redirected to the file
<& File
- both standard input and standard error to be
redirected to the file

Single quotes

Single quotes ('') are used to preserve the literal value of each character enclosed
within the quotes. A single quote may not occur between single quotes, even when
preceded by a backslash.
We continue with the previous example:
franky ~> echo '$date'
$date

Double quotes

Using double quotes the literal value of all characters enclosed is preserved, except for
the dollar sign, the backticks (backward single quotes, ``) and the backslash.
The dollar sign and the backticks retain their special meaning within the double
quotes.

10

The backslash retains its meaning only when followed by dollar, backtick, double
quote, backslash or newline. Within double quotes, the backslashes are removed from
the input stream when followed by one of these characters. Backslashes preceding
characters that don't have a special meaning are left unmodified for processing by the
shell interpreter.
A double quote may be quoted within double quotes by preceding it with a backslash.
franky ~> echo "$date"
20021226
franky ~> echo "`date`"
Sun Apr 20 11:22:06 CEST 2003
franky ~> echo "I'd say: \"Go for it!\""
I'd say: "Go for it!"
franky ~> echo "\"
More input>"
franky ~> echo "\\"
\

The following construct allows for creation of the named variable if it does not
yet exist:
${VAR:=value}
Example:
franky ~> echo $FRANKY
franky ~> echo ${FRANKY:=Franky}
Franky

Chapter 4. Regular expressions

4.1.2. Regular expression metacharacters

A regular expression may be followed by one of several repetition operators

(metacharacters):
Table 4-1. Regular expression operators
11

Operat
Effect
or
.

Matches any single character.

The preceding item is optional and will be matched, at most, once.

The preceding item will be matched zero or more times.

The preceding item will be matched one or more times.

{N}

The preceding item is matched exactly N times.

{N,}

The preceding item is matched N or more times.

{N,M}

The preceding item is matched at least N times, but not more than M
times.

represents the range if it's not first or last in a list or the ending point of a
range in a list.

Matches the empty string at the beginning of a line; also represents the
characters not in the range of a list.

Matches the empty string at the end of a line.

\b

Matches the empty string at the edge of a word.

\B

Matches the empty string provided it's not at the edge of a word.

\<

Match the empty string at the beginning of word.

\>

Match the empty string at the end of word.

Two regular expressions may be concatenated; the resulting regular expression

matches any string formed by concatenating two substrings that respectively match
the concatenated subexpressions.Two regular expressions may be joined by the infix
operator "|"; the resulting regular expression matches any string matching either
subexpression.
Repetition takes precedence over concatenation, which in turn takes precedence over
alternation. A whole subexpression may be enclosed in parentheses to override these
precedence rules.

12

Arithmetic Operators:
There are following arithmetic operators supported by Bourne Shell.
Assume variable a holds 10 and variable b holds 20 then:
Operator Description

Example

Addition - Adds values on either side of the operator

`expr $a + $b` will give 30

Subtraction - Subtracts right hand operand from left hand operand

`expr $a - $b` will give -10

Multiplication - Multiplies values on either side of the operator

`expr $a \* $b` will give 200

Division - Divides left hand operand by right hand operand

`expr $b / $a` will give 2

Modulus - Divides left hand operand by right hand operand and returns
remainder

`expr $b % $a` will give 0

a=$b would assign value of b

Assignment - Assign right operand in left operand

==

Equality - Compares two numbers, if both are same then returns true.

[ $a == $b ] would return false.

!=

Not Equality - Compares two numbers, if both are different then returns true.

[ $a != $b ] would return true.

Modulus %

into a

meaning:

Most explanations leave one important step.

Let's fill the gap using another example:
16 % 6 = 4
And 16 / 6 = 2
Then you multiply the result of your division with 6:
2 * 6 = 12
Now you will subtract 16 - 12 = 4
The answer - number 4 is the reminder, the same number as the result of modulus division.
You get the same with: 16 % 6 = 4.

13

Exercises
Display configuration files in /etc that contain numbers in their names.
# ls a /etc/ | grep [*0-9*]
From the /etc/group directory, display all lines starting with the
string "daemon".
# grep ^daemon /etc/group
Print all the lines from the same file that don't contain the string.
# grep v ^daemon /etc/group
Display localhost information from the /etc/hosts file, display the line
number(s) matching the search string and count the number of
occurrences of the string.
# grep c (used for counting). See script ~/SCRIPTS/count.sh
How many README files do these subdirectories contain? Don't count
anything in the form of "README.a_string".
# ls a /usr/share/doc/* | grep c ^README$
Make a list of files in your home directory that were changed less that 10
hours ago, using grep, but leave out directories.
# ls alR /home/*

Chapter 5. The GNU sed stream editor

Table 5-1. Sed editing commands
Command

Result

a\

Append text below current line.

14

Command

Result

c\

Change text in the current line with new text.

Delete text.

i\

Insert text above current line.

Print text.

Read a file.

Search and replace text.

Write to a file.

Apart from editing commands, you can give options to sed. An overview is in the
table below:
Table 5-2. Sed options
Option

Effect

-e
SCRIPT

Add the commands in SCRIPT to the set of commands to be run while processing the
input.

-f

Add the commands contained in the file SCRIPT-FILE to the set of commands to be
run while processing the input.

-n

Silent mode.

-V

Print version information and exit.

Multiple find and replace commands are separated with individual

-e

options:

sandy ~> sed -e 's/erors/errors/g' -e 's/last/final/g' example

s/ = for replace
/g = to replace patern on entire line not just first occurrence.

Exercises
1. Make a list of files in /usr/bin that have the letter "a" as the second character.
Put the result in a temporary file.
ls /usr/bin | grep ^.a.*
2. Delete the first 3 lines of each temporary file.
15

sed 1,2,3d tmp.txt

3. Print to standard output only the lines containing the pattern "an".
sed n an/p/g tmp.txt
4. Create a file holding sed commands to perform the previous two tasks. Add an
extra command to this file that adds a string like "*** This might have
something to do with man and man pages ***" in the line preceding every
occurence of the string "man". Check the results.
sed i /man/a\*** This might have something to do with man
and man pages *** tmp.txt tmp2.txt

Chapter 6. The GNU awk programming language

$1 $2 $n - tab variable in awk (could be text, or space)

$0 entire line variable

{ print $1 } = will display variable $1 value

Formatting characters for gawk

16

Sequence

Meaning

\a

Bell character

\n

Newline character

\t

Tab

Example:
df -h | sort -rnk 5 | head -3 | \
awk '{ print "Partition " $6 "\t: " $5 " full!" }'
Partition /var : 86% full!
Partition /usr : 85% full!
Partition /home : 70% full!

!!A regular expression can be used as a pattern by enclosing

it in slashes.!!! / /
Ex: awk /^[ax].*/
6.2.4. Special patterns

In order to precede output with comments, use the BEGIN statement:

kelly is in /etc> ls -l | \
awk 'BEGIN { print "Files found:\n" } /\<[a|x].*\.conf$/ { print $9 }'
Files found:
amd.conf
antivir.conf
xcdroast.conf
xinetd.conf
kelly is in /etc>

The END statement can be added for inserting text after the entire input is processed:
kelly is in /etc> ls -l | \
awk '/\<[a|x].*\.conf$/ { print $9 } END { print \
"Can I do anything else for you, mistress?" }'
amd.conf
antivir.conf
xcdroast.conf
xinetd.conf
Can I do anything else for you, mistress?
kelly is in /etc>

17

Built in awk variable is FS, edit this variable to define tab delimiter
for $1, $2, $n. Always use BEGIN statement to assign FS a value.
Ex: In the example below, we build a command that displays all the users on your

system with a description:

kelly is in ~> awk 'BEGIN { FS=":" } { print $1 "\t" $5 }' /etc/passwd
--output omitted-kelly
Kelly Smith
franky Franky B.
eddy
Eddy White
willy
William Black
cathy
Catherine the Great
sandy
Sandy Li Wong
kelly is in ~>

The output field separator OFS

Fields are normally separated by spaces in the output. This becomes apparent when
you use the correct syntax for the print command, where arguments are separated by
commas:
!! by default if you put print $1,$2 the outbul delimiter will be a blank space. IF you
specify BEGIN OFS=- , when printing $1,$2 it will output 1-2
kelly@octarine ~/test> cat test
record1
data1
record2
data2
kelly@octarine ~/test> awk '{ print $1 $2}' test
record1data1
record2data2

The output record separator

ORS

The output from an entire print statement is called an output record.

Each print command results in one output record, and then outputs a string called
the output record separator, ORS. The default value for this variable is"\n", a newline
character. Thus, each print statement generates a separate line.
To change the way output fields and records are separated, assign new values
to OFS and ORS:
kelly@octarine ~/test> awk 'BEGIN { OFS=";" ; ORS="\n-->\n" } \

18

{ print $1,$2}' test

record1;data1
-->
record2;data2
-->

NR - The number of records

The built-in NR holds the number of records that are processed. It is incremented after
reading a new input line. You can use it at the end to count the total number of
records, or in each output record:
kelly@octarine ~/test> cat processed.awk
BEGIN { OFS="-" ; ORS="\n--> done\n" }
{ print "Record number " NR ":\t" $1,$2 }
END { print "Number of records processed: " NR }
kelly@octarine ~/test> awk -f processed.awk test
Record number 1:
record1-data1
--> done
Record number 2:
record2-data2
--> done
Number of records processed: 2
--> done
kelly@octarine ~/test>

User defined variables

Apart from the built-in variables, you can define your own. When awk encounters a
reference to a variable which does not exist (which is not predefined), the variable is
created and initialized to a null string. For all subsequent references, the value of the
variable is whatever value was assigned last. Variables can be a string or a numeric
value. Content of input fields can also be assigned to variables.
Values can be assigned directly using the = operator, or you can use the current value
of the variable in combination with other operators:
kelly@octarine ~> cat revenues
20021009
20021013
20021015
20021020
20021112
20021123
20021204
20021215

consultancy
training
appdev
training

BigComp
EduComp
SmartComp
EduComp

2500
2000
10000
5000

kelly@octarine ~> cat total.awk

{ total=total + $5 }
{ print "Send bill for " $5 " dollar to " $4 }
END { print "---------------------------------\nTotal revenue: " total }

19

kelly@octarine ~> awk -f total.awk test

Send bill for 2500 dollar to BigComp
Send bill for 2000 dollar to EduComp
Send bill for 10000 dollar to SmartComp
Send bill for 5000 dollar to EduComp
--------------------------------Total revenue: 19500

Exercises
1. For the first exercise, your input is lines in the following form:
Username:Firstname:Lastname:Telephone number

Make an awk script that will convert such a line to an LDAP record in this format:
dn: uid=Username, dc=example, dc=com
cn: Firstname Lastname
sn: Lastname
telephoneNumber: Telephone number

see ~/SCRIPTS/AWK/awk1.awk
2. Create a Bash script using awk and standard UNIX commands that will show the top three users
of disk space in the /home file system (if you don't have the directory holding the homes on a
separate partition, make the script for the / partition; this is present on every UNIX system). First,
execute the commands from the command line. Then put them in a script. The script should
create sensible output (sensible as in readable by the boss). If everything proves to work, have
the script email its results to you (use for instance mail -s Disk space
usage <you@your_comp> < result)
See

~/SCRIPTS/AWK/awk2.sh

Chapter 7. Conditional statements ( IF )

$? -

is a system variable that generates exit code values from 0-255. 0

means true condition.

Table 7-1. Primary expressions

20

Primary

Meaning

[ -a FILE ]

True if FILE exists.

[ -b FILE ]

True if FILE exists and is a block-special file.

[ -c FILE ]

True if FILE exists and is a character-special file.

[ -d FILE ]

True if FILE exists and is a directory.

[ -e FILE ]

True if FILE exists.

[ -f FILE ]

True if FILE exists and is a regular file.

[ -g FILE ]

True if FILE exists and its SGID bit is set.

[ -h FILE ]

True if FILE exists and is a symbolic link.

[ -k FILE ]

True if FILE exists and its sticky bit is set.

[ -p FILE ]

True if FILE exists and is a named pipe (FIFO).

[ -r FILE ]

True if FILE exists and is readable.

[ -s FILE ]

True if FILE exists and has a size greater than zero.

[ -t FD ]

True if file descriptor FD is open and refers to a terminal.

[ -u FILE ]

True if FILE exists and its SUID (set user ID) bit is set.

[ -w FILE ]

True if FILE exists and is writable.

[ -x FILE ]

True if FILE exists and is executable.

[ -O FILE ]

True if FILE exists and is owned by the effective user ID.

[ -G FILE ]

True if FILE exists and is owned by the effective group ID.

[ -L FILE ]

True if FILE exists and is a symbolic link.

[ -N FILE ]

True if FILE exists and has been modified since it was last read.

[ -S FILE ]

True if FILE exists and is a socket.

[ FILE1 -nt FILE2 ]

True if FILE1 has been changed more recently than FILE2, or

if FILE1 exists and FILE2 does not.

[ FILE1 -ot FILE2 ] True if FILE1 is older than FILE2, or is FILE2 exists and FILE1 does not.
[ FILE1 -ef FILE2 ] True if FILE1 and FILE2 refer to the same device and inode numbers.
[ -o OPTIONNAM
True if shell option "OPTIONNAME" is enabled.
E]
[ -z

STRING ]

True of the length if "STRING" is zero.

STRING ] or [
True if the length of "STRING" is non-zero.
STRING ]
[ -n

[ STRING1 ==
STRING2 ]

True if the strings are equal. "=" may be used instead of "==" for strict
POSIX compliance.

[ STRING1 !=
STRING2 ]

True if the strings are not equal.

21

Primary

Meaning

[ STRING1 <
STRING2 ]

True if "STRING1" sorts before "STRING2" lexicographically in the

current locale.

[ STRING1 >
STRING2 ]

True if "STRING1" sorts after "STRING2" lexicographically in the current

locale.

"OP" is one of -eq, -ne, -lt, -le, -gt or -ge. These arithmetic binary
operators return true if "ARG1" is equal to, not equal to, less than, less
[ ARG1 OP ARG2 ]
than or equal to, greater than, or greater than or equal to"ARG2",
respectively. "ARG1" and "ARG2" are integers.

!!!
$# refers to the number of command line arguments. $0 refers
to the name of the script. !!!!!
* if/then/elif/else constructs

This is the full form of the if statement:

if TEST-COMMANDS; then
CONSEQUENT-COMMANDS;
elif MORE-TEST-COMMANDS; then
MORE-CONSEQUENT-COMMANDS;
else ALTERNATE-CONSEQUENT-COMMANDS;
fi

Boolean operations

The above script can be shortened using the Boolean operators "AND" (&&)
and "OR" (||).
Arithmetic expansion allows the evaluation of an arithmetic expression and the
substitution of the result. The format for arithmetic expansion is:
$(( EXPRESSION )) do not use square brackets [].!!!
Example using Boolean operators
22

We use the double brackets for testing an arithmetic expression, see Section 3.4.6.
This is equivalent to the let statement. You will get stuck using square brackets here, if
you try something like $[$year % 400], because here, the square brackets don't
represent an actual command by themselves.
Among other editors, gvim is one of those supporting colour schemes according to the
file format; such editors are useful for detecting errors in your code.

Using the exit statement and if

We already briefly met the exit statement in Section 7.2.1.3. It terminates execution of
the entire script. It is most often used if the input requested from the user is incorrect,
if a statement did not run successfully or if some other error occurred.
The exit statement takes an optional argument. This argument is the integer exit status
code, which is passed back to the parent and stored in the $? variable.
A zero argument means that the script ran successfully. Any other value may be used
by programmers to pass back different messages to the parent, so that different actions
can be taken according to failure or success of the child process. If no argument is
given to the exit command, the parent shell uses the current value of the $? variable.

23

Below is an example with a slightly adapted penguin.sh script, which sends its exit
status back to the parent, feed.sh:
anny ~/testdir> cat penguin.sh
#!/bin/bash
# This script lets you present different menus to Tux. He will only be happy
# when given a fish. We've also added a dolphin and (presumably) a camel.
if [ "$menu" == "fish" ]; then
if [ "$animal" == "penguin" ]; then
echo "Hmmmmmm fish... Tux happy!"
elif [ "$animal" == "dolphin" ]; then
echo "Pweetpeettreetppeterdepweet!"
else
echo "*prrrrrrrt*"
fi
else
if [ "$animal" == "penguin" ]; then
echo "Tux don't like that. Tux wants fish!"
exit 1
elif [ "$animal" == "dolphin" ]; then
echo "Pweepwishpeeterdepweet!"
exit 2
else
echo "Will you read this sign?!"
exit 3
fi
fi

This script is called upon in the next one, which therefore exports its
variables menu and animal:
anny ~/testdir> cat feed.sh
#!/bin/bash
# This script acts upon the exit status given by penguin.sh
export menu="$1"
export animal="$2"
feed="/nethome/anny/testdir/penguin.sh"
$feed $menu $animal
case $? in
1)

echo "Guard: You'd better give'm a fish, less they get violent..."
;;

2)

echo "Guard: It's because of people like you that they are leaving earth
all the time..."
;;

24

3)
echo "Guard: Buy the food that the Zoo provides for the animals, you ***,
how
do you think we survive?"
;;
*)
echo "Guard: Don't forget the guide!"
;;
esac
anny ~/testdir> ./feed.sh apple penguin
Tux don't like that. Tux wants fish!
Guard: You'd better give'm a fish, less they get violent...

As you can see, exit status codes can be chosen freely. Existing commands usually
have a series of defined codes; see the programmer's manual for each command for
more information.

Using case statements

Simplified conditions
Nested if statements might be nice, but as soon as you are confronted with a couple of
different possible actions to take, they tend to confuse. For the more complex
conditionals, use the case syntax:
case EXPRESSION in CASE1) COMMAND-LIST;; CASE2) COMMANDLIST;; ... CASEN) COMMAND-LIST;; esac
Each case is an expression matching a pattern. The commands in the COMMANDLIST for the first match are executed. The "|" symbol is used for separating multiple
patterns, and the ")" operator terminates a pattern list. Each case plus its according
commands are called a clause. Each clause must be terminated with ";;".
Each case statement is ended with the esac statement.
In the example, we demonstrate use of cases for sending a more selective warning
message with the disktest.sh script:
anny ~/testdir> cat disktest.sh
#!/bin/bash
# This script does a very simple test for checking disk space.
space=`df -h | awk '{print $5}' | grep % | grep -v Use | sort -n | tail -1 |
cut -d "%" -f1 -`

25

case $space in
[1-6]*)
Message="All is quiet."
;;
[7-8]*)
Message="Start thinking about cleaning out some stuff. There's a partition
that is $space % full."
;;
9[1-8])
Message="Better hurry with that new disk... One partition is $space %
full."
;;
99)
Message="I'm drowning here! There's a partition at $space %!"
;;
*)
Message="I seem to be running with an nonexistent amount of disk space..."
;;
esac
echo $Message | mail -s "disk report `date`" anny

Exercises
3. Modify /etc/profile so that you get a special greeting message when you
connect to your system as root.
See edit from the end of /etc/profile
5.

Write a script called whichdaemon.sh that checks if

the httpd and init daemons are running on your system. If
an httpd is running, the script should print a message
like, "This machine is running a web server." Useps to check on
processes

See script ~/SCRIPTS/CONITIONALIF/wichdaemon.sh

6. Write a script that makes a backup of your home directory on a remote machine
using scp. The script should report in a log file, for
instance ~/log/homebackup.log. If you don't have a second machine to copy the
backup to, use scp to test copying it to the localhost. This requires SSH keys
between the two hosts, or else you have to supply a password. The creation of
SSH keys is explained in man ssh-keygen.
26

See script ~/SCRIPTS/CONITIONALIF/scpwithbackup.sh

7.

See script ~/SCRIPTS/CONITIONALIF/casebackup2.sh

Chapter 8. Writing interactive scripts

Using the echo built-in command

The echo built-in command outputs its arguments, separated by spaces and terminated
with a newline character. The return status is always zero. echo takes a couple of
options:

-e:

interprets backslash-escaped characters.

-n:

suppresses the trailing newline.

echo e aaaa na\n adds a new line after aaaa.

Sequence

Meaning

\a

Alert (bell).

\b

Backspace.

\c

Suppress trailing newline.

\e

Escape.

\f

Form feed.

\n

Newline.

\r

Carriage return.

\t

Horizontal tab.

\v

Vertical tab.

\\

Backslash.

READ input
This will take input from user and assign variable ex:
echo Cati ani ai

(daca tastezi 25)

27

read Varsta
echo $Varsta (valoarea variabilei va fi 25)
See script ~/SCRIPTS/READ/readtest.sh

Options to the read built-in

Option

Meaning

The words are assigned to sequential indexes of the array variable ANAME, starting at
-a ANAME 0. All elements are removed from ANAME before the assignment.
Other NAME arguments are ignored.
-d DELIM The first character of DELIM is used to terminate the input line, rather than newline.
-e

readline is used to obtain the line.

-n NCHARS

read returns after reading NCHARS characters rather than waiting for a complete line
of input.

-p PROMPT

Display PROMPT, without a trailing newline, before attempting to read any input. The
prompt is displayed only if input is coming from a terminal.

-r

If this option is given, backslash does not act as an escape character. The backslash is
considered to be part of the line. In particular, a backslash-newline pair may not be
used as a line continuation.

-s

Silent mode. If input is coming from a terminal, characters are not echoed.

Cause read to time out and return failure if a complete line of input is not read
-t TIMEOU within TIMEOUT seconds. This option has no effect if read is not reading input from
T
the terminal or from a pipe.
-u FD

Read input from file descriptor FD.

If you put read xyz n 1 (read will return value after only 1
character input, and so on..) !!!

Redirection and file descriptors

Stdin = 0
Stdout = 1
Stderr = 2

28

Read and exec

Assigning file descriptors to files

Another way of looking at file descriptors is thinking of them as a way to assign a

numeric value to a file. Instead of using the file name, you can use the file descriptor
number. The exec built-in command can be used to replace the shell of the current
process or to alter the file descriptors of the current shell. For example, it can be used
to assign a file descriptor to a file. Use
exec fdN> file
for assigning file descriptor N to file for output, and
exec fdN< file
for assigning file descriptor N to file for input. After a file descriptor has been
assigned to a file, it can be used with the shell redirection operators, as is
demonstrated in the following example:
michel ~> exec 4> result.txt
michel ~> filter body.txt | cat header.txt /dev/fd/0 footer.txt >& 4
michel ~> cat result.txt
This text is printed at the beginning of each print job and thanks the
sysadmin

<&- will delete FdID(File Descriptor ID) assignment ex: 5<&delete fd id 5.

will

Exercises
1. Write a script that asks for the user's age. If it is equal to or

higher than 16, print a message saying that this user is allowed
to drink alcohol. If the user's age is below 16, print a message
telling the user how many years he or she has to wait before
legally being allowed to drink.
See script
See script ~/SCRIPTS/READ/exercise1.sh

29

2. Write a script that takes one file as an argument. Use a here document that
presents the user with a couple of choices for compressing the file. Possible
choices could be gzip, bzip2, compress and zip.
See script ~/SCRIPTS/READ/exercise2.sh

3. Write a script called homebackup that automates tar so the person

executing the script always uses the desired options (cvp) and
backup destination directory (/var/backups) to make a backup of
his or her home directory
See script /homebackup.sh
/tmp/backups.

- it will create compression on

4. Write a script called simple-useradd.sh that adds a local user to

the system.

See script ~/SCRIPTS/READ/simple-useradd.sh

Chapter 9. Repetitive tasks

The FOR loop
Using command substitution for specifying LIST items

The first is a command line example, demonstrating the use of a for loop that makes a
backup copy of each .xml file. After issuing the command, it is safe to start working
on your sources:
[carol@octarine ~/articles] ls *.xml
file1.xml file2.xml file3.xml
[carol@octarine ~/articles] ls *.xml > list
[carol@octarine ~/articles] for i in `cat list`; do cp "$i" "$i".bak ; done
[carol@octarine ~/articles] ls *.xml*
file1.xml file1.xml.bak file2.xml file2.xml.bak

file3.xml

file3.xml.bak

See also script from ~/SCRIPTS/LOOPS/firstloop1.sh

30

The WHILE loop

This small script can be used for simulation testing; it generates files:
#!/bin/bash
# This generates a file every 5 minutes
while true; do
touch pic-`date +%s`.jpg
sleep 300
done

Note the use of the date command to generate all kinds of file and directory names.
See the man page for more. Also sleep 300 (means waiting time 5 mins) until a new
file is created. !!!! The true statement will create files without stopping until a
force kill is performend by user (ctrl+c). !!!

The UNTIL loop

The until loop is very similar to the while loop, except that the loop
executes until the TEST-COMMAND executes successfully. As long
as this command fails, the loop continues. The syntax is the same as
for the while loop.

Example:
An improved picturesort.sh script (see Section 9.2.2.2), which tests for available
disk space. If not enough disk space is available, remove pictures from the previous
months:
#!/bin/bash
# This script copies files from my homedirectory into the webserver
directory.
# A new directory is created every hour.
# If the pics are taking up too much space, the oldest are removed.
while true; do
DISKFUL=$(df -h $WEBDIR | grep -v File | awk '{print $5 }' | cut -d
"%" -f1 -)
until [ $DISKFUL -ge "90" ]; do

31

DATE=`date +%Y%m%d`
HOUR=`date +%H`
mkdir $WEBDIR/"$DATE"
while [ $HOUR -ne "00" ]; do
DESTDIR=$WEBDIR/"$DATE"/"$HOUR"
mkdir "$DESTDIR"
mv $PICDIR/*.jpg "$DESTDIR"/
sleep 3600
HOUR=`date +%H`
done
DISKFULL=$(df -h $WEBDIR | grep -v File | awk '{ print $5 }' | cut -d
"%" -f1 -)
done
TOREMOVE=$(find $WEBDIR -type d -a -mtime +30)
for i in $TOREMOVE; do
rm -rf "$i";
done
done

Note! find $WEBDIR -type d a mtime +30 ( it means that will

find all directories that were accessed and modified last more
than 30 days ago.
Also DATE=`date +%Y%m%d` will output date in one number formate ex
20150303. Same for date +%H will put the hour in one number ex: if hour is
11:20 AM it will be 11
LOOP with Output redirection
#!/bin/bash
#
#
#
#

This script creates a subdirectory in the current directory, to which old

files are moved.
Might be something for cron (if slightly adapted) to execute weekly or
monthly

ARCHIVENR=`date +%Y%m%d`
DESTDIR="$PWD/archive-$ARCHIVENR"
mkdir "$DESTDIR"
# using quotes to catch file names containing spaces, using read -d for more
# fool-proof usage:
find "$PWD" -type f |

while read file

32

do
gzip "$file"; mv "$file".gz "$DESTDIR"
echo "$file archived"
done
See script /root/SCRIPTS/LOOPS/loop-withoutput-redirection/ loop-withoutput-redirection.sh

The break built-in

The break statement is used to exit the current loop before its
normal ending. This is done when you don't know in advance how
many times the loop will have to execute, for instance because it is
dependent on user input.

#!/bin/bash
# This script provides wisdom
# You can now exit in a decent way.
FORTUNE=/usr/games/fortune
while true; do
echo "On which topic do you want advice?"
echo "1. politics"
echo "2. startrek"
echo
echo -n "Enter your choice, or 0 for exit: "
read choice
echo
case $choice in
1)
$FORTUNE politics
;;
2)
$FORTUNE startrek
;;
0)
echo "OK, see you!"
break
;;
*)
echo "That is not a valid choice, try a number from 0 to 2."
;;
esac
done

Break will end loop at user input. !!!!

33

The continue built-in

The continue statement resumes iteration of an enclosing for,

while, until, select loop.
Example:
#!/bin/bash
# This script converts all file names containing upper case characters into
file# names containing only lower cases.
LIST="$(ls)"
for name in "$LIST"; do
if [[ "$name" != *[[:upper:]]* ]]; then
continue
fi
ORIG="$name"
NEW=`echo $name | tr 'A-Z' 'a-z'`
mv "$ORIG" "$NEW"
echo "new name for $ORIG is $NEW"
done

tr = translate, convert or delete characters in a string. In our case this will convert from upper
case to lower case.
Also notice [:upper:] statement see this example:

Making menus with the select built-in

The select construct allows easy menu generation. The syntax is quite similar to that
of the for loop:
34

select WORD [in LIST]; do RESPECTIVE-COMMANDS; done

is expanded, generating a list of items. The expansion is printed to standard error;
each item is preceded by a number.
LIST

Upon printing all the items, the PS3 prompt is printed and one line from standard input
is read. If this line consists of a number corresponding to one of the items, the value
of WORD is set to the name of that item. If the line is empty, the items and
the PS3 prompt are displayed again. If an EOF (End Of File) character is read, the loop
exits. Since most users don't have a clue which key combination is used for the EOF
sequence, it is more user-friendly to have a break command as one of the items. Any
other value of the read line will set WORD to be a null string.The read line is saved in
the REPLY variable.The RESPECTIVE-COMMANDS are executed after each
selection until the number representing the break is read. This exits the loop.
PS3 is a special variable that will output the value by itself.
Ex:
#!/bin/bash
echo "This script can make any of the files in this directory private."
echo "Enter the number of the file you want to protect:"
PS3="Your choice: "
#This will output after the 2 echos.
QUIT="QUIT THIS PROGRAM - I feel safe now."
touch "$QUIT"
select FILENAME in *;
do
case $FILENAME in
"$QUIT")
echo "Exiting."
Break
# break will exit the loop.
;;
*)
echo "You picked $FILENAME ($REPLY)"
chmod go-rwx "$FILENAME"
;;
esac
done
rm "$QUIT"

35

The shift built-in

A shift statement is typically used when the number of arguments to a command is not
known in advance, for instance when users can give as many arguments as they like.
In such cases, the arguments are usually processed in a while loop with a test
condition of (( $# )). This condition is true as long as the number of arguments is
greater than zero. The $1 variable and the shift statement process each argument. The
number of arguments is reduced each time shift is executed and eventually becomes
zero, upon which the while loop exits.
The example below, cleanup.sh, uses shift statements to process each file in the list
generated by find:
#!/bin/bash
# This script can clean up files that were last accessed over 365 days ago.
USAGE="Usage: $0 dir1 dir2 dir3 ... dirN"
if [ "$#" == "0" ]; then
echo "$USAGE"
exit 1
fi
while (( "$#" )); do
if [[ $(ls "$1") == "" ]]; then
echo "Empty directory, nothing to be done."
else
find "$1" -type f -a -atime +365 -exec rm -i {} \;
fi
shift
done

$# = counts the number of positional parameters inserted with the script.

Shift = will take any positional parameter one by one.

Exercises

1. Create a script that will take a (recursive) copy of files in /etc so that a
beginning system administrator can edit files without fear.
see script ~/SCRIPTS/LOOP/recursivecopy.sh

36

2. Write a script that takes exactly one argument, a directory name. If the number
of arguments is more or less than one, print a usage message. If the argument is
not a directory, print another message. For the given directory, print the five
biggest files and the five files that were most recently modified.
See script ~/SCRIPTS/LOOPS/2ndexercise.sh
3.

4. Write a script similar to the one in Section 9.5.1, but think of a way of quitting
after the user has executed 3 loops.
See script ~/SCRIPTS/LOOPS/4thexercise.sh
5.

Rewrite the whichdaemon.sh script from Section 7.2.4, so that

it:Prints a list of servers to check, such as Apache, the SSH
server, the NTP daemon, a name daemon, a power
management daemon, and so on.For each choice the user can
make, print some sensible information, like the name of the
web server, NTP trace information, and so on.
See script ~/SCRIPTS/LOOPS/6thexercise.sh

Chapter 10. More on variables

Using the declare built-in

Using a declare statement, we can limit the value assignment to variables.

The syntax for declare is the following:
declare OPTION(s) VARIABLE=value
The following options are used to determine the type of data the variable can hold and
to assign it attributes:
Table 10-1. Options to the declare built-in
Opti
Meaning
on
-a

Variable is an array.

37

Opti
Meaning
on
-f

Use function names only.

-i

The variable is to be treated as an integer; arithmetic evaluation is

performed when the variable is assigned a value (see Section 3.4.6).

-p

Display the attributes and values of each variable. When -p is used,

additional options are ignored.

-r

Make variables read-only. These variables cannot then be assigned values by

subsequent assignment statements, nor can they be unset.

-t

Give each variable the trace attribute.

-x

Mark each variable for export to subsequent commands via the environment.

Using + instead of - turns off the attribute instead. When used in a

function, declare creates local variables.

-i = will set variable value to integer. If changed to

a string value will become 0. Any other integer value
(number) will be registered as new value.
Ex: The following example shows how assignment of a type to a variable influences
the value.
[bob in ~] declare -i VARIABLE=12
[bob in ~] VARIABLE=string
[bob in ~] echo $VARIABLE
0
[bob in ~] declare -p VARIABLE
declare -i VARIABLE="0"

Constants

In Bash, constants are created by making a variable read-only. The readonly built-in
marks each specified variable as unchangeable. The syntax is:
readonly OPTION VARIABLE(s)

38

[bob in ~] readonly TUX=penguinpower

[bob in ~] TUX=Mickeysoft
bash: TUX: readonly variable

Array variables
An array is a variable containing multiple values. Any variable may
be used as an array. There is no maximum limit to the size of an
array, nor any requirement that member variables be indexed or
assigned contiguously. Arrays are zero-based: the first element is
indexed with the number 0
Explicit declaration of an array is done using the declare built-in:
declare -a ARRAYNAME
A declaration with an index number will also be accepted, but the index number will
be ignored. Attributes to the array may be specified using
the declare and readonly built-ins. Attributes apply to all variables in the array; you
can't have mixed arrays.
Array variables may also be created using compound assignments in this format:
ARRAY=(value1

value2 ... valueN)

EX:
[bob in ~] ARRAY=(one two three)
[bob in ~] echo ${ARRAY[*]}
one two three
[bob in ~] echo $ARRAY[*]
one[*]
[bob in ~] echo ${ARRAY[2]}
three
[bob in ~] ARRAY[3]=four
[bob in ~] echo ${ARRAY[*]}
one two three four

Unset = is used to delete array or variable in array: in this

example two (variable inderx1) will be deleted.
39

[bob in ~] unset ARRAY[1]

[bob in ~] echo ${ARRAY[*]}
one three four

Operations on variables
Length of a variable

Using the ${#VAR} syntax will calculate the number of characters in

a variable.
EX:
[bob in ~] echo $SHELL
/bin/bash
[bob in ~] echo ${#SHELL}
9
[bob in ~] ARRAY=(one two three)
[bob in ~] echo ${#ARRAY}
3

Testing a variable if exists with sintax echo ${VAR:?}

Ex:
[bob in ~] cat vartest.sh
#!/bin/bash
# This script tests whether a variable is set.
# it exits printing a message.

If not,

echo ${TESTVAR:?"There's so much I still wanted to do..."}

echo "TESTVAR is set, we can proceed."
[bob in testdir] ./vartest.sh
./vartest.sh: line 6: TESTVAR: There's so much I still wanted to do...
[bob in testdir] export TESTVAR=present
[bob in testdir] ./vartest.sh
present
TESTVAR is set, we can proceed.

Removing substrings
40

${VAR#WORD} and ${VAR##WORD}

If VAR is an array variable subscribed with "*" or "@", the pattern removal operation is
applied to each member of the array in turn, and the expansion is the resultant list.
EX:
[bob in ~] echo ${ARRAY[*]}
one two one three one four
[bob in ~] echo ${ARRAY[*]#one}
two three four
[bob in ~] echo ${ARRAY[*]#t}
one wo one hree one four
[bob in ~] echo ${ARRAY[*]#t*}
one wo one hree one four
[bob in ~] echo ${ARRAY[*]##t*}
one one one four

The opposite effect is obtained using "%" and "%%", as in this example
below. WORD should match a trailing portion of string:
[bob in ~] echo $STRING
thisisaverylongname
[bob in ~] echo ${STRING%name}
thisisaverylong

Exercises
1. See script ~/SCRIPTS/TypesofVariables/1stexercise.sh

Chapter 11. Functions

Shell functions are a way to group commands for later execution,
using a single name for this group, or routine. The name of the
routine must be unique within the shell or script. All the commands
that make up a function are executed like regular commands. When

41

calling on a function as a simple command name, the list of

commands associated with that function name is executed.
Functions either use the syntax
function FUNCTION { COMMANDS; }
or
FUNCTION () { COMMANDS; }
Both define a shell function FUNCTION. The use of the built-in
command function is optional; however, if it is not used, parentheses are needed.
[lydia@cointreau ~/test] cat showparams.sh
#!/bin/bash
echo "This script demonstrates function arguments."
echo
echo "Positional parameter 1 for the script is $1."
echo
test ()
{
echo "Positional parameter 1 in the function is $1."
RETURN_VALUE=$?
echo "The exit code of this function is $RETURN_VALUE."
}
test other_param
[lydia@cointreau ~/test] ./showparams.sh parameter1
This script demonstrates function arguments.
Positional parameter 1 for the script is parameter1.
Positional parameter 1 in the function is other_param.
The exit code of this function is 0.
[lydia@cointreau ~/test]

In above example, test other_param will execute the test function with other_param
being 1st paramenter in the function.

42

Exercises
1 and 2. Type catman <ce vrei u> = functia e in /root/.bashrc

Chapter 12. Catching signals

Signals
Table 12-2. Common kill signals
Signal name

Signal value

Effect

SIGHUP

Hangup

SIGINT

Interrupt from keyboard

SIGKILL

Kill signal

SIGTERM

15

Termination signal

SIGSTOP

17,19,23

Stop the process

Kill -9 PID (force process kill)

When a process starts up several instances, killall might be easier.

It takes the same option as the kill command, but applies on all
instances of a given process.
#!/bin/bash
# traptest.sh
trap "echo Booh!" SIGINT SIGTERM
echo "pid is $$"
while :
do

# This is the same as "while true".

sleep 60

# This script is not really doing anything.

done

See also /root/SCRIPTS/SIGNALS/1stexample.sh

43

Exercises
1. Create a script that writes a boot image to a diskette using the dd utility. If the user tries to
interrupt the script using Ctrl+C, display a message that this action will make the diskette
unusable.
See script ~/SCRIPTS/SIGNALS/createimages.sh

2. Wget http://.....
Tar xv (software name)
Trap echo SIGTERM SIGINT
Yum install y (software name).

END

44