We also provide you with a PDF file that has color images of the screenshots/diagrams used in this book. The color images will help you better understand the changes in the output. You can download this file from https://www.packtpub.com/sites/default/files/downloads/LearningLinuxShellScripting_ColorImages.pdf.

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books—maybe a mistake in the text or the code—we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title.

To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the book in the search field. The required information will appear under the Errata section.

Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

Please contact us at <copyright@packtpub.com> with a link to the suspected pirated material.

We appreciate your help in protecting our authors and our ability to bring you valuable content.

If you have a problem with any aspect of this book, you can contact us at <questions@packtpub.com>, and we will do our best to address the problem.

The following are the commands for changing the file permissions:

To check the file permission, give the following command:

$ ll file_name

The details of file permissions are as seen in the following image:

In the preceding diagram, as we can see, permissions are grouped in owner-user and group and other users' permissions. Permissions are of three types such as read, write, and execute permissions. As per the requirement, we may need to change permissions of the various files.

We can change the file or directory permissions by the following two ways:

$ chmod ugo+rwx file_name

$ chmod +rwx file_name

$ chmod +rwx file_name

We will see how Linux decides the default permissions of the newly created file or folder:

$ umask
0002

The meaning of the preceding output is that, if we create a new directory, then from the permissions of +rwx, the permission 0002 will be subtracted. This means that for a newly created directory, the permissions will be 775 or rwx rwx r-x. For a newly created file, the file permissions will be rw- rw- r--. By default, for any newly created text file, the execute bit will never be set. Therefore, the newly created text file and directory will have different permissions even though the umask is same.

Another very interesting functionality is the setuid feature. If the setuid bit is set for a script, then the script will always run with the owner's privileges irrespective of which user is running the script. If the administrator wants to run script written by him by other users, then he can set this bit.

Consider either of the following situations:

$ chmod u+s file_name
$ chmod 4777 file

The file permissions after any of the preceding two commands will be drwsrwxrwx.

Similar to setuid, the setgid functionality gives the user the ability to run scripts with group owner's privileges, even if it is executed by any other user.

$ chmod g+s filename

Alternatively, you can use the following command:

$ chmod 2777 filename

File permissions after any of the preceding two commands will be drwxrwsrwtx.

Sticky bit is a very interesting functionality. Let's say, in the administration department there are 10 users. If one folder has been set with sticky bit, then all other users can copy files to that folder. All users can read the files, but only the owner of the respective file can edit or delete the file. Other user can only read but not edit or modify the files if the sticky bit is set.

$ chmod +t filename

Alternatively, you can use the following command:

$ chmod 1777

File permissions after any of the preceding two commands will be drwxrwxrwt.

All I/O, including files, pipes, and sockets, are handled by the kernel via a mechanism called the file descriptor. A file descriptor is a small unsigned integer, an index into a file-descriptor table maintained by the kernel and used by the kernel to reference open files and I/O streams. Each process inherits its own file-descriptor table from its parent. The first three file descriptors are 0, 1, and 2. File descriptor 0 is standard input (stdin), 1 is standard output (stdout), and 2 is standard error (stderr). When you open a file, the next available descriptor is 3, and it will be assigned to the new file.

When a file descriptor is assigned to something other than a terminal, it is called I/O redirection. The shell performs redirection of output to a file by closing the standard output file descriptor 1 (the terminal) and then assigning that descriptor to the file. When redirecting standard input, the shell closes file descriptor 0 (the terminal) and assigns that descriptor to a file. The Bash shells handle errors by assigning a file to the file descriptor 2.

The following command will take input from the sample.txt file:

$ wc  <  sample.txt

The preceding command will take content from the sample.text file. The wc command will print the number of lines, words, and characters in the sample.txt file.

$ echo "Hello world" > log.txt

This command will redirect output to be saved in the log.txt file.

$ echo "Welcome to Shell Scripting" >> log.txt

This command will append the Hello World text in the log.txt file.

The single > will overwrite or replace the existing text in log file. And double >> will append the text in the log file.

Let's see a few more examples:

$ tr '[A-Z]' '[a-z]' < sample.txt

The preceding tr command will read text from the sample.txt file. The tr command will convert all uppercase letters to lower case letters and will print converted text on screen:

$ ls > log.txt
$ cat log.txt

The output of command will be as follows:

dir_1
sample.txt
extra.file

In this example command, ls is sending directory content to file log.txt. Whenever we want to store the result of the command in the file, we can use the preceding example.

$ date >> log.txt
$ cat log.txt

Output:

