Ubuntu Unleashed 2017 Edition (2017)

---

To store a string in a variable, you can use the following:

Use the preceding variable form if the string doesn’t have embedded spaces. If a string has embedded spaces, you can do the assignment as follows:

Accessing Variable Values

You can access the value of a variable by prefixing the variable name with a dollar sign ($). That is, if the variable name is var, you can access the variable by using $var.

If you want to assign the value of var to the variable lcount, you can do so as follows:

Positional Parameters

It is possible to pass options from the command line or from another shell script to your shell program.

These options are supplied to the shell program by Linux as positional parameters, which have special names provided by the system. The first parameter is stored in a variable called 1 (number 1) and can be accessed by using $1within the program. The second parameter is stored in a variable called 2 and can be accessed by using $2 within the program, and so on. One or more of the higher numbered positional parameters can be omitted while you’re invoking a shell program.

Understanding how to use these positional parameters and how to access and use variables retrieved from the command line is necessary when developing more advanced shell programs.

A Simple Example of a Positional Parameter

For example, if a shell program mypgm expects two parameters—such as a first name and a last name—you can invoke the shell program with only one parameter, the first name. However, you cannot invoke it with only the second parameter, the last name.

Here is a shell program called mypgm1, which takes only one parameter (a name) and displays it on the screen:

Click here to view code image

