The Korn Shell is the UNIX shell (command execution program, often c.docx

The Korn Shell is the UNIX shell (command execution program,
often called a command interpreter) that was developed by
David Korn of Bell Labs as a comprehensive, combined version
of other major UNIX shells. Incorporating all the features of the
C shell (csh) and the Tab C-shell (tcsh) with the script language
features similar to that of the Bourne Shell, the Korn Shell is
considered the most efficient shell. Korn, Bourne, and C are the
3 most commonly used UNIX shells. You will be using the Korn
Shell (ksh) for this project in which you will be writing shell
script files.
1.
Begin by executing the following command from a terminal
session in your Ubuntu system:
sudo apt-get install ksh
You will immediately be asked to enter your password
(csci345). This will install the Korn shell into your Ubuntu
system on your PC or Mac for use in this project. Simply type
ksh
and to go into the Korn Shell (your system prompt will change
to $ only) and then enter CTRL-D to exit out of it (your default
system prompt of
[email protected]
:~$ will re-appear).
As you go through this exercise and start writing shell scripts,
you will learn some additional troubleshooting tips to help you
navigate through the Korn Shell (ksh).
Keep track of some of these tips (5 of them) and put them into

a Word document in a list format with explanations (at least 150
words in current APA format). Make sure that these are
different from those mentioned in the textbook.
2.
Do some research on what the Korn Shell is about and what it
has to offer. Provide some basic information (3–5 key points) in
a short report (at least 150 words in current APA format) and
compile it into the same Word document as above and submit it
with this project. Also, provide 5–7 positive features of the
Korn Shell (ksh) in the same report (at least 150 words in
current APA format) in a list. Below are 3 websites that can
assist you in this effort. You will need at least 2 external
references for this short report (in addition to your textbook):
-
http://kornshell.com/
-
http://www.dartmouth.edu/~rc/classes/ksh/print_pages.shtml
-
http://www.bolthole.com/solaris/ksh.html
There are many other websites out there that will give you
additional help, if needed. Take a look at the ksh shell script
below. There are 3 versions of essentially the same program,
which is a wrapper to edit a file under SCCS version control.
The basic task is to use the sccs command to “check out” a file
under version control and then automatically edit the file. The
script will then be used by users who may not be particularly
advanced UNIX users. Hence, the need for a wrapper script.
While the basic functionality is the same across all versions, the
differences in safety and usability between the first version and

the last (4th) version are worth noting. The first one is
extremely bad: it would be written by someone who has just
picked up a book on shell scripting and has decided, “I’m a
programmer now.”
#!/bin/ksh
sccs edit $1
if [ "$EDITOR" = "" ] ; then
EDITOR=vi
fi
$EDITOR $1
This version makes somewhat of an attempt to be user-friendly
by having a check for an environmental variable EDITOR
setting and using it, if available; however, there are no
comments, no error checking, and no help for the user at all.
The second one is an improvement, showing some consideration
to potential users by having safety checks.
#!/bin/ksh
# Author: Name Here
if [ $# -lt 1 ] ; then
print "This program will check out a file, or files, with
sccs"
exit 1
fi
# set EDITOR var to "vi" if not already set

EDITOR=${EDITOR:-vi}
sccs edit
[email protected]
$EDITOR
[email protected]
This is a step above the prior version. It accepts multiple files
as potential arguments. It is always nice to be flexible about the
number of files your scripts can handle. It also has a usage
message if the script is called without arguments. Plus, it is
always a good idea to put your name in as well. Unfortunately,
there is still quite a bit lacking as you can tell by comparing it
to the next version. The third one is a good, solid version; it is a
positive role model for your scripts.
#!/bin/ksh
# SCCS editing wrapper, version 0.3
# Author - Sys Admin
# Usage: see usage() function, below
usage(){
print sedit - a wrapper to edit files under SCCS
print "usage: sedit file {file2 ...}"
}
# Set EDITOR var to "vi" if not already set to something
EDITOR=${EDITOR:-vi}
# Could already be in path, but it doesn’t hurt to add it again.
# adjust as needed, if your sccs lives somewhere else
SCCSBIN=/usr/ccs/bin
if [ ! -x $SCCSBIN/sccs ] ; then

print ERROR: sccs not installed on this machine. Cannot
continue.
usage
exit 1
fi
PATH=$SCCSBIN:$PATH
if [ $# -lt 1 ] ; then
usage
print ERROR: no files specified
exit 1
fi
# Yes, I could use "sccs edit
[email protected]
" and check for a single error, but # this approach allows for
finer error reporting
for f in
[email protected]
; do
sccs edit $f
if [ $? -ne 0 ] ; then
print ERROR checking out file $f
if [ "$filelist" != "" ] ; then
print "Have checked out $filelist"
fi
exit 1
fi
filelist="$filelist $f"
done
$EDITOR $filelist
if [ $? -ne 0 ] ; then
print ERROR: $EDITOR returned error status
exit 1
fi

Here are some nice things to note with this script:
·
Sets special variables at the top of the script in a unified place;
·
Paranoid checks about EVERYTHING;
·
Returns an error status from the script on non-clean exit
condition (“exit 1” vs. “exit”); and
·
Use of comments. Not only does he/she specify what he/she is
doing, he/she clarifies what she/she is NOT doing and why.
3.
Now that you have the Korn Shell (ksh) installed and have
learned more about the language itself, it is time to do some
programming:
a.
Write a Korn shell script that accepts exactly 1 command line
argument that must be a positive integer. The script will print a
comma separated list of integers, all on the same line, starting
with the initial command line value and decreasing it by one-to-
one. The last printed value must not be followed by a comma.
Do not write this script to be executed interactively.
Requirements:

The script must be to handle the following error situations:
1.
Incorrect number of arguments and
2.
Non-positive arguments.
The script file name must be:
printnum.sh
The script permissions must be 705 (show in your Word
document).
Sample Output (provide yours in same Word document)
Sunny Day Scenarios:
[email protected]
:~$
sh printnum.sh 3
3, 2, 1
[email protected]
:~$
[email protected]
:~$
sh printnum.sh 10
10, 9, 8, 7, 6, 5, 4, 3, 2, 1
[email protected]
:~$
Rainy Day Scenarios:

[email protected]
:~$
sh printnum.sh
error: program must be executed with 1 argument. usage:
printnum.sh value (where value >= 1)
[email protected]
:~$
sh printnum.sh 2 5
error: program must be executed with 1 argument. usage:
printnum.sh value (where value >= 1)
[email protected]
:~$
sh printnum.sh -1
error: argument must be a positive number. usage: printnum.sh
value (where value >= 1)
Add at least 2 more scenarios in your Word document.
b.
Write a Korn shell script that will determine which file in a
directory has the maximum number of lines (this may be
different than the file that has the maximum number of bytes).
After determining the file with the maximum number of lines,
the script will print out the name of the file and the number of
lines. The script must only focus on files and ignore
subdirectories. The command
wc
may be helpful. Do not write this script to be executed
interactively.

Requirements:
·
The script must allow either no arguments or 1 argument.
1.
If zero arguments are specified, the script by default will
examine the files in the current directory.
2.
If 1 argument is specified, the argument must be the name of a
directory. The script will then examine the files in the specified
directory.
The script must be able to handle the following error
conditions:
1.
More than 1 argument is specified.
2.
The specified argument is not a directory.
maxlines.sh
The script permissions should be 705
Sunny Day Scenarios
(Note: output depends on current directory and may not match
the values below):

[email protected]
:~$
sh maxlines.sh
File maxlines.sh has maximum number lines (36 lines).
[email protected]
:~$
sh maxlines.sh /etc
File mime.types has the maximum lines with 827 lines.
Rainy Day Scenarios:
[email protected]
:~$
sh maxlines.sh junk
error: argument must be a directory usage: maxlines.sh
[directory]
[email protected]
:~$
sh maxlines.sh junk trash
error: can only use 0 or 1 arguments. usage: maxlines.sh
[directory]
c.
Create a search utility by writing 2 Korn Shell scripts named
srchfile.sh
and
srch.sh
,
respectively. The script

srchfile.sh
will list all occurrences of a string found in a file. The script
srch.sh
will list all occurrences of a string in a file or all files in a
specified directory. Actually,
srch.sh
will use the script
srchfile.sh
as if it were just another UNIX command to perform the actual
search in a file. In other words, the script
srch.sh
needs to be able to use the script
srchfile.sh
. Therefore, this assignment recommends that the first script
created be the
srchfile.sh
script. The script
srch.sh
calls the
srchfile.sh
script.
Requirements:
Part 1
Description.
The shell script
srchfile.sh
must accept 2 command line arguments.
1.
The script shall first print the name of the file being searched.
2.

If there are one more instances of the string in the file, the
script shall print each line that contains the matching string,
along with the line number of the file.
You may use the UNIX command
grep
in your script to do the actual search. In fact,
grep
can even print the line number if used with the appropriate
option (see man page for
grep
).
If the user enters more or fewer than the required number of
arguments, the script shall produce an error message and stop.
The first argument shall represent the string to be searched.
The second argument shall represent the name of the file to be
searched. If the second argument is not a file, the script shall
produce an error message and stop.
srchfile.sh
.
The script permissions must be 705

In the Sunny Day Scenario
, the
srchfile.sh
script is invoked searching for string root pattern in file passwd
in the /etc directory:
[email protected]
:~$
sh srchfile.sh root /etc/passwd
------ File = /etc/passwd ------
1:root:x:0:0:root:/root:/bin/bash
In the Rainy Day Scenario
, script
srchfile.sh
is invoked with only 1 command line argument:
[email protected]
:~$
sh srchfile.sh xxxx
error: must provide 2 arguments
usage: sh srchfile.sh search-pattern file
In the Rainy Day Scenario
, script
srchfile.sh
is invoked with second command line argument /etc., which is
a directory rather than a file:
[email protected]
:~$
sh srchfile.sh xxxx /etc
error: second argument must be a file
usage: ./srchfile.sh search-pattern file

Part 2
Description.
Now, write a second Korn Shell script named
srch.sh.
The
srch.sh
script will call the
srchfile.sh
script to perform a specific task and accept 2 command line
arguments. The first argument shall be a string (pattern) found
in the file being searched. The second command line argument
shall be the name of a file or a directory.
Requirements:
The second argument represents either the name of the file to be
searched or a directory. If a directory is entered, then all files in
the directory shall be searched.
The script
srch.sh
shall use the script
srchfile.sh
to search for the string in a given file. If the second argument
is a directory, then
srch.sh
will invoke
srchfile.sh
repeatedly in a loop.
If the user enters more or fewer than the required number of

arguments, the script shall produce an error message and stop.
srch.sh
.
The script permissions must be 705.
Sunny Day Scenario
, the
srch.sh
script searching for string root in the file /etc/passwd:
[email protected]
:~$
sh srch.sh root /etc/passwd
------ File = /etc/passwd ------
1:root:x:0:0:root:/root:/bin/bash
Rainy Day Scenario
, script
srch.sh
is invoked with only 1 command line argument:
[email protected]
:~$
sh srch.sh root
usage: sh srch.sh search-pattern file
Rainy Day Scenario
, script

srch.sh
is invoked with 3 command line arguments:
[email protected]
:~$
sh srch.sh root1 root2 root3
usage: sh srch.sh search-pattern file
d.
In this exercise, you are to write a Korn shell script that spawns
5 processes and then kills them.
Requirements.
This homework assignment requires the creation of 2 Korn shell
scripts; 1 script shall be named
simple_script.sh
and the main script will be named
process.sh.
The source code for
simple_script.sh
is given to you below.
Simple_script.sh script
Create a small shell script file called
simple_script.sh

with the following contents:
echo “I am simple_script.sh with process ID $$” sleep 5
The
simple_script.sh
script file name must be:
simple_script.sh
.
Try running
simple_script.sh
at the command line; it will print out its process ID and then
sleep for 5 seconds before terminating. Each time you run the
script, it will have a different process ID.
process.sh script
Design your script named
process.sh
as follows:
Have your script create 5 instances of
simple_script.sh
in the background. Each time the script
process.sh
creates an instance of
simple_script.sh
, the
shell variable $! in
process.sh
will contain the process ID of the latest
simple_script.sh
script.

After your
process.sh
script has created 5 instances of
simple_script.sh
, let your
process.sh
script sleep for 1 second and then let your
process.sh
script start killing the processes using the process ID obtained
from $! (see man page for
kill
command).
Your script must only start killing processes AFTER it has
created ALL 5 instances of
simple_script.sh
(i.e., DO NOT create
simple_script.sh
process 1. Kill it and then create process 2, kill it and so on).
You MUST use a shell array for the
process.sh
script. Use the shell array to store the process IDs of the
simple_script.sh
processes.
process.sh
The script permissions must be 705.

Sunny Day Scenarios (add here) …
Rainy Day Scenarios (add here) …
Below is a sample of the output messages from
process.sh
(NOTICE the order of how the scripts are created and
destroyed in the same order):
[email protected]
:~$
sh
process.sh
I am simple_script.sh with process ID 12301
process is killing process 12301
Add at least 2 scenarios in your Word document.
·
·
Submit a zip file with all Korn Shell script files for step 3, parts
a–d, and submit your Word document for steps 1–3 (scenarios).

The Korn Shell is the UNIX shell (command execution program, often c.docx

The Korn Shell is the UNIX shell (command execution program, often c.docx

Recommended

Recommended

More Related Content

Similar to The Korn Shell is the UNIX shell (command execution program, often c.docx

Similar to The Korn Shell is the UNIX shell (command execution program, often c.docx (20)

More from SUBHI7

More from SUBHI7 (20)

Recently uploaded

Recently uploaded (20)

The Korn Shell is the UNIX shell (command execution program, often c.docx