Wednesday, April 9, 2008

Sample Shell scripts Examples:

Shell scripts use to automate your daily tasks and make life peaceful
===================================================================================== A simple 3 line shell script to check if the doent exists then backup the logfile with date suffix and create the new logfile. if the file exists then do nothing
#!/usr/bin/ksh
if [[ ! -f /home/jack/app/donotrun.tmp ]] ; then
mv /tmp/app.log /tmp/app.log.`date +%Y%m%d%H%M`

touch /tmp/app.log
fi
____________________________________________________________________
Examples 1 .

  • Sample code to automate FTP in shell script.
    ############ Create the file needed for FTP ################
    count=`find ${PDFPUB} -type f wc -l` #To checking how many files are there to transfer
    echo open $FTP_HOST > FINPUB_FTP.temp # host name stored in variable
    echo "user ${FINPUBUSER} ${FINPUBPASS}" >> FINPUB_FTP.temp
    echo binary >> FINPUB_FTP.temp
    echo "cd /tmp/FINPUB" >> FINPUB_FTP.temp
    echo "lcd /home/mpansare/pdfpub" >> FINPUB_FTP.temp
    echo prompt >> FINPUB_FTP.temp
    echo "mput *" >> FINPUB_FTP.temp
    echo bye >> FINPUB_FTP.temp
    ############ FTP the file ################
    echo "" >>$LOGFILE
    ftp -nv -i <>>$LOGFILE
    rm FINPUB_FTP.temp
    ------------------------------------------------------------------------------------------------- ftp options:
    -v = Verbose option forces ftp to show all responses from the remote server, as well as report on data transfer statistics.
    -n = Restrains ftp from attempting ``auto-login'' upon initial connection.
    -i = Turns off interactive prompting during multiple file transfers.
    -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ########## Determine if FTP was successful ################
    grep "226 Transfer complete." $LOGFILE
    return_code=$?
    grepcount=`grep -c "226 Transfer complete" $LOGFILE` # counts how many files were transfered properly

    # If else block
    if [[ $count -eq $grepcount ]]; then
    echo "FTP file transfer counts match" >> $LOGFILE
    else
    echo "FTP files transfer donot match. Some files may not have transfer" >> $LOGFILE
    fi

=====================================================================================

Example 2.

  • Script to check diskusage that runs thru cron every hour to report and alert if disk space exceeds 95%

#!/usr/bin/ksh
#############################################################
# Script Name:checkDiskUsage.sh

###########################################################
dater=`date +%Y%m%d`
sScriptName=checkDiskUsage
sLogfile=/dev/${sScriptName}.${dater}.log
sSpool=/tmp/${sScriptName.$$}.tmp
echo "${sScriptName} starting on `date`" >> ${sLogfile}
iSpoolCmd=`df -k egrep -v "/procFilesystem" > "${sSpool}"`
if [[ $iSpoolCmd -ne 0 ! -s ${sSpool} ]];then
echo "Error: Could not retrieve disk usage statistics. Aborting!" >> $sLogfile
exit 255
fi
while read -r myline; do
sDir=`echo "${myline}" awk '{print $7}'`
sPUsage=`echo "${myline}" awk '{print $4}'`
sUsage=`echo "${sPUsage}" tr -d %`
#echo ${sDir}, ${sUsage}

if [[ ${sUsage} -ge 95 ]];then
echo "WARNING : Usage on ${sDir} has reached ${sPUsage}" >> ${sLogfile}
elif [[ ${sUsage} -ge 90 && ${sUsage} -lt 95 ]];then
echo "NEEDS ATTENTION : Usage on ${sDir} has reached ${sPUsage}" >> ${sLogfile}
fi
done < ${sSpool} echo "${sScriptName} ending on `date`" >> ${sLogfile}
rm ${sSpool} >/dev/null
exit 0

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------

=====================================================================================

Example 3.

  • The dailylogbackup script is used to backup the log files on dailybasis with date suffix This script is called with a PARM file which lists all the logfiles to be backed up (on a daily basis).# Input parms:

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------