dir_1
dir_2
file_1
file_2
file_3
Sun Sept 17 12:57:22 PDT 2004

In the preceding example, we are redirecting and appending the result of the date command to the log.txt file.

$ gcc hello.c 2> error_file

The gcc is a C language compiler program. If an error is encountered during compilation, then it will be redirected to error_file. The > character is used for a success result and 2> is used for error results redirection. We can use error_file for debugging purposes:

$ find . –name "*.sh" > success_file 2> /dev/null

In the preceding example, we are redirecting output or success results to success_file and errors to /dev/null. /dev/null is used to destroy the data, which we do not want to be shown on screen.

$ find . –name "*.sh" &> log.txt

The preceding command will redirect both output and error to log.txt.

$ find . –name "*.sh"  > log.tx 2>&1

The preceding command will redirect result to log.txt and send errors to where the output is going, such as log.txt.

$ echo "File needs an argument" 1>&2

The preceding command will send a standard output to the standard error. This will merge the output with the standard error.

The summary of all I/O redirection commands will be as follows:

The following is the summary of various metacharacters:

Run the following command:

$ touch filea fileb filec fileab filebc filead filebd filead
$ touch file{1,2,3}

Try the following command out:

$ ls  s*
$ ls  file
$ ls  file[abc]
$ ls  file[abc][cd]
$ ls  file[^bc]
$ touch file file1 file2 file3 … file20
$ ls ?????
file1
file2
file3
$ ls file*
file file1 file10 file2 file3
$ ls file[0-9]
file1 file2 file3
$ ls file[0-9]*
file1 file10 file2 file3
$ ls file[!1-2]
file3

Curly braces allow you to specify a set of characters from which the shell automatically forms all possible combinations. To make this work, the characters to be combined with the given string must be specified as a comma separated list with no spaces:

$ touch file{1,2,3}
$ ls

$ mkdir directory{1,2,3}{a,b,c}
$ ls

$ touch file{a..z}
$ ls

The following is the summary of various io-redirection and logical operators:

For example:

$ ls || echo "Command un-successful"
$ ls a abcd || echo "Command un-successful"

These commands will print Command un-successful if the ls command is unsuccessful.

A command line can consist of multiple commands. Each command is separated by a semicolon, and the command line is terminated with a newline. The exit status is that of the last command in the chain of commands.

The first command is executed, and the second one is started as soon as the first one has finished.

$ w; date

Output:

$ w ; date > whoandwhen

Output of the date command will be redirected to the whoandwhen file.

In the preceding example, we can see that when we put multiple commands on the same line, but separated by the ";" command, then those commands execute sequentially one by one.

$ date; who am i
Tue Mar 10 23:21:38 PDT 201
student  pts/0        2015-03-10 23:12 (:0.0)

In the preceding example, the date command is executed first and the who am I command will be executed next. Both the commands are typed on same lines, separated by the ";" " command.

Commands may also be grouped so that all of the output is either piped to another command or redirected to a file.

$ ( ls; pwd; date ) > outputfile

The output of each of the commands is sent to the file called outputfile. The spaces inside the parentheses are necessary.

$ ( w ; date ) > whoandwhen

The output of the w command and date will be redirected to the whoandwhen file:

$ (echo "***x.c***";cat x.c) > log.txt

Output:

This redirects the content of x.c with a heading ***x.c*** to the file out.

$ (pwd; ls; date) > log.txt

Output:

This redirects output of commands pwd, ls, and date in the log.txt file.

The first command is started in the background to continue until it has finished; immediately after starting first command, the second command is started and it will run in the foreground:

$ find / -name "*.z" & s
----------------     -----
Command1            command2

In the preceding example, first command such as find will start running in the background and while the find command is running in background, the ls command will start running in foreground.

The second command is only started if the first command is successful. To achieve this, the shell checks the exit (return) status of the first command and starts the second command only if and when that exit status is found to be "0".

$ ls /home/ganesh  &&  echo "Command executed successfully"
Since we are working as user ganesh,
$ ls /root  && echo "Command executed successfully"

Since we are working as a normal user, we cannot access the /root directory. Therefore, nothing will be printed on screen.

The second command is only started if the first command fails. The shell checks the exit status of the first command and starts the second command only if that exit status is not equal to "0".

$ ls /root  ||  echo "Command execution failed"

Example:

$ ls || echo "command ls failed"

In the preceding example, if ls runs successfully, then echo will not be called. If the ls command fails such as $ ls /root and if user is not root, then ls will fail and the echo command will print command ls failed.

