UNIX Shell Scripting<\/p>\n
The basic concept of a shell script is a list of commands, which are listed in the order of execution. A good shell script will have comments, preceded by a pound sign, #, describing the steps. There are conditional tests, such as value A is greater than value B, loops allowing us to go through massive amounts of data, files to read and store data, and variables to read and store data, and the script may include functions.
\nShell scripts and functions are both interpreted. This means they are not compiled. Both shell scripts and functions are ASCII text that is read by the Korn shell command interpreter. When we execute a shell script, or function, a command interpreter goes through the ASCII text line by line, loop by loop, test by test and executes each statement, as each line is reached from the top to the bottom.<\/p>\n
1. A shell is an environment in which we can run our commands, programs, and shell scripts. There are different flavors of shells, just as there are different flavors of operating systems. Each flavor of shell has its own set of recognized commands and functions.<\/p>\n
Korn Shell \/bin\/ksh OR \/usr\/bin\/ksh<\/p>\n
The standard Shell on Linux is the Bourne Again shell (bash) shell, and some others use Bourne shell (sh) as the default. To find your Default shell:
\n Echo $SHELL
\n2. If the special characters are used to in a way that their special meaning is not needed then they must be escaped. To escape or remove its special function, the character must be preceded with a backslash \\ or enclosed within \u201c\u201cforward tic mark.<\/p>\n
\\ ( ; # $ ? & * ( ) [ ] ` \u2018 \u201c +
\n3. A shell script can be executed in the following ways:<\/p>\n
Ksh shell_script_name<\/p>\n
a. Will create a Korn shell and execute the shell_script_name in the newly created Korn shell environment.
\n shell_script_name
\nThe script will execute in the shell that is declared on the first line of the shell script. If no shell is declared on the first line of the shell script, it will execute in the default shell, which is the user\u2019s system-defined shell. Executing in an unintended shell may result in a failure and give unpredictable results.<\/p>\n
Declare the Shell in the Shell Script:<\/p>\n
We MUST declare the shell in the very first line of the script. If no shell is declared, the script will execute in the default shell, defined by the system for the user executing the shell script.<\/p>\n
#! \/usr\/bin\/ksh OR #! \/bin\/ksh.
\n#! \/usr\/bin\/sh OR #! \/bin\/sh declares a Bourne shell
\n#! \/usr\/bin\/ksh OR #! \/bin\/ksh declares a Korn shell
\n#! \/usr\/bin\/csh OR #! \/bin\/csh declares a C shell
\n#! \/usr\/bin\/bash OR #! \/bin\/bash declares a Bourne-Again shell
\nComments:<\/p>\n
We have to write code that is readable and has an easy flow. This involves writing a script that is easy to read and easily maintained, which means that it must have plenty of comments describing the steps.
\n#!\/usr\/bin\/ksh
\n#
\n# SCRIPT : NAME_of_SCRIPT
\n# AUTHOR : AUTHORS_NAME
\n# DATE : DATE_of_CREATION
\n# REV : 1.1.A (Valid are A, B, D, T and P)
\n (For Alpha, Beta, Dev, Test and Production)
\n## PLATFORM : (SPECIFY: AIX, HP-UX, Linux, Solaris or Not platform dependent)
\n#
\n# PURPOSE : Give a clear, and if necessary, long, description of the purpose
\n Of the shell script.<\/p>\n
#
\n# REV LIST:
\n# DATE : DATE_of_REVISION
\n# BY : AUTHOR_of_MODIFICATION
\n# MODIFICATION : Describe what was modified, new feature, etc.
\n#
\n# set -n # Uncomment to check your syntax, without execution.
\n# # NOTE: Do not forget to put the comment back in or
\n# # the shell script will not execute!
\n# set -x # Uncomment to debug this shell script (Korn shell only)
\n##########################################################<\/p>\n
########### DEFINE FILES AND VARIABLES HERE ##############
\n##########################################################<\/p>\n
############### DEFINE FUNCTIONS HERE ####################
\n##########################################################<\/p>\n
##########################################################
\n################ BEGINNING OF MAIN #######################
\n##########################################################<\/p>\n
# End of script
\nFunctions:
\nwe can write a piece of code, which is used over and over, just once and use it without having to rewrite the code every time. We just call the function instead.<\/p>\n
Form of the function<\/p>\n
Function function_name
\n{
\nCommands to execute
\n}
\nOr
\nfunction_name ()
\n{
\nCommands to execute
\n}
\nControl Structures:<\/p>\n
If … then Statement<\/p>\n
If [test_command]
\nThen
\n Commands
\nFi
\nIf … then … else Statement
\nIf [test_command]
\nThen
\n Commands
\nElse
\n Commands
\nFi
\nIf … then … elif … (else) Statement
\nIf [test_command]
\nThen
\n Commands
\nElif [test_command]
\nThen
\n Commands
\nElse (Optional)
\n Commands
\nFi
\nFor … in Statement
\nFor loop_variable in argument list
\nDo
\nCommands
\nDone<\/p>\n
While Statement
\nWhile test_command_is_true
\ndo
\n Commands
\nDone
\nUntil Statement
\nuntil test_command_is_true
\ndo
\n Commands
\nDone
\nCase Statement
\ncase $variable in
\nmatch_1)
\ncommands_to_execute_for_1
\n;;
\nmatch_2)
\ncommands_to_execute_for_2
\n;;
\nmatch_3)
\ncommands_to_execute_for_3
\n;;
\n.
\n.
\n.
\n*) (Optional – any other value)
\ncommands_to_execute_for_no_match
\n;;
\nesac<\/p>\n
Break Continue, exit and return:<\/p>\n
It is sometimes necessary to break out of a for or while loop, continue in the next block of code, exit completely out of the script, or return a function\u2019s result back to the script that called the function.
\nBreak: Is used to terminate the execution of the entire loop, after completing the execution of all of the lines of code up to the break statement. It then steps down to the code following the end of the loop.
\nContinue: Is used to transfer control to the next set of code, but it continues execution of the loop.
\nExit: Will do just what one would expect: It exits the entire script. An integer may be added to an exit command (for example, exit 0), which will be sent as the return code.
\nReturn: Is used in a function to send data back, or return a result, to the calling script.<\/p>\n
Here Document: || : Logical OR\u2014command1 ||command2 && : Logical AND\u2014command1 && sdiff : Compare two files side by side ps : Information on currently running vmstat :Show virtual memory status who am I : Display login name, terminal, login f, finger : Information about logged-in users wall : Display a message on all logged-in basename : Base filename of a string su : Switch to another user, also known as awk : Programming language to parse Variables: To assign a variable to point to data: Note: The positional parameters, $0, $2, etc., in a function, are for the function\u2019s use and may not be in the environment of the shell script that is calling the function. Where a variable is known in a function or shell script is called the scope of the variable.<\/p>\n Shift Command Special Parameters $* and $@ Double Quotes \u201c, Forward Tics \u2019, and Back Tics ` Operators Chmod Permissions<\/p>\n 4000 Setting Traps Exit Signals<\/p>\n 0 Uppercase or Lowercase Text Typeset -u VARIABLE: The -u switch to the typeset command is used for uppercase. Cron Tables<\/p>\n 15 3 8 1 * \/usr\/local\/bin\/somescript.sh at Command<\/p>\n Like a cron table, the at command executes commands based on time. Using the at command we can schedule a job to run once, at a specific time.<\/p>\n Silent Running<\/p>\n To execute a script in silent mode (without any output to the screen), we can use the following syntax: The getopts command is built in to the Korn shell. It retrieves valid command-line options specified by a single character preceded by a – (minus sign) or + (plus sign). To specify that a command switch requires an argument to the switch, it is followed by a : (colon). If the switch does not require any argument then the : should be omitted. All of the options put together are called the OptionString, and this is followed by some variable name. The argument for each switch is stored in a variable called $OPTARG. If the entire OptionString is preceded by a : (colon), then any unmatched switch option causes a ? to be loaded into the VARIABLE.<\/p>\n Example:<\/p>\n SECS=0 # Initialize all to zero UNIX Shell Scripting<\/p>\n The basic concept of a shell script is a list of commands, which are listed in the order of execution. A good shell script will have comments, preceded by a pound sign, #, describing the steps. There are conditional tests, such as value A is greater than value B, loops allowing us […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[47],"tags":[],"_links":{"self":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/3272"}],"collection":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=3272"}],"version-history":[{"count":1,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/3272\/revisions"}],"predecessor-version":[{"id":3273,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/3272\/revisions\/3273"}],"wp:attachment":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=3272"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=3272"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=3272"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
\nA here document is used to redirect input into an interactive shell script or program. The input that is supplied must be the exact data that the program is expecting, and many programs will fail if spaces are added to the input.
\nSyntax for a Here Document
\nprogram_name <
\n> : Redirect, create, or overwrite a
\n file
\n| : Pipe, used to string commands
\n together<\/p>\n
\n \u2014execute command2 if command1
\n fails
\n& : Execute in background<\/p>\n
\n command2\u2014execute command2 if
\n command1 succeeds
\ndate : Display the system date and time
\necho : Write strings to standard output
\nsleep : Execution halts for the specified
\n number of seconds
\nwc : Count the number of words, lines,
\n and characters in a file
\nhead : View the top of a file
\ntail : View the end of a file
\ndiff : Compare two files<\/p>\n
\n (requires 132-character display)
\nspell : Spell checker
\nlp, lpr,
\nenq, qprt : Print a file
\nlpstat :Status of system print queues
\nenable : Enable, or start, a print queue
\ndisable : Disable, or stop, a print queue
\nrwall : Display a message to all users on a
\n remote host
\nrsh or remsh
\n : Execute a command, or log in, on a
\n remote host
\ndf : File systems statistics<\/p>\n
\n processes
\nnetstat : Show network status<\/p>\n
\ncal : Display a calendar
\nwho : Display information about users on
\n the system
\nw : Extended who command
\nwhoami : Display $LOGNAME or $USER
\n environment parameter<\/p>\n
\n date\/time, and where logged in<\/p>\n
\n including the users .plan and .project
\ntalk : Two users have a split screen
\n conversation
\nwrite : Display a message on a user\u2019s screen<\/p>\n
\n users\u2019 screens
\niostat : Show input\/output status
\nuname : Name of the current operating
\n system, as well as machine
\n information
\nsar : System activity report<\/p>\n
\n parameter
\nman : Display the on-line reference manual<\/p>\n
\n super-user
\ncut : Write out selected characters<\/p>\n
\n characters
\nsed : Programming language for character
\n substitution
\nvi : Start the vi editor
\nemacs : Start the emacs editor
\n`command` : Command substitution
\n( ) : Run the enclosed command in a sub-
\n shell
\n(( )) : Evaluate and assign value to variable
\n and do math in a shell
\n$(( )) : Evaluate the enclosed expression
\n[ ] : Same as the test command
\n[[ ]] : Used for string comparison
\n$( ) : Command substitution<\/p>\n
\nA variable is a character string to which we assign a value. The value assigned could be a number, text, filename, device, or any other type of data. A variable is nothing more than a pointer to the actual data.<\/p>\n
\n$VARIABLE_NAME=\u201dvalue_to_assign\u201d
\nTo view the data assigned to the variable
\n Echo $UPPERCASE or print $UPPERCASE for variables
\n Cat $UPPERCASE if the variable pointing to a file, as a command structure
\nCommand-Line Arguments:
\nThe command-line arguments $1, $2, $3,…$9 are positional parameters, with $0 pointing to the actual command, program, shell script, or function and $1, $2, $3, …$9 as the arguments to the command.<\/p>\n
\nThe shift command is used to move positional parameters to the left; for example, shift causes $2 to become $1. We can also add a number to the shift command to move the positions more than one position; for example, shift 3 causes $4 to move to the $1 position.<\/p>\n
\nThe $* special parameter specifies all command-line arguments.
\nThe $@ special parameter also specifies all command-line arguments.
\nThe \u201c$*\u201d special parameter takes the entire list as one argument with spaces between.
\nThe \u201c$@\u201d special parameter takes the entire list and separates it into separate arguments.<\/p>\n
\nWe use \u201c, double quotes, in a statement where we want to allow character or command substitution.
\nWe use \u2018, forward tics, in a statement where we do not want character or command substitution.
\nWe use `, back tics, in a statement where we want to execute a command, or script, and have its output substituted instead; this is command substitution.
\nMath in a Shell Script
\nThe Korn shell let command and the ((expr)) command expressions are the most commonly used methods to evaluate an integer expression.<\/p>\n
\n++ \u2014
\nAuto-increment and auto-decrement, both prefix and postfix
\n+
\nUnary plus
\n–
\nUnary minus
\n!~
\nLogical negation; binary inversion (one\u2019s complement)
\n* \/ %
\nMultiplication; division; modulus (remainder)
\n+ –
\nAddition; subtraction
\n<< >>
\nBitwise left shift; bitwise right shift
\n<= >=
\nLess than or equal to; greater than or equal to
\n< >
\nLess than; greater than
\n== !=
\nEquality; inequality (both evaluated left to right)
\n&
\nBitwise AND
\n^
\nBitwise exclusive OR
\n|
\nBitwise OR
\n&&
\nLogical AND
\n||
\nLogical OR<\/p>\n
\nSets user ID on execution
\n2000
\nSets group ID on execution
\n1000
\nSets the link permission to directories or sets the save-text attribute for files.
\n0400
\nPermits read by owner
\n0200
\nPermits write by owner
\n0100
\nPermits execute or search by owner
\n0040
\nPermits read by group
\n0020
\nPermits write by group
\n0010
\nPermits execute or search by group
\n0004
\nPermits read by others
\n0002
\nPermits write by others
\n0001
\nPermits execute or search by others<\/p>\n
\nWhen a program is terminated before it would normally end, we can catch an exit signal. This is called a trap.<\/p>\n
\nNormal termination, end of script
\n1
\nHang up, line disconnected
\n2
\nTerminal interrupt, usually CONTROL-C
\n3
\nQuit key, child processes to die before terminating
\n9
\nkill -9 command, cannot trap this type of exit status
\n15
\nkill command\u2019s default action
\n24
\nStop, usually CONTROL-z<\/p>\n
\nVARIABLE VALUES
\nExpected input: TRUE
\nReal input: TRUE
\nPossible input: true TRUE True True, etc…
\nUPCASING
\nUPCASEVAR=$(echo $VARIABLE | tr \u2018[a-z]\u2019 \u2018[A-Z]\u2019)
\nDOWNCASING
\nDOWNCASEVAR=$(echo $VARIABLE | tr \u2018[A-Z]\u2019 \u2018[a-z]\u2019)
\n\u2018[a-z]\u2019 \u2018[A-Z]\u2019 Used for lower to uppercase
\n\u2018[A-Z]\u2019 \u2018[a-z]\u2019 Used for upper to lowercase<\/p>\n
\nExample: EXAMPLE:
\nTypeset -u VARIABLE
\nVARIABLE=\u201dTrue\u201d
\necho $VARIABLE
\nTRUE
\nTypeset -l VARIABLE: always translate characters to lowercase
\nExample:
\n Typeset -l VARIABLE
\nVARIABLE=\u201dTrue\u201d
\necho $VARIABLE
\ntrue<\/p>\n
\n |
\nMinute (0 through 29)
\nHour (0 through 23)
\nDay of the Month (1 through 31)
\nMonth (1 through 12)
\nWeekday (0 – 6 for Sunday to Saturday)<\/p>\n
\n\/PATH\/script_name 2>&1 > \/dev\/null
\nGetopts<\/p>\n
\nMINUTES=0
\nHOURS=0
\nDAYS=0
\nPROCESS= # Initialize to null
\nwhile getopts :s:m:h:d:p: TIMED 2>\/dev\/null
\ndo
\ncase $TIMED in
\ns) SECS=$OPTARG
\n;;
\nm) (( MINUTES = $OPTARG * 60 ))
\n;;
\nh) (( HOURS = $OPTARG * 3600 ))
\n;;
\nd) (( DAYS = $OPTARG * 86400 ))
\n;;
\np) PROCESS=$OPTARG
\n;;
\n\\?) usage
\nexit 1
\n;;
\nesac
\ndone
\n(( TOTAL_SECONDS = SECONDS + MINUTES + HOURS + DAYS ))<\/p>\n","protected":false},"excerpt":{"rendered":"