#!/usr/bin/ksh
#############################################################
# ScriptName: dailyBkupLogFile.sh
# Purpose: c
# Input parms:
# Usage: dailyBkupLogFile.sh
# Parent script:
#################################################################
# Define a path where the script will log all actions
mylogfile=/dev/Logs/dailyBkupLogFile.log
# Check for proper command line arguments
if [ $# -ne 1 ] ; then
echo "Incorrect Usage. Correct Usage: $0 "
exit 1
fi
# Check if the PARM file really exists
parmfile=$1
if [ ! -f $parmfile ] ; then
echo "Error: C
ould not find the specified PARM file. Please verify the PARM file exists."
exit 1
fi
echo "$0 started on `date`" >> $mylogfile
# Iterate through the list of logfiles supplied in the PARM file
while read -r sLine ; do
if [ -f $sLine ] ; then
#create dated name
newfile="$sLine.`date +%Y%m%d`"
#flag and counter to tack on the end
i=0
#if the newfile exists, set flag
if [ -f $newfile ] ; then
i=1
#loop to see how many we need to do
while [ -f $newfile.$i ]; do
((i+=1)) ; done

fi

#if there were previous logs, append the number
if [ $i -ne 0 ] ; then
mvcmd="mv $sLine $newfile.$i"
else
mvcmd="mv $sLine $newfile"
fi
# Backup the logfile by performing move/rename with current date appended
$mvcmd
if [ $? -eq 0 ] ; then
echo "Backing up logfile $sLine : SUCCESS" >> $mylogfile
else
echo "Backup command failed: $mvcmd" >> $mylogfile
fi
# Create a new logfile with the same original filename
touchcmd="touch $sLine"
$touchcmd
if [ $? -eq 0 ] ; then
echo "Creating logfile $sLine : SUCCESS" >> $mylogfile
else
echo "Logfile create failed: $touchcmd" >> $mylogfile
fi
else
echo "Error: Could not find logfile - Skipping backup of $sLine." >> $mylogfile
fi
done < $parmfile echo "$0 completed on `date`" >> $mylogfile
exit 0

Saturday, April 5, 2008

Unix Shell Scripting.

Shell Programming
This section describes the fundamentals of bash shell programming and covers the following topics:
· Creating and running shell programs
· Using shell variables
· The importance of quotes
· The test command
· Conditional statements
· Iteration statements
· Functions

  • Creating and Running Shell Programs
    Shell programs, or scripts, are just text files that contain one or more shell commands. Shell scripts are similar to batch files in DOS, but are much more powerful. These scripts can be used to simplify repetitive tasks, to replace two or more commands that are always executed together with a single command, to automate the installation of other programs, to write simple interactive applications, and various other useful tasks. The general Linux philosophy for providing functionality is to link several small, discrete commands together to accomplish more complicated tasks. Shell scripting and piping are the most common ways to do this.
    Since bash is for most intents and purposes the standard shell for Linux, only bash shell programming will be discussed here. In bash, the pound symbol (#) signifies a comment to be ignored when it is the first character on a line.
    Once the script exists, there are several ways to execute it. One way to accomplish this is to make the file executable. This is done by entering the command "chmod +x remount". This command changes the permissions of the file so that it is now executable. You can now run your new shell program by typing (./scriptname) on the command line. reasons your
  • Using Variables
    As is the case with almost any language, the use of variables is very important in shell programs. You saw some of the ways in which shell variables can be used in the introductory shell sections. Two of the variables that were introduced were the PATH variable and the PS1 variable. These are examples of built-in shell variables, or variables that are defined by the shell program you are using. This section describes how you can create your own variables and use them in simple shell programs.
    Assigning a Value to a Variable
    You can assign a value to a variable simply by typing the variable name followed by an equal sign and the value you want to assign to the variable. For example, if you wanted to assign a value of 5 to the variable count, you would enter the following command "count=5". With the bash syntax for setting a variable, you must make sure that there are no spaces on either side of the equal sign. Notice that you do not have to declare the variable as you would if you were programming in C or Pascal. This is because the shell language is a non-typed interpretive language. This means that you can use the same variable to store character strings that you use to store integers. You would store a character string into a variable in the same way that you stored the integer into a variable. For example "name=Garry " is also completely valid.
    Accessing the Value of a Variable
    Once you have stored a value into a variable, how do you get the value back out? You do this in the shell by preceding the variable name with a dollar sign ($). If you wanted to print the value stored in the count variable to the screen, you would do so by entering the command "echo -n $count". If you omitted the $ from the preceding command, the echo command would display the word count on-screen. Also, here "-n" is an option for echo not to append a carriage return to the end of the line.
    Positional Parameters and Other Built-In Shell Variables
    The shell has knowledge of a special kind of variable called a positional parameter. Positional parameters are used to refer to the parameters that were passed to a shell program on the command line or a shell function by the shell script that invoked the function. When you run a shell program that requires or supports a number of command-line options, each of these options is stored into a positional parameter. The first parameter is stored into a variable named 1, the second parameter is stored into a variable named 2, and so forth. These variable names are reserved by the shell so that you can't use them as variables you define. To access the values stored in these variables, you must precede the variable name with a dollar sign ($) just as you do with variables you define.
    Example Script: reverse
    The following shell program expects to be invoked with two parameters. The program takes the two parameters and prints the second parameter that was typed on the command line first and the first parameter that was typed on the command line second.
    #program reverse, prints the command line parameters out in reverse order#!/bin/bashecho "$2" "$1"
    Table 1: Built-in shell variables.
    Variable Use
    $# = Stores the number of command-line arguments that were passed to the shell program.
    $? = Stores the exit value of the last command that was executed.
    $0 = Stores the first word of the entered command (the name of the shell program).
    $* = Stores all the arguments that were entered on the command line ($1 $2 ...).
    "$@" = Stores all the arguments that were entered on the command line, individually quoted ("$1" "$2" ...).
    The Importance of Quotation Marks
    The use of the different types of quotation marks is very important in shell programming. Both kinds of quotation marks and the backslash character are used by the shell to perform different functions. The double quotation marks (""), the single quotation marks (''), and the backslash (\) are all used to hide special characters from the shell. Each of these methods hides varying degrees of special characters from the shell. Remember that everything in this section also applies to the bash command line, so for example you could use a backslash to use a space in the name of a file.
    Double Quotes
    The double quotation marks are the least powerful of the three methods. When you surround characters with double quotes, all the whitespace characters are hidden from the shell, but all other special characters are still interpreted by the shell. This type of quoting is most useful when you are assigning strings that contain more than one word to a variable. For example, if you wanted to assign the string hello there to the variable greeting, you would type the following command:greeting="Hello there"
    This command would store the string "Hello there" in the variable "greeting" as one word. If you typed this command without using the quotes, you would not get the results you wanted. bash would not understand the command and would return an error message.
    Single Quotes
    Single quotes are the most powerful form of quoting. They hide all special characters from the shell. This is useful if the command that you enter is intended for a program other than the shell. Because the single quotes are the most powerful, you could have written the previous example using single quotes. You might not always want to do this. If the string being assigned to the greeting variable contained another variable, you would have to use the double quotes. For example, if you wanted to include the name of the user in your greeting, you would type the following command: greeting="Hello there $LOGNAME"
    This would store the string "Hello there " and the value of $LOGNAME into the variable greeting. The LOGNAME variable is a shell variable that contains the username of the person who is logged in to the system. If you tried to write this command using single quotes it wouldn't work, because the single quotes would hide the dollar sign from the shell and the shell wouldn't know that it was supposed to perform a variable substitution.
    Backslash
    Using the backslash is the third way of hiding special characters from the shell. Like the single quotation mark method, the backslash hides all special characters from the shell, but it can hide only one character at a time, as opposed to groups of characters. You could rewrite the greeting example using the backslash instead of double quotation marks by using the following command: greeting=Hello\ There
    In this command, the backslash hides the space character from the shell, and the string "Hello there" is assigned to the variable "greeting".
    Backslash quoting is used most often when you want to hide only a single character from the shell. This is usually done when you want to include a special character in a string. For example, if you wanted to store the price of a box of computer disks into a variable named disk_price, you would use the following command: disk_price=\$5.00
    The backslash in this example would hide the dollar sign from the shell. If the backslash were not there, the shell would try to find a variable named 5 and perform a variable substitution on that variable. Assuming that no variable named 5 were defined, the shell would assign a value of .00 to the disk_price variable. This is because the shell would substitute a value of null for the $5 variable. The disk_price example could also have used single quotes to hide the dollar sign from the shell.
    Back Quotes
    The back quote marks (") perform a different function. They are used when you want to use the results of a command in another command. For example, if you wanted to set the value of the variable contents equal to the list of files in the current directory, you would type the following command: contents='ls'
    This command would execute the ls command and store the results of the command into the contents variable. As you will see in later, this feature can be very useful when you want to write a shell program that performs some action on the results of another command.
    The test Command
    A command called test is used to evaluate conditional expressions. You would typically use the test command to evaluate a condition that is used in a conditional statement or to evaluate the entrance or exit criteria for an iteration statement. The test command has the following syntax: test expression
    or [ expression ]
    Several built-in operators can be used with the test command. These operators can be classified into four groups: integer operators, string operators, file operators, and logical operators.
    The test command's integer operators.
    Operator Meaning
    int1 -eq int2 - Returns True if int1 is equal to int2.
    int1 -ge int2 - Returns True if int1 is greater than or equal to int2.
    int1 -gt int2 - Returns True if int1 is greater than int2.
    int1 -le int2 - Returns True if int1 is less than or equal to int2.
    int1 -lt int2 - Returns True if int1 is less than int2.
    int1 -ne int2 - Returns True if int1 is not equal to int2.

    The test command's string operators.
    Operator Meaning
    str1 = str2 - Returns True if str1 is identical to str2.
    str1 != str2 - Returns True if str1 is not identical to str2.
    str - Returns True if str is not null.
    -n str - Returns True if the length of str is greater than zero.
    -z str - Returns True if the length of str is equal to zero.
    The test command's file operators.
    Operator Meaning
    -d filename - Returns True if file, filename is a directory.
    -f filename - Returns True if file, filename is an ordinary file.
    -r filename - Returns True if file, filename can be read by the process.
    -s filename - Returns True if file, filename has a nonzero length.
    -w filename - Returns True if file, filename can be written by the process.
    -x filename - Returns True if file, filename is executable.
    The test command's logical operators.
    Command Meaning
    ! expr - Returns True if expr is not true.
    expr1 -a expr2 - Returns True if expr1 and expr2 are true.
    expr1 -o expr2 - Returns True if expr1 or expr2 is true.
    Conditional Statements
    The bash shell has two forms of conditional statements. These are the if statement and the case statement. These statements are used to execute different parts of your shell program depending on whether certain conditions are true.
    The if Statement
    bash supports nested if...then...else statements. These statements provide you with a way of performing complicated conditional tests in your shell programs. The syntax of the if statement is shown here:

if [ expression ] then;

commands

elif [ expression2 ]then;

commands

else

commands

fi
The elif and else clauses are both optional parts of the if statement. Also note that bash use the reverse of the statement name in most of their complex statements to signal the end of the statement. In this statement the fi keyword is used to signal the end of the if statement. The elif statement is an abbreviation of else if. This statement is executed only if none of the expressions associated with the if statement or any elif statements before it were true. The commands associated with the else statement are executed only if none of the expressions associated with the if statement or any of the elif statements were true.
The case Statement
The case statement enables you to compare a pattern with several other patterns and execute a block of code if a match is found. The shell case statement is quite a bit more powerful than the case statement in Pascal or the switch statement in C. This is because in the shell case statement you can compare strings with wildcard characters in them, whereas with the Pascal and C equivalents you can compare only enumerated types or integer values. The syntax for the case statement is the following:

case string1

instr1) commands;;

str2) commands;;

*) commands;;