When && or || are used, the exit status of the first command is checked first, then the decision to perform the next will be taken.

For example:

$ ls
$ echo $?
  0
$ ls /root
    ls: /root: Permission denied
$ echo $?
  1
$ tar cvzf /dev/st0 /home /etc | | mail -s "Something went wrong with the backup" root

If we give the command as follows:

$ cd /home/student/work/temp/; rm –rf *

Initially, the shell will change to the /home/student/work/temp folder, and then it will delete all files and folders.

If we give the command as follows:

cd /backup/ol/home/student/work/temp/ && rm * -rf

This will first change to the required folder, and then the rm command will be called for deletion. The problem with ";" is that even if the shell fails to change to the required folder, the rm command will execute and it will delete all the files and folders from your original folder. This will be really dangerous.

For example:

$ [[ "a" = "b" ]]; echo ok
ok

In this case, the [[ ]] expression will evaluate to false. Since the semicolon will not check the status of the earlier command, ok will be printed even if the first [[ ]] fails.

$ [[ "a" = "b" ]] && echo ok

In this case, the [[ ]] expression will evaluate to false. As the first expression is false, the "&&" operator will not proceed to execute the next command.

In this case, ok will be printed only if [[ ]] is true.

In the current shell, we can create and store user defined variables. These may contain characters, digits, and "_". A variable should not start with a digit. Normally for environment variables, upper case characters are used.

If we create a new variable, it will not be available in subshells. The newly created variable will be available only in the current shell. If we run Shell script, then local variables will not be available in the commands called by Shell script. Shell has one special variable $$. This variable contains the process ID of the current shell.

Let's try a few commands:

$ echo $$
1234

This is the process ID of the current shell.

$ name="Ganesh Naik"
$ echo $name
Ganesh Naik

We declared the variable name and initialized it.

$ bash

This command will create a new subshell.

$ echo $$
1678

This is the process ID of the newly created subshell.

$ echo $name

Nothing will be displayed, as the local variables from the parent shell are not inherited in the newly created child shell or subshell:

$ exit

We will exit the subshell and return to the original shell terminal.

$ echo $$
1234

This is the process ID of the current shell or parent shell.

$ echo $name
Ganesh Naik

This is displaying the variable's presence in the original shell or parent shell.

Variables created in the current shell will not be available in a subshell or child shell. If we need to use a variable in a child shell, then we need to export them using the export command.

Using the export command, we are making variables available in the child process or subshell. But if we declare new variables in the child process and export it in the child process, the variable will not be available in parent process. The parent process can export variables to child, but the child process cannot export variables to the parent process.

Whenever we create a Shell script and execute it, a new shell process is created and the Shell script runs in that process. Any exported variable values are available to the new shell or to any subprocess.

We can export any variable as follows:

$ export NAME

Or:

$ declare -x NAME

Let's understand the concept of exporting the variable by the following example:

$ PERSON="Ganesh Naik"
$ export PERSON
$ echo $PERSON
Ganesh Naik
$ echo $$
515

The process ID of the current shell or parent shell is 515.

$ bash

This will start a subshell.

$ echo $$
555

This is the process ID of new or subshell.

$ echo $PERSON
Ganesh Naik
$ PERSON="Author"
$ echo $PERSON
Author
$ exit

This will terminate the subshell, and will be placed in the parent shell.

$ echo $$
515

This is the process ID of the parent shell.

$ echo $PERSON
Author

Let's write Shell script to use the concept we learned:

# Ubuntu Timezone files location : /usr/share/zoneinfo/
# redhat "/etc/localtime"  instead of "/etc/timezone"
# In Redhat
# ln -sf /usr/share/zoneinfo/America/Los_Angeles /etc/localtime

export TZ=America/Los_Angeles
echo "Your Timezone is = $TZ"
date
export TZ=Asia/Tokyo
echo "Your Timezone is = $TZ"
date

unset TZ

echo "Your Timezone is = $(cat /etc/timezone)"
# For Redhat or Fedora /etc/localtime
date

The date command checks the TZ environmental variable. We initialized the TZ for Los_Angeles, then to Tokyo, and then finally we removed it. We can see the difference in the date command output.

Let's write another Shell script to study the parent and child process and exportation of variables.

Create the export1.sh Shell script:

#!/bin/bash
foo="The first variable foo"
export bar="The second variable bar"
./export2.sh

Create another shell script export2.sh
#!/bin/bash
echo "$foo"
echo "$bar"

The Shell script export1.sh runs as a parent process and export2.sh is started as a child process of export1.sh. We can clearly observe that the variable bar, which was exported, is available in the child process; but variable foo, which was not exported, is not available in the child process.