#!/bin/sh
#Name display program
if [ $# -eq 0 ]
then
echo "Name not provided"
else
echo "Your name is "$1
fi

If you execute mypgm1, as follows:

Click here to view code image

matthew@seymour:~$ bash mypgm1

you get the following output:

Name not provided

However, if you execute mypgm1, as follows:

Click here to view code image

matthew@seymour:~$ bash mypgm1 Heather

you get the this output:

Your name is Heather

The shell program mypgm1 also illustrates another aspect of shell programming: the built-in variables provided to the shell by the Linux kernel. In mypgm1, the built-in variable $# provides the number of positional parameters passed to the shell program. You learn more about working with built-in variables in the next major section of this chapter.

Using Positional Parameters to Access and Retrieve Variables from the Command Line

Using positional parameters in scripts can be helpful if you need to use command lines with piped commands requiring complex arguments. Shell programs containing positional parameters can be even more convenient if the commands are infrequently used. For example, if you use your Ubuntu system with an attached voice modem as an answering machine, you can write a script to issue a command that retrieves and plays the voice messages. The following lines convert a saved sound file (in .rmd or voice-phone format) and pipe the result to your system’s audio device:

Click here to view code image

#!/bin/sh
# play voice message in /var/spool/voice/incoming
rmdtopvf /var/spool/voice/incoming/$1 | pvfspeed -s 8000 | \
pvftobasic >/dev/audio

You can then easily play back a voice message using this script (perhaps named pmm):

Click here to view code image

matthew@seymour:~$ pmm name_of_message

Shell scripts that contain positional parameters are often used for automating routine and mundane jobs, such as system log report generation, file system checks, user resource accounting, printer use accounting, and other system, network, or security administration tasks.

Using a Simple Script to Automate Tasks

You could use a simple script, for example, to examine your system log for certain keywords. If the script is run via your system’s scheduling table, /etc/crontab, it can help automate security monitoring. By combining the output capabilities of existing Linux commands with the language facilities of the shell, you can quickly build a useful script to perform a task normally requiring a number of command lines. For example, you can create a short script, named greplog, like this:

Click here to view code image

#!/bin/sh
# name: greplog
# use: mail grep of designated log using keyword
# version: v.01 08aug02
#
# author: bb
#
# usage: greplog [keyword] [logpathname]
#
# bugs: does not check for correct number of arguments

# build report name using keyword search and date
log_report=/tmp/$1.logreport.`date '+%m%d%y'`

# build report header with system type, hostname, date and time
echo "==============================================================" \
>$log_report
echo " S Y S T E M M O N I T O R L O G" >>$log_report
echo uname -a >>$log_report
echo "Log report for" `hostname -f` "on" `date '+%c'` >>$log_report
echo "==============================================================" \
>>$log_report ; echo "" >>$log_report

# record log search start
echo "Search for->" $1 "starting" `date '+%r'` >>$log_report
echo "" >>$log_report

# get and save grep results of keyword ($1) from logfile ($2)
grep -i $1 $2 >>$log_report

# build report footer with time
echo "" >>$log_report
echo "End of" $log_report at `date '+%r'` >>$log_report

# mail report to root
mail -s "Log Analysis for $1" root <$log_report

# clean up and remove report
rm $log_report
exit 0

In this example, the script creates the variable $log_report, which will be the filename of the temporary report. The keyword ($1) and first argument on the command line is used as part of the filename, along with the current date (with perhaps a better approach to use $$ instead of the date, which will append the script’s PID as a file extension). Next, the report header containing some formatted text, the output of the uname command, and the hostname and date is added to the report. The start of the search is then recorded, and any matches of the keyword in the log are added to the report. A footer containing the name of the report and the time is then added. The report is mailed to root with the search term as the subject of the message, and the temporary file is deleted.

You can test the script by running it manually and feeding it a keyword and a pathname to the system log, /var/log/messages, like this:

Click here to view code image

matthew@seymour:~# greplog FAILED /var/log/messages

Note that your system should be running the syslogd daemon. If any login failures have occurred on your system, the root operator might get an email message that looks like this:

Click here to view code image

Date: Sun, 23 Oct 2016 16:23:24 -0400
From: root <root@righthere.home.org>
To: root@righthere.home.org
Subject: FAILED

==============================================================
S Y S T E M M O N I T O R L O G
Linux system 4.4.0-22-generic #1 Sun Oct 9 20:21:24 EDT 2016
+GNU/Linux
Log report for righthere.home.org on Sun 23 Oct 2016 04:23:24 PM EDT
==============================================================

Search for-> FAILED starting 04:23:24 PM

Oct 23 16:23:04 righthere login[1769]: FAILED LOGIN 3 FROM (null) FOR bball,
+Authentication failure

End of /tmp/FAILED.logreport.102303 at 04:23:24 PM

To further automate the process, you can include command lines using the script in another script to generate a series of searches and reports.

Built-In Variables

Built-in variables are special variables provided to shell by Linux that you can use to make decisions within a shell program. You cannot modify the values of these variables within the shell program.

Some of these variables are:

$#—Number of positional parameters passed to the shell program

$?—Completion code of the last command or shell program executed within the shell program (returned value)

$0—The name of the shell program

$*—A single string of all arguments passed at the time of invocation of the shell program

To show these built-in variables in use, here is a sample program called mypgm2:

Click here to view code image

#!/bin/sh
#my test program
echo "Number of parameters is $#"
echo "Program name is $0"
echo "Parameters as a single string is $*"

If you execute mypgm2 from the command line in pdksh and bash as follows:

Click here to view code image

matthew@seymour:~$ bash mypgm2 Sanjiv Guha

you get the following result:

Click here to view code image

Number of parameters is 2
Program name is mypgm2
Parameters as a single string is Sanjiv Guha

Special Characters

Some characters have special meaning to Linux shells; these characters represent commands, denote specific use for surrounding text, or provide search parameters. Special characters provide a sort of shorthand by incorporating these rather complex meanings into a simple character. Some special characters are shown in Table 14.2.

TABLE 14.2 Special Shell Characters

Special characters are very useful to you when you’re creating shell scripts, but if you inadvertently use a special character as part of variable names or strings, your program behaves incorrectly. As you learn in later parts of this section, you can use one of the special characters in a string if you precede it with an escape character (\, or backslash) to indicate that it isn’t being used as a special character and shouldn’t be treated as such by the program.

A few special characters deserve special note. They are the double quotes (“), the single quotes (’), the backslash (\), and the backtick (`)—all discussed in the following sections.

Using Double Quotes to Resolve Variables in Strings with Embedded Spaces

If a string contains embedded spaces, you can enclose the string in double quotes (“) so that the shell interprets the whole string as one entity instead of more than one.

For example, if you assigned the value of abc def (abc followed by one space, followed by def) to a variable called x in a shell program as follows, you would get an error because the shell would try to execute def as a separate command:

The shell executes the string as a single command if you surround the string in double quotes as follows:

The double quotes resolve all variables within the string. Here is an example for pdksh and bash:

var="test string"
newvar="Value of var is $var"
echo $newvar

Here is the same example for tcsh:

Click here to view code image

set var="test string"
set newvar="Value of var is $var"
echo $newvar

If you execute a shell program containing the preceding three lines, you get the following result:

Value of var is test string

Using Single Quotes to Maintain Unexpanded Variables

You can surround a string with single quotes (’) to stop the shell from expanding variables and interpreting special characters. When used for the latter purpose, the single quote is an escape character, similar to the backslash, which you learn about in the next section. Here, you learn how to use the single quote to avoid expanding a variable in a shell script. An unexpanded variable maintains its original form in the output.

In the following examples, the double quotes in the preceding examples have been changed to single quotes:

Click here to view code image

pdksh and bash:
var='test string'
newvar='Value of var is $var'
echo $newvar
tcsh:
set var = 'test string'
set newvar = 'Value of var is $var'
echo $newvar

If you execute a shell program containing these three lines, you get the following result:

Value of var is $var

As you can see, the variable var maintains its original format in the results, rather than having been expanded.

Using the Backslash as an Escape Character

As you learned earlier, the backslash (\) serves as an escape character that stops the shell from interpreting the succeeding character as a special character. Say that you want to assign a value of $test to a variable called var. If you use the following command, the shell reads the special character $ and interprets $test as the value of the variable test. No value has been assigned to test; a null value is stored in var as follows:

Unfortunately, this assignment might work for bash and pdksh, but it returns an error of “undefined variable” if you use it with tcsh. Use the following commands to correctly store $test in var:

The backslash before the dollar sign (\$) signals the shell to interpret the $ as any other ordinary character and not to associate any special meaning to it. You could also use single quotes (') around the $test variable to get the same result.

Using the Backtick to Replace a String with Output

You can use the backtick (`) character to signal the shell to replace a string with its output when executed. This is called command substitution. You can use this special character in shell programs when you want the result of the execution of a command to be stored in a variable. For example, if you want to count the number of lines in a file called test.txt in the current directory and store the result in a variable called var, you can use the following command:

Comparison of Expressions in pdksh and bash

Comparing values or evaluating the differences between similar bits of data—such as file information, character strings, or numbers—is a task known as comparison of expressions. Comparison of expressions is an integral part of using logic in shell programs to accomplish tasks. The way the logical comparison of two operators (numeric or string) is done varies slightly in different shells. In pdksh and bash, a command called test can be used to achieve comparisons of expressions. In tcsh, you can write an expression to accomplish the same thing.

This section covers comparison operations using the pdksh or bash shells. Later in the chapter, you learn how to compare expressions in the tcsh shell.

The pdksh and bash shell syntax provide a command named test to compare strings, numbers, and files. The syntax of the test command is as follows:

test expression
or
[ expression ]

Both forms of the test commands are processed the same way by pdksh and bash. The test commands support the following types of comparisons:

String comparison

Numeric comparison

File operators

Logical operators

String Comparison

You can use the following operators to compare two string expressions:

=—To compare whether two strings are equal

!=—To compare whether two strings are not equal

-n—To evaluate whether the string length is greater than zero

-z—To evaluate whether the string length is equal to zero

Next are some examples using these operators when comparing two strings, string1 and string2, in a shell program called compare1:

Click here to view code image

#!/bin/sh
string1="abc"
string2="abd"
if [ $string1 = $string2 ]; then
echo "string1 equal to string2"
else
echo "string1 not equal to string2"
fi

if [ $string2 != string1 ]; then
echo "string2 not equal to string1"
else
echo "string2 equal to string2"
fi

if [ $string1 ]; then
echo "string1 is not empty"
else
echo "string1 is empty"
fi

if [ -n $string2 ]; then
echo "string2 has a length greater than zero"
else
echo "string2 has length equal to zero"
fi

if [ -z $string1 ]; then
echo "string1 has a length equal to zero"
else
echo "string1 has a length greater than zero"
fi

If you execute compare1, you get the following result:

Click here to view code image

string1 not equal to string2
string2 not equal to string1
string1 is not empty
string2 has a length greater than zero
string1 has a length greater than zero

If two strings are not equal in size, the system pads out the shorter string with trailing spaces for comparison. That is, if the value of string1 is "abc" and that of string2 is "ab", string2 is padded with a trailing space for comparison purposes; it has a value of "ab " (with a space after the letters).

Number Comparison

The following operators can be used to compare two numbers:

-eq—To compare whether two numbers are equal

-ge—To compare whether one number is greater than or equal to the other number

-le—To compare whether one number is less than or equal to the other number

-ne—To compare whether two numbers are not equal

-gt—To compare whether one number is greater than the other number

-lt—To compare whether one number is less than the other number

The following shell program compares three numbers, number1, number2, and number3:

Click here to view code image

#!/bin/sh
number1=5
number2=10
number3=5

if [ $number1 -eq $number3 ]; then
echo "number1 is equal to number3"
else
echo "number1 is not equal to number3"
fi

if [ $number1 -ne $number2 ]; then
echo "number1 is not equal to number2"
else
echo "number1 is equal to number2"
fi

if [ $number1 -gt $number2 ]; then
echo "number1 is greater than number2"
else
echo "number1 is not greater than number2"
fi

if [ $number1 -ge $number3 ]; then
echo "number1 is greater than or equal to number3"
else
echo "number1 is not greater than or equal to number3"
fi

if [ $number1 -lt $number2 ]; then
echo "number1 is less than number2"
else
echo "number1 is not less than number2"
fi

if [ $number1 -le $number3 ]; then
echo "number1 is less than or equal to number3"
else
echo ""number1 is not less than or equal to number3"
fi

When you execute the shell program, you get the following results:

Click here to view code image

number1 is equal to number3
number1 is not equal to number2
number1 is not greater than number2
number1 is greater than or equal to number3
number1 is less than number2
number1 is less than or equal to number3

File Operators

You can use the following operators as file comparison operators:

-d—To ascertain whether a file is a directory

-f—To ascertain whether a file is a regular file

-r—To ascertain whether read permission is set for a file

-s—To ascertain whether a file exists and has a length greater than zero

-w—To ascertain whether write permission is set for a file

-x—To ascertain whether execute permission is set for a file

Assume that a shell program called compare3 is in a directory with a file called file1 and a subdirectory dir1 under the current directory. Assume that file1 has a permission of r-x (read and execute permission) and dir1has a permission of rwx (read, write, and execute permission). The code for the shell program would look like this:

Click here to view code image

#!/bin/sh
if [ -d $dir1 ]; then
echo ""dir1 is a directory"
else
echo ""dir1 is not a directory"
fi

if [ -f $dir1 ]; then
echo ""dir1 is a regular file"
else
echo ""dir1 is not a regular file"
fi

if [ -r $file1 ]; then
echo ""file1 has read permission"
else
echo ""file1 does not have read permission"
fi

if [ -w $file1 ]; then
echo ""file1 has write permission"
else
echo ""file1 does not have write permission"
fi

if [ -x $dir1 ]; then
echo ""dir1 has execute permission"
else
echo ""dir1 does not have execute permission"
fi

If you execute the shell program, you get the following results:

Click here to view code image

dir1 is a directory
file1 is a regular file
file1 has read permission
file1 does not have write permission
dir1 has execute permission

Logical Operators

You use logical operators to compare expressions using Boolean logic, which compares values using characters representing NOT, AND, and OR:

!—To negate a logical expression

-a—To logically AND two logical expressions

-o—To logically OR two logical expressions

This example named logic uses the file and directory mentioned in the previous compare3 example:

Click here to view code image

#!/bin/sh
if [ -x file1 -a -x dir1 ]; then
echo file1 and dir1 are executable
else
echo at least one of file1 or dir1 are not executable
fi

if [ -w file1 -o -w dir1 ]; then
echo file1 or dir1 are writable
else
echo neither file1 or dir1 are executable
fi

if [ ! -w file1 ]; then
echo file1 is not writable
else
echo file1 is writable
fi

If you execute logic, it will yield the following result:

file1 and dir1 are executable
file1 or dir1 are writable
file1 is not writable

Comparing Expressions with tcsh

As stated earlier, the method for comparing expressions in tcsh is different from the method used under pdksh and bash. The comparison of expression demonstrated in this section uses the syntax necessary for the tcsh shell environment.

String Comparison

You can use the following operators to compare two string expressions:

==—To compare whether two strings are equal

!=—To compare whether two strings are not equal

The following examples compare two strings, string1 and string2, in the shell program compare1:

Click here to view code image

#!/bin/tcsh
set string1 = "abc"
set string2 = ""abd"

if (string1 == string2) then
echo "string1 equal to string2"
else
echo ""string1 not equal to string2"
endif

if (string2 != string1) then
echo ""string2 not equal to string1"
else
echo ""string2 equal to string1"
endif

If you execute compare1, you get the following results:

string1 not equal to string2
string2 not equal to string1

Number Comparison

You can use the following operators to compare two numbers:

>=—To compare whether one number is greater than or equal to the other number

<=—To compare whether one number is less than or equal to the other number

>—To compare whether one number is greater than the other number

<—To compare whether one number is less than the other number

The next examples compare three numbers, number1, number2, and number3, in a shell program called compare2:

Click here to view code image

#!/bin/tcsh
set number1=5
set number2=10
set number3=5

if (number1 > number2) then
echo "number1 is greater than number2"
else
echo "number1 is not greater than number2"
endif

if (number1 >= number3) then
echo "number1 is greater than or equal to number3"
else
echo ""number1 is not greater than or equal to number3"
endif

if (number1 < number2) then
echo ""number1 is less than number2"
else
echo ""number1 is not less than number2"
endif

if (number1 <= number3) then
echo ""number1 is less than or equal to number3"
else
echo ""number1 is not less than or equal to number3"
endif

When executing the shell program compare2, you get the following results:

Click here to view code image

number1 is not greater than number2
number1 is greater than or equal to number3
number1 is less than number2
number1 is less than or equal to number3

File Operators

You can use the following operators as file comparison operators:

-d—To ascertain whether a file is a directory

-e—To ascertain whether a file exists

-f—To ascertain whether a file is a regular file

-o—To ascertain whether a user is the owner of a file

-r—To ascertain whether read permission is set for a file

-w—To ascertain whether write permission is set for a file

-x—To ascertain whether execute permission is set for a file

-z—To ascertain whether the file size is zero

The following examples are based on a shell program called compare3, which is in a directory with a file called file1 and a subdirectory dir1 under the current directory. Assume that file1 has a permission of r-x (read and execute permission) and dir1 has a permission of rwx (read, write, and execute permission).

The following is the code for the compare3 shell program:

Click here to view code image

#!/bin/tcsh
if (-d dir1) then
echo "dir1 is a directory"
else
echo "dir1 is not a directory"
endif

if (-f dir1) then
echo "file1 is a regular file"
else
echo "file1 is not a regular file"
endif

if (-r file1) then
echo "file1 has read permission"
else
echo "file1 does not have read permission"
endif

if (-w file1) then
echo "file1 has write permission"
else
echo "file1 does not have write permission"
endif

if (-x dir1) then
echo "dir1 has execute permission"
else
echo "dir1 does not have execute permission"
endif

if (-z file1) then
echo "file1 has zero length"
else
echo "file1 has greater than zero length"
endif

If you execute the file compare3, you get the following results:

Click here to view code image

dir1 is a directory
file1 is a regular file
file1 has read permission
file1 does not have write permission
dir1 has execute permission
file1 has greater than zero length

Logical Operators

You use logical operators with conditional statements. You use the following operators to negate a logical expression or to perform logical ANDs and ORs:

!—To negate a logical expression

&&—To logically AND two logical expressions

||—To logically OR two logical expressions

This example named logic uses the file and directory mentioned in the previous compare3 example:

Click here to view code image

#!/bin/tcsh
if ( -x file1 && -x dir1 ) then
echo file1 and dir1 are executable
else
echo at least one of file1 or dir1 are not executable
endif

if ( -w file1 || -w dir1 ) then
echo file1 or dir1 are writable
else
echo neither file1 or dir1 are executable
endif

if ( ! -w file1 ) then
echo file1 is not writable
else
echo file1 is writable
endif

If you execute logic, it yields the following result:

file1 and dir1 are executable
file1 or dir1 are writable
file1 is not writable

The for Statement

You use the for statement to execute a set of commands once each time a specified condition is true. The for statement has a number of formats. The first format used by pdksh and bash is as follows:

for curvar in list
do
statements
done

You should use this form if you want to execute statements once for each value in list. For each iteration, the current value of the list is assigned to vcurvar. list can be a variable containing a number of items or a list of values separated by spaces. The second format is as follows:

for curvar
do
statements
done

In this form, the statements are executed once for each of the positional parameters passed to the shell program. For each iteration, the current value of the positional parameter is assigned to the variable curvar.

You can also write this form as follows:

for curvar in $
do
statements
done

Remember that $@ gives you a list of positional parameters passed to the shell program, quoted in a manner consistent with the way the user originally invoked the command.

Under tcsh, the for statement is called foreach. The format is as follows:

foreach curvar (list)
statements
end

In this form, statements are executed once for each value in list, and, for each iteration, the current value of list is assigned to curvar.

Suppose that you want to create a backup version of each file in a directory to a subdirectory called backup. You can do the following in pdksh and bash:

Click here to view code image

#!/bin/sh
for filename in *
do
cp $filename backup/$filename
if [ $? -ne 0 ]; then
echo "copy for $filename failed"
fi
done

In the preceding example, a backup copy of each file is created. If the copy fails, a message is generated.

The same example in tcsh is as follows:

Click here to view code image

#!/bin/tcsh
foreach filename (`/bin/ls`)
cp $filename backup/$filename
if ($? != 0) then
echo "copy for $filename failed"
endif
end

The while Statement

You can use the while statement to execute a series of commands while a specified condition is true. The loop terminates as soon as the specified condition evaluates to false. It is possible that the loop will not execute at all if the specified condition initially evaluates to false. You should be careful with the while command because the loop never terminates if the specified condition never evaluates to false.