esac
The string string1 is compared to str1 and str2. If one of these strings matches string1, the commands up until the double semicolon (;;) are executed. If neither str1 nor str2 matches string1, the commands associated with the asterisk are executed. This is the default case condition because the asterisk matches all strings.
The following code is an example of a bash case statement. This code checks to see if the first command-line option was -i or -e. If it was -i, the program counts the number of lines in the file specified by the second command-line option that begins with the letter i. If the first option was -e, the program counts the number of lines in the file specified by the second command-line option that begins with the letter e. If the first command-line option was not -i or -e, the program prints a brief error message to the screen.

case $1 in

-i) count='grep ^i $2 wc -l' echo "The number of lines in $2 that start with an i is $count" ;;

-e) count='grep ^e $2 wc -l' echo "The number of lines in $2 that start with an e is $count" ;;

*) echo "That option is not recognized";;

esac
Iteration Statements
The shell languages also provide several iteration or looping statements.
The for Statement
The for statement executes the commands that are contained within it a specified number of times. bash has two variations of the for statement. The first form of the for statement that bash support has the following syntax:

for var1 in list

do

commands

done
In this form, the for statement executes once for each item in the list. This list can be a variable that contains several words separated by spaces, or it can be a list of values that is typed directly into the statement. Each time through the loop, the variable var1 is assigned the current item in the list, until the last one is reached. The second form of for statement has the following syntax: for var1do statementsdone
In this form, the for statement executes once for each item in the variable var1. When this syntax of the for statement is used, the shell program assumes that the var1 variable contains all the positional parameters that were passed in to the shell program on the command line. Typically this form of for statement is the equivalent of writing the following for statement: for var1 in "$@"do statementsdone
The following is an example of the for statement. This example takes as command-line options any number of text files. The program reads in each of these files, converts all the letters to uppercase, and then stores the results in a file of the same name but with a .caps extension. for filedo tr a-z A-Z < $file >$file.capsdone
The while Statement
Another iteration statement offered by the shell programming language is the while statement. This statement causes a block of code to be executed while a provided conditional expression is true. The syntax for the while statement is the following:

while expression

do

statements

done
The following is an example of the while statement. This program lists the parameters that were passed to the program, along with the parameter number. count=1while [ -n "$*" ]do echo "This is parameter number $count $1" shift count='expr $count + 1'done
As you will see later the shift command moves the command-line parameters over one to the left.
The until Statement
The until statement is very similar in syntax and function to the while statement. The only real difference between the two is that the until statement executes its code block while its conditional expression is false, and the while statement executes its code block while its conditional expression is true. The syntax for the until statement is:

until expression

do

commands

done
The same example that was used for the while statement can be used for the until statement. All you have to do to make it work is negate the condition. This is shown in the following code: count=1until [ -z "$*" ]do echo "This is parameter number $count $1" shift count='expr $count + 1'done
The only difference between this example and the while statement example is that the -n test command option (which means that the string has nonzero length) was removed, and the -z test option (which means that the string has zero length) was put in its place. In practice the until statement is not very useful, because any until statement you write can also be written as a while statement.
The shift Command

The shift command moves the current values stored in the positional parameters to the left one position. For example, if the values of the current positional parameters are:$1 = -r $2 = file1 $3 = file2 and you executed the shift command the resulting positional parameters would be as follows: $1 = file1 $2 = file2 You can also move the positional parameters over more than one place by specifying a number with the shift command. This is a very useful command when you have a shell program that needs to parse command-line options. This is true because options are typically preceded by a hyphen and a letter that indicates what the option is to be used for. Because options are usually processed in a loop of some kind, you often want to skip to the next positional parameter once you have identified which option should be coming next. For example, the following shell program expects two command-line options, one that specifies an input file and one that specifies an output file. The program reads the input file, translates all the characters in the input file into uppercase, then stores the results in the specified output file. while [ "$1" ]do if [ "$1" = "-i" ]; then infile="$2" shift 2 elif [ "$1" = "-o" ] then outfile="$2" shift 2 else echo "Program $0 does not recognize option $1" fidone tr a-z A-Z < $infile > $outfile
Functions
The shell languages enable you to define your own functions. These functions behave in much the same way as functions you define in C or other programming languages. The main advantage of using functions as opposed to writing all of your shell code in line is for organizational purposes. Code written using functions tends to be much easier to read and maintain and also tends to be smaller, because you can group common code into functions instead of putting it everywhere it is needed.
The syntax for creating a function in is the following:

fname ()

{ shell commands}
Once you have defined your function using one of these forms, you can invoke it by entering the following command: fname [parm1 parm2 parm3 ...]
Notice that you can pass any number of parameters to your function. When you do pass parameters to a function, it sees those parameters as positional parameters, just as a shell program does when you pass it parameters on the command line.
The following shell program contains several functions, each of which is performing a task associated with one of the command-line options. This example illustrates many of the topics covered in this section. It reads all the files that are passed on the command line and—depending on the option that was used—writes the files out in all uppercase letters, writes the files out in all lowercase letters, or prints the files. upper () { shift for i do tr a-z A-Z < $1 > $1.out rm $1 mv $1.out $1 shift done;} lower () { shift for i do tr A-Z a-z < $1 > $1.out rm $1 mv $1.out $1 shift done;} print () { shift for i do lpr $1 shift done;} usage_error () { echo "$1 syntax is $1 " echo "" echo "where option is one of the following" echo "p to print frame files" echo "u to save as uppercase" echo "l to save as lowercase"; } case $1in p -p) print $@;; u -u) upper $@;; l -l) lower $@;; *) usage_error $0;;esac;}

Tuesday, April 1, 2008

Conditional Expressions in Shell Scripting

A conditional expression is used with the [[ compound command to test attributes of files and to compare strings. Word splitting and filename generation are not performed on the words between [[ and ]]. See "The Test Statement" for details of [[.
Each expression can be constructed from one or more of the following unary or binary expressions:

Condition Description :

-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.
-f file True if file exists and is an ordinary file.
-g file True if file exists and is has its setgid bit set.
-h file True if file exists and is a symbolic link.
-k file True if file exists and is has its sticky bit set.
-n string True if length of string is non-zero.
-o option True if option named option is on.
-p file True if file exists and is a fifo special file or a pipe.
-r file True if file exists and is readable by current process.
-s file True if file exists and has size greater than zero.
-t file_des True if file descriptor number file_des is open and associated with a terminal device.
-u file True if file exists and is has its setuid bit set.
-w file True if file exists and is writable by current process.
-x file True if file exists and is executable by current process. If file exists and is a directory, the current process has permission to search in the directory.
-z string True if length of string is zero.
-H file True if file exists and is a hidden directory
-L file True if file exists and is a symbolic link.
-O file True if file exists and is owned by the effective user ID of this process.
-G file True if file exists and its group matches the effective group ID of this process.
-S file True if file exists and is a socket.
file1 -nt file2 True if file1 exists and is newer than file2.
file1 -ot file2 True if file1 exists and is older than file2.
file1 -ef file2 True if file1 and file2 exist and refer to the same file.
str = pattern True if string, str, matches pattern. str != pattern True if string, str, does not match pattern.
str1 <> str2 True if str1 comes after str2 based on the ASCII value of their characters.
exp1 -eq exp2 True if exp1 is equal to exp2. exp1 -ne exp2 True if exp1 is not equal to exp2. exp1 -lt exp2 True if exp1 is less than exp2.
exp1 -gt exp2 True if exp1 is greater than exp2.
exp1 -le exp2 True if exp1 is less than or equal to exp2.
exp1 -ge exp2 True if exp1 is greater than or equal to exp2.
A compound expression can be constructed from these primitives by using any of the following, listed in decreasing order of precedence.

Compound Description

(expression) True, if expression is true. The round-brackets are used to group expressions. ! expression True if expression is false. expr1 && expr2 True, if expr1 and expr2 are both true. && means Logical-AND expr1 expr2 True, if either expr1 or expr2 is true. means Logical-OR
The Test Statement:
The syntax for the test statement should be in the form:
$ test c ..or.. $ [[ condition ]]
Where condition is one or more valid conditional statements. The syntax, [[ , represents the command word, 'test', but must always be closed with ]]. Because [[ is, in effect, a command word, it must be followed by at least one white-space character (space or TAB) and the closing brackets, ]] , must also be preceded by at least one white-space character.
The following test statement uses the Bourne shell compatible syntax.
$ [ condition ]
Note that the character, [, represents to command word, test and must be followed by at least one SPACE or TAB character. The closing square bracket must be preceded by at least one SPACE or TAB character.
The following test statement uses the Korn shell syntax.
$ [[ condition ]]
Again, that the characters, [[, represents to command word, test and must be followed by at least one SPACE or TAB character. The closing square brackets must be preceded by at least one SPACE or TAB character.
The AND and OR statements differ between the Bourne and the Korn shell syntax.
Bourne shell syntax:
$ [ condition1 -a condition2 ] # ( 1 AND 2) $ [ condition1 -o condition2 ] # ( 1 OR 2)
Korn shell syntax:
$ [[ condition1 && condition2 ]] # ( 1 AND 2) $ [[ condition1 condition2 ]] # ( 1 OR 2)
The -a and -o clauses can not be used inside the Korn shell-specific, [[...]], test statement.
Numeric Conditional Testing:
Numeric conditional testing can be carried out within double round-brackets. The following test statements are unique to the Korn shell.
$ ((condition))
The opening double round brackets need not be followed by a SPACE or TAB character. Nor do the closing double round brackets neet to be preceeded by a SPACE or TAB.
Numeric conditions can be:
Condition Description
((x==$y)) Test if x is equal to y. ((x!=$y)) Test if x is not equal to y. ((x>$y)) Test if x is greater than y. ((x<$y)) Test if x is less than y. ((x>=$y)) Test if x is greater than or equal to y. ((x<=$y)) Test if x is less than or equal to y. If numeric variables are used within the test condition, the variable name does not to be preceded by a dollar ($) character if the variable name is to the left of the equals (=) character. The following two test conditions would be treated as being identical: (($var==3)) Test if content of variable,var, is equal to 3. ((var==3)) Test if content of variable, var, is equal to 3. Note: Any special shell variable, such as # (number of arguments) or ? (return status value) do need to be preceeded by the $ character. (($#==3)) would be a valid test condition, whereas((#==3)) would not! Logic Testing (if, then, ..., fi): The logical state of a condition can be used to determine whether one or more command lines should be executed. The simplest form of locical branching is performed using the if conditional statement. The structure of an if statement can be any of the following. Note: The word "then" is a reserved word and must be treated as a command in its own right. If it is to appear on the same command line as the if statement, it must be preceded by a semi-colon (to separate the two commands). if condition_statement then ... series of commands to be executed ... fi is the same as if condition_statement ; then ... series of commands to be executed ... fi For readability, it is probably better to have the word, then, on a line of its own. if statements can be nested, as shown below. Each if must be closed by the command word fi (the word `if' reversed). if condition_statement then command line 1 command line 2 if condition_statement2 then commands_for_nested_if fi command line 3 command line 4 fi Logic Testing (if, then,... elif ... ,else ...): Alternative command sequences can be executed based on the TRUE or FALSE state of a condition test. Shown below are more forms for the if statement. if condition_statement then commands to be executed if condition is TRUE else commands to be executed if condition is FALSE fi Multiple conditions can be applied. For example: if condition_statement1 then commands to be executed if condition1 is TRUE elif condition_statement2 then commands to be executed if condition2 is TRUE elif condition_statement3 then commands to be executed if condition3 is TRUE else commands executed if preceding conditions are FALSE fi Note that each elif is followed by the separated command word, then. The entire statement is closed down by just one occurrence of the word fi. Any of the conditional statements, described on the preceding pages could be used where the words, condition_statement, appear in the examples shown above. Logic Testing (case ... esac): As an alternative to using if then ... fi, the Korn shell supports the use of the case statement. The syntax for the case statement is: case value in pattern1) commands to execute when value matches pattern1 ;; pattern2) commands to execute when value matches pattern2 ;; ... patternn) commands to execute when value matches patternn ;; esac Where value could be either: A variable's contents (substituted on the command line) or A single value returned by a command substitution. When value matches one of the patterns, no further attempt will be made to match any other patterns within the case statement. The pattern can be any shell pattern matching structure. Multiple, alternative patterns can be used when separated by the pipe () character. Pattern Matching within case ... esac: The patterns which can be used within case ... esac are: Pattern Description
abcd) The literal string of characters, `abcd'.
ab) The literal character, `a' or `b'.
a*) The letter `a' followed by zero or more (of any) characters
a*A*) The letter `a' or the letter `A' followed by zero or more occurrences of any character
[aA]*) The letter `a' or the letter `A' followed by zero or more occurrences of any character
[!aA]*) A string of 1 or more occurences of any character where the first character is not the letter `a' or `A'.
a????) A four-character string of characters where the first character is the letter `a'.
\)) A literal bracket `)'.
*) Any number (zero or more) of any character.
The last pattern, shown above, would normally be used as the last, "catch all", pattern match. For example:
case $var in
ab) echo "var contains the letter a or b" ;;
[AB]) echo "var contains the letter A or B" ;;
*) echo "var does not contain a, A, b or B" ;;
esac

About Me

This site will be helpful for Unix system administrator to automate their tasks using scripts, comments on posts are welcome.