Many times we may not pass arguments on the command line, but we may need to set parameters internally inside the script.

We can declare parameters by the set command as follows:

$ set USA Canada UK France
$ echo $1
USA
$ echo $2
Canada
$ echo $3
UK
$ echo $4
France

We can use this inside the set_01.sh script as follows:

#!/bin/bash
set USA Canada UK France
echo $1
echo $2
echo $3
echo $4

Run the script as:

$ ./set.sh

Output:

USA
Canada
UK
France

We give commands as follows:

set One Two Three Four Five
echo $0      # This will show command
echo $1       # This will show first parameter
echo $2
echo $*    # This will list all parameters
echo $#    # This will list total number of parameters
echo ${10} ${11}  # Use this syntax for parameters for 10th and
         # 11th parameters

Let us write script set_02.sh as follows:

#!/bin/bash
echo The date is $(date)
set $(date)
echo The month is $2
exit 0

Output:

In the script $(date), the command will execute and the output of that command will be used as $1, $2, $3 and so on. We have used $2 to extract the month from the output.

Let's write script set_03.sh as follows:

#!/bin/bash

echo "Executing script $0"
echo $1 $2 $3

set eins zwei drei
echo "One two three in German are:"
echo "$1"
echo  "$2"
echo  "$3"

textline="name phone address birthdate salary"
set $textline
echo  "$*"
echo 'At this time $1 = ' $1 'and $4 = ' $4

Output:

In this script, the following output shows:

Using shift, we can change the parameter to which $1 and $2 are pointing to the next variable.

Create a script shift_01.sh as follows:

#!/bin/bash
echo "All Arguments Passed are as follow : "
echo $*
echo "Shift By one Position :"
shift
echo "Value of Positional Parameter $ 1 after shift :"
echo $1
echo "Shift by Two Positions :"
shift 2
echo "Value of Positional Parameter $ 1 After two Shifts :"
echo $1

Execute the command as follows:

$ chmod +x shift_01.sh
$ ./shift_01.sh One Two Three Four

Output:

student@ubuntu$ ./shift_01.sh One Two Three Four

All arguments passed are as follows:

One Two Three Four

Shift by one position.

Here, the value of the positional parameter $1 after shift is:

Two

Shift by two positions.

The value of the positional parameter $1 after two shifts:

Four

We observed that initially $1 was One. After shift, $1 will be pointing to Two. Once shift is done, the value in position 1 is always destroyed and is inaccessible.

Create a shift_02.sh script as follows:

#!/bin/bash

echo '$#: ' $#
echo '$@: ' $@
echo '$*: ' $*
echo
echo '$1 $2 $9 $10 are: ' $1 $2 $9 $10
echo

shift
echo '$#: ' $#
echo '$@: ' $@
echo '$*: ' $*
echo
echo '$1 $2 $9 are: ' $1 $2 $9

shift 2
echo '$#: ' $#
echo '$@: ' $@
echo '$*: ' $*
echo
echo '$1 $2 $9 are: ' $1 $2 $9

echo '${10}: ' ${10}

In this script execution, the following output shows:

set Alan John Dennis

oldargs=$*

set $oldargs

You will learn about creating an array in the Bash shell.

If the array name is FRUIT, then we can create an array as follows:

FRUIT[index]=value

Index is the integer value. It should be 0 or any positive integer value.

We can also create an array as follows:

$ declare -a array_name
$ declare -a arrayname=(value1 value2 value3)

Example:

$ declare -a fruit=('Mango' 'Banana' 'Apple' 'Orange' 'Papaya')
$ declare -a array_name=(word1 word2 word3 ...)
$ declare -a fruit=( Pears Apple Mango Banana Papaya )
$ echo ${fruit[0]}
Pears
$ echo ${fruit[1]}
Apple
$ echo "All the fruits are ${fruit[*]}"
    All the fruits are Pears Apple Mango Banana Papaya
$ echo "The number of elements in the array are ${#fruit[*]}"
    The number of elements in the array are 3
$ unset fruit  or unset ${fruit[*]}

Once we have initialized an array, we can access it as follows:

${array_name[index]}

We will create the script array_01.sh as follows:

#!/bin/bash

FRUIT[0]="Pears"
FRUIT[1]="Apple"
FRUIT[2]="Mango"
FRUIT[3]="Banana"
FRUIT[4]="Papaya"
echo "First Index: ${FRUIT[0]}"
echo "Second Index: ${FRUIT[1]}"

output:

$ chmod +x array_01.sh
$./array_01.sh
First Index: Pears
Second Index: Apple

To display all the items from the array, use the following commands:

${FRUIT[*]}
${FRUIT[@]}

Create an array_02.sh script as follows:

#!/bin/bash
FRUIT[0]="Pears"
FRUIT[1]="Apple"
FRUIT[2]="Mango"
FRUIT[3]="Banana"
FRUIT[4]="Papaya"
echo "Method One : ${FRUIT[*]}"
echo "Method Two : ${FRUIT[@]}"

Output:

$ chmod +x array_02.sh
$./ array_02.sh
Method One : Pears Apple Mango Banana Papaya
Method Two : Pears Apple Mango Banana Papaya

Let's see few more examples:

$ city[4]=Tokyo

The fourth member of the array, city, is being assigned Tokyo. Since it is the only element in the array, array the size will be 1.

$ echo ${city[*]}
Tokyo

The size of the array city is 1, since any other member of the array is not yet initialized.

${city[*]} will display the only element of the array city.

$ echo ${city[0]}

city[0] has no value, and neither does city[1] and city[2].

$ echo ${city[4]}
Tokyo

city[4] has the name of city as Tokyo.

$ countries=(USA  [3]=UK  [2]=Spain)

The array countries are being assigned USA at index 0, UK at index 3, and Spain at index 2. We can observe here that it does not matter in which sequence we are initializing the members of the array. They need not be in same sequence.

$ echo ${countries[*]}
USA Spain UK
$ echo ${countries[0]}
USA

The first element of the countries array is printed.

$ echo ${countries[1]}

There is nothing stored in countries [1].

$ echo ${countries[2]}
Spain

The third element of the countries array, countries [2], was assigned Spain.

$ echo ${countries[3]}
UK

The fourth element of the countries array, countries [3], was assigned UK.

Let's write script for using the sort command along with the here document:

In this script, the here document is enclosed between the EOF pattern. We have used the here document to supply text to the sort command.

Let's write script for using the wc command along with the here document:

In this script, we have used the here document as an input for the wc command to calculate the number of words:

Tape backup using << here operator

Let's write a script for taking the tape backup by using the tar command and the here document:

This script uses the tar command to archive the home folder in the tape device, and then it sends mail to an administrator using the command mail. We have used the here document to feed data into the command mail.

The ed is a basic type of editor. We can edit text files using this editor:

In this script, we have used passed the here document to utility for editing the file flowers.txt. We replaced the Rose word with Lily.

All the users who are logged in will receive the message using the wall command:

The command wall is used to send messages to the logged-in users. All the users that are logged in will receive the message.

FTP is a commonly used protocol to transfer data on websites. FTP stands for File Transfer Protocol. The following steps show the usage of FTP and data transfer:

For a successful execution of the script, we need to set up an autologin for the ftp command. The here operator does not work well when the ftp command asks for a username and password.

Enter the following script to see how to avoid a variable substitution in these files:

This script uses an ordinary here file, but it turns off the variable substitution. Otherwise, you would see the values of $HOME, $filename, and $USER in the output instead of the literal text. All of this is done by magically enclosing the end marker, Quoted_End_Marker, in quotes at the original reference. Do not enclose the marker in quotes at the end of the here file.

The exec command is very interesting. Whenever we run any command in shell, the new subshell or process gets created, and the command runs in this newly created process. When we run any command as argument to the exec command, exec will replace the current shell with the command to be executed. It does not create or spawn a new process to run the command.

exec fd > output.txt

exec fd<&-

exec 5<&-

Let's understand the opening, closing, and writing of a file.

Write a Shell script file_01.sh, shown as follows:

#!/bin/bash
# We will open file for writing purpose
# We are assigning descriptor number 3 for file sample_out.txt
exec 3> sample_out.txt

# We are sending output of command "echo" to sample_out.txt file
echo "This is a test message for sample_out.txt file" >&3

# Run command date & store output in file sample_out.txt
date >&3

# Closing file with file descriptor 3
exec 3<&-

Save the file, give the permission to execute, and run the script as follows:

$ chmod u+x file_01.sh
$ ./file_01.sh
$ cat sample_out.txt

Output:

This is a test message for sample_out.txt file
Tue Sep 29 23:19:22 IST 2015

Let's write script to read from a file:

Write the script file_02.sh, shown as follows:

#!/bin/bash
# We will open file sample_input.txt for reading purpose.
# We are assigning descriptor 3 to the file.
exec 3< sample_input.txt

cat <&3
# Closing file
exec 3<&-

Save the file, give the permission to execute, and run the script as follows:

$ chmod u+x file_02.sh

We will create the sample_input.txt file as follows:

$ echo "Hello to All" > sample_input.txt

Run the script and check the result:

$ ./file_02.sh

Output:

Hello to All

In the earlier examples, we opened the file either for reading or writing. Now, we will see how to open the file for reading and writing purposes:

exec fd<> fileName

If the file descriptor number is not specified, then 0 will be used in its place. The file will be created if it does not exist. This procedure is useful to update files.

Let's understand following script.

Write the Shell script file_03.sh as follows:

#!/bin/bash
file_name="sample_out.txt"
# We are assing fd number 3 to file.
# We will be doing read and write operations on file
exec 3<> $file_name

# Writing to file
echo """
 Do not dwell in the past,
 do not dream of the future,
 concentrate the mind on the present moment. - Buddha
""" >&3
# closing file with fd number 3
exec 3>&-

We can use command read to get data from a file to store it in variables. The procedure for using the read command to get text from a file is as follows:

read -u fd variable1 variable2 ... variableN

Now, we will see how to read from one file and write to another. Let's write script file_04.sh as follows:

#!/bin/bash
# We are assigning descriptor 3 to in_file.txt
exec 3< in_file.txt
# We are assigning descriptor 4 to out_file.txt
exec 4> out_file.txt

# We are reading first line of input.txt
read -u 3 line

echo $line

echo "Writing content of in_file.txt to out_file.txt"
echo  "Line 1 - $line " >&4

# Closing both the files
exec 3<&-
exec 4<&-

Save the file, give the permission to execute, and run the script as follows:

$ chmod u+x file_04.sh
$ echo "Sun is at the center of Solar System." > in_file.txt
$ cat in_file.txt

Output:

Sun is at the center of Solar System.
$ ./file_04.sh

Output:

Sun is at the center of Solar System.
Writing content of in_file.txt to out_file.txt
$ cat out_file.txt

Output:

Line 1 - Sun is at the center of Solar System.

In this example, we read the complete line in the variable line and we used the same variable to write it to another file.

Let's write one more script file_05.sh to get the hostname and addresses:

#!/bin/sh

cp /etc/hosts hosts2

grep -v '^#' hosts2 > hosts3

exec 3< hosts3    # opening hosts3 as input file

exec 4> hostsfinal  # opening hostsfinal as output file

read <& 3 address1 name_1 extra_info
read <& 3 address2 name_2 extra_info

echo $name_1 $address1 >& 4
echo $name_2 $address2 >& 4

exec 3<&-      # Closing hosts3
exec 4<&-      # Closing hostsfinal

In this script, we used the variables address1, name_1, extra_info, address2, and name_2 to store useful information.

#!/bin/bash
# we are assigning file descriptor 3 to input file test.txt
exec 3< test.txt
# we are assigning file descriptor 4 to output.txt
exec 4> output.txt
# we are using read command to read line from file
read -u 3 line
echo "Process id of current process is $$"
my_pid=$$
echo "Currently following files are opened by $0 script :"
ls -l /proc/$my_pid/fd

# We are closing both files test.txt and output.txt
exec 3<&-
exec 4>&-

#!/bin/bash
echo "Enter the name of file for reading"
read file_name
exec<$file_name
while read var_line
do
  echo $var_line
done

Executing the command and storing the results in a file

The following is the syntax for storing the output of a command in a file:

Command >& fd
./script >& fd

The following is the illustrative example script file_08.sh:

#!/bin/bash
exec 4> output.txt
cat /proc/cpuinfo  >&4
exec 3<&-

Save the file, give the permission to execute, and run the script as follows:

$ chmod u+x file_08.sh
$ ./file_08.sh

Output:

In this example, we have executed the command cat /proc/cpuinfo and we have stored the output in file output.txt.

The following is the summary of the exec command for using various file handling-related operations:

In the Bash shell, the -n option is a shortcut for noexec (as in no execution). This option tells the shell to not run the commands. Instead, the shell just checks for syntax errors.

We can test the script as follows:

$ bash –n hello.sh

The –n option will tell the Bash shell to check the syntax in the Shell script; but not to execute the Shell script.

Another way to do this is as follows:

#!/bin/bash  -n
We have modified shebang line.

In this case, we can test the Shell script as follows:

$ chmod u+x hello.sh
$ ./hello.sh

This option is safe, since the shell commands are not executed. We can catch incomplete if, for, while, case, and similar programming constructs as well as many more syntactical errors.

Let's write debug_01.sh:

#!/bin/bash
echo -n "Commands in bin directory are : $var"

for var in $(ls )
do
        echo -n -e "$var   "
do
# no error if "done" is typed instead of "do"

Save the file, give the permission to execute, and run the script as follows:

$ chmod  u+x debug_01.sh
$ ./debug_01.sh

Output:

Commands in bin directory are : ./hello.sh: line 7: syntax error near unexpected token `do'
./hello.sh: line 7: `do'

$ bash –n debug_01.sh

Output:

hello.sh: line 7: syntax error near unexpected token `do'
hello.sh: line 7: `do'

The -v option tells the shell to run in a verbose mode. In practice, this means that the shell will echo each command prior to executing the command. This will be useful in locating the line of script that has created an error.

We can enable the script execution with the –v option as follows:

$ bash –v hello.sh

Another way is by modifying the shebang line as follows:

#!/bin/bash  -v

In this case, we can run the script with the –v option as follows:

$ chmod u+x hello.sh
$ ./hello.sh

Let's write the script debug_02.sh, shown as follows:

#!/bin/bash
echo "Hello $LOGNAME"
echo "Today is `date`
echo "Your present working directory is $PWD
echo Good-bye $LOGNAME

Save the file, give the permission to execute, and run the script as follows:

$ chmod u+x debug_02.sh
$ ./debug_02.sh

Output:

Hello student
Today is Fri May 1 00:18:52 IST 2015
Your present working directory is /home/student/work
Good-bye student

Let's enable the –v option for debugging, and run the script again as follows:

$ bash –v debug_02.sh

Output:

#!/bin/bash
echo "Hello $LOGNAME"
"Hello student"
echo "Today is `date`
date
"Today is Fri May 1 00:18:52 IST 2015
echo "Your present working directory is $PWD
"Your present working directory is /home/student/work
echo Good-bye $LOGNAME
Good-bye student

The -x option, short for xtrace or execution trace, tells the shell to echo each command after performing the substitution steps. Thus, we will see the value of variables and commands.

We can trace the execution of the Shell script as follows:

$ bash –x hello.sh

Instead of the previous way, we can modify the shebang line as follows:

#!/bin/bash  -x

Let's test the earlier script debug_01.sh as follows:

$ bash –x hello.sh

Output:

$ bash –x debug_02.sh
+ echo Hello student
Hello student
+ date
+ echo The date is Fri May 1 00:18:52 IST 2015
The date is Fri May 1 00:18:52 IST 2015
+ echo Your home shell is /bin/bash
Your home shell is /bin/bash
+ echo Good-bye student
Good-bye student

Let's try the following programs with the –n –v –f and –x options. Here's a sample program—debug_03.sh:

#!/bin/bash
echo "Total number of parameters are = $#"
echo "Script name = $0"
echo "First Parameter is $1"
echo "Second Parameter is $2"
echo "All parameters are = $*"
echo "File names starting with f* in current folder are :"
ls f*

Save the file, give the permission to execute, and run the script as follows:

$ chmod u+x debug_03.sh
$ ./debug_03.sh One Two

Output:

"Total number of parameters are = 2"
"Script name = ./debug_03.sh"
"First Parameter is India"
"Second Parameter is Delhi"
"All parameters are = India Delhi"
"File names starting with debug_02.sh debug_03.sh in current folder are: "
debug_02.sh  debug_03.sh

Let's test the same script with the –n option, which will check for syntax errors:

$ bash –n debug_03.sh One Two

Let's test the same script with the –v option:

$ bash –v debug_03.sh One Two

Output:

#!/bin/bash
echo "Total number of parameters are = $#"
"Total number of parameters are = 2"
echo "Script name = $0"
"Script name = debug_03.sh"
echo "First Parameter is $1"
"First Parameter is India"
echo "Second Parameter is $2"
"Second Parameter is Delhi"
echo "All parameters are = $*"
"All parameters are = India Delhi"
echo "File names starting with d* in current folder are :"
"File names starting with debug_02.sh debug_03.sh in current folder are: "
ls d*
debug_02.sh  debug_03.sh

Let us test the same script with the –x option:

$ bash –x debug_03.sh One Two

Output:

+ echo $'\342\200\234Total' number of parameters are = $'2\342\200\235'
"Total number of parameters are = 2"
+ echo $'\342\200\234Script' name = $'debug_03.sh\342\200\235'
"Script name = debug_03.sh"
+ echo $'\342\200\234First' Parameter is $'India\342\200\235'
"First Parameter is India"
+ echo $'\342\200\234Second' Parameter is $'Delhi\342\200\235'
"Second Parameter is Delhi"
+ echo $'\342\200\234All' parameters are = India $'Delhi\342\200\235'
"All parameters are = India Delhi"
+ echo $'\342\200\234File' names starting with debug_02.sh debug_03.sh in current folder are $':\342\200\234'
"File names starting with debug_02.sh debug_03.sh in current folder are: "
+ ls debug_02.sh debug_03.sh
debug_02.sh  debug_03.sh

Let's test one more program, which will give a syntax error during the –n and –x options debugging. Write the Shell script debug_04.sh as follows:

#!/bin/bash
echo "Commands in bin directory are : $var"

for var in $(ls )
do
        echo -n -e "$var   "
do

Save the file, give the permission to execute, and run the script as follows:

$ chmod u+x debug_04.sh
$ bash –n debug_04.sh

Output:

debug_04.sh: line 7: syntax error near unexpected token `do'
debug_04.sh: line 7: `do'

The preceding program has a syntax error on line number 7. The word do has an error. We need to change word "do" to "done".

$ bash –n script_name  // interpretation without execution
$ bash –v script_name  // Display commands in script
$ bash –x script_name  // Trace the execution of script

$ bash –xv script_name    // Enable options x and v for debugging
$ bash  +xv script_name    //Disable options x and v for debugging

Most of the time, we invoke the debugging mode from the first line of script. This debugging mode will remain active until the last line of code. But many times, we may need to enable debugging for a particular section of script. By using the set command, we can enable and disable debugging at any point in our Shell script:

set -x
section of script
set +x

Consider the following script:

#!/bin/bash

str1="USA"
str2="Canada";

[ $str1 = $str2 ]
echo $?

Set –x

[ $str1 != $str2 ]
echo $?

[ -z $str1 ]
echo $?

Set +x

[ -n $str2 ]
echo $?

Exit 0

In this case, the debugging will be enabled after the set -x and will be disabled immediately after the set +x.

:set hlsearch     :set ic  vi –b filename

If we follow certain good practices, then we will face errors. Even if errors are found, these will be easier to debug:

We can use two different ways for evaluating arithmetic expressions:

$(( expression ))
$[ expression ]

Learn arithmetic operations using the preceding mentioned arithmetic expansion:

$ a=10
$ b=20
$ c=$((a + b))
$ echo $c

During arithmetic operations, we may need to find square or cube of any given number. These operations are called as exponent operations. We can perform exponent operations as follows:

$ a=5
$ b=3
$ expo=$[ $a ** $b ]# This is equivalent to ab
$ echo $expo
125

This is the result of the 5³ operations.

Another way of arithmetic expansions is as follows:

$ B=10
$ A=$[B + 10]
$ echo $A
20
$ echo $[ 3 + 4 - 5 ]
2

$ echo $[ 3 + 4 * 5]
23

Arithmetic multiplication has more precedence over addition. Therefore, 4*5 was performed first, and the addition of 3+20 was performed later on:

$ echo $[(3 + 4) * 5]
35

$ echo $(( 3 + 4 ))
7

$ echo $(( 6 / 0 ))
bash: 6/0: division by 0 ( error token is "0")

We will use many of the preceding arithmetic techniques for doing the same addition operation and check the result.

Let's write an interactive script called arithmetic_03.sh as follows:

#!/bin/bash
echo "Enter  first value"
read number_1
echo "Enter  secondvalue"
read number_2
total=`expr $number_1 + $number_2`
echo $total
sum=$(($number_1 + $number_2))
echo "sum is "$sum
echo "Sum is $[ $number_1+$number_2 ]"

Let us test the script:

$ chmod +x arithmetic_03.sh
$ ./arithmetic_03.sh

Output:

Enter  first value
10
Enter  second  value
5
15
Sum is 15
Sum is 15

The preceding Shell script shows that even if we use any of the previous techniques, the result remains the same.

Let's write the shell called script arithmetic_04.sh as follows:

#!/bin/bash
# Interactive Shell Script Demonstrating Arithmetic Operators
echo "Enter First value"
read number_1
echo "Enter Second value"
read number_2
echo $(($number_1 + $number_2))
echo $(($number_1 / $number_2)) # Division of two numbers

Let's test the program as follows:

$ chmod +x arithmetic_04.sh
$ ./arithmetic_04.sh

Output:

Enter First value
10
Enter Second value
5
15
2

We will write one more script with a different technique. Let's write the Shell script arithmetic_05.sh as follows: