Thursday, 31 January 2013

Shell Scripting Basics For Easy Reference

The first line in your script must be #!/bin/bash, that is a # (Hash) followed by a ! (bang) followed by the path of the shell, (#!) known as hashbang or shebang or poundbang. This line lets the environment know the file is a shell script.

#! -- shebang or hashbang

---> Interactinve and Non-Interactive shell interfaces

---> In interactive we get direct access, we can do any thing on the shell.

---> shell performs command line parsing # cd --- takes us to the users home directory

---> shell is comes as follows " username@name-of-the-system current-directory"

---> # shows as root level user

---> $ normal level user

---> Files in bash which helps to customise user's environment:- system and user level configuration files

---> The less root level privilage you use with script that much better

---> Built-in and non-built-in commands are there.

---> vim /etc/profile --------- a global configuration file. system wide environment and startup for 
login-setup also configure functions and alias in /etc/bashrc and bashrc.

---> hostname,history size and several login options 
are able to configure in /etc/profile, And bash reads
its global settings from the file /etc/profile 
( main bash config file). which contains system wide
environmental variables.

---> Define variable with upper-case. System variables 
and User Defined variables. System Variables usually in 
caps and User Defined variables usually in lowercase letters.

---> bashrc file also contains aliases and functions, 
any logic which is performed on a user which loges into the
system goes to " bashrc " where as /etc/profile contains 
global variables(mail,logname etc).

---> /etc/skel, contains .bash_logout, .bash_profile, 
.bashrc, these imp files. When you logout anything 
specified in .bash_logout will happen.

If we make any changes in /etc/skel only new users which 
created will inherit the new properties not the existing
users. In-order to affect the currently existing users in 
system you have to modify there individual .bash_ files.

---> ~ in bash represents users home directory.

---> when a user logged-in first a system wide file 
and then user based files are read. 
 /etc/profile,/etc/bashrrc, ~/.bash_profile, ~/.bashrc

---> when you create a new users using useradd, 
what all files are there in /etc/skel are copied 
in their home directory automatically.

---> In redhat linux bash is the default shell.

---> anything prefixed by a $ sign acts as a variable
When ever you created a variable, in-order to get it 
on the bash you have to export it,just defining is not 
enough, you have to export it(/etc/profile )

---> variables are of two types, system variables and user defined variables.

# echo $SHELL
# echo $PATH

---> variablename=value
# echo $n -----> $ sign is used with the variable in-order
 to print the contents of the variable ($n).

---> To define a null variable n=""

---> echo command to display the test or value of a variable.
some options include -e, -n, \n---> new line, -t etc.

----> userlevel variable set in .bash_profile helps to 
over-ride the global variable set in /etc/profile.Check by
setting variables in /etc/profile and in .bash_profile for a user and echo it in the shell eg: # echo $TEST

And this user level variables did not affect globally.

----> If we export the variables in /etc/skel files,
when we created a new user it will export the same variables for new user as well, no need to export it seperately so we can save time as well.

Conditional testing / Comparison / Decision making

Bash invokes 'test' when ever we needs comparisons between
strings,files etc. test allows conditional testing.
To instruct bash we are doing a test we can either use
" [ expression ] " bracket or " test expression " itself.

eg:- # test 1 -eq 1 OR [ 1 -eq 1 ]

either way we can use the comparison.

---> in shell $? acts as an exit-status variable. In a
command/script it will return two types of values, 
if return value is zero command is successful, if return value is non-zero command is not successful.

$? ----> gives the exit status of previously executed command. In unix terminology 0 is good and if it is any other number say 1,2 etc command is not executed properly.And in boolean terminology 0 is false and 1 is true. If a false value it will display from -1,32 but not zero.

# echo $?

---> Different operators in shell script for comparision are:

-eq, -le, -ge, -ne, -lt, -gt

 -eq = equal to

 -ne = not equal to

 -lt = less than

 -le = less than or equal to

 -gt = greater than

 -ge = greater than or equal to

example:- with "test" and "[ ]"

 if test 5 -eq 6 OR if [ 5 -eq 6 ]

 if test 5 -ne 6 OR if [ 5 -ne 6 ]

 if test 5 -lt 6 OR if [ 5 -lt 6 ]

 if test 5 -le 6 OR if [ 5 -le 6 ]

 if test 5 -gt 6 OR if [ 5 -lt 6 ]

 if test 5 -ge 6 OR if [ 5 -ge 6 ]

We can use both ways of comparision, just check below as well. the below set is mainly used for "string comparision".

---> For comparing strings of characters,

 test hai  = hai

 test hai != hai

---> another good function is checking "NEWER THAN ( -nt )", say create new files and check whether one is newer than other.

 eg:- touch test1
      touch test2  ---- both have same timestamp when we type but have a seconds difference. Let's check how it working

 [ test1 -nt test2 ]; echo $?

 We can use "OLDER THAN ( -ol )" as well. 

 [ test1 -nt test2 ]; echo $?

---> we can check other files whether it is a "character devices" or "block devices"

eg:-  test -b test1; echo $?
      test -c /dev/cdrom; echo $?

---> Also we can check whether a file existing or not

 test -e testing3; echo $? --- it will return 1 if not existing. We can check both files and directories like this.

---> check whether its a regular file or not

 mkdir testing3

test -f testing3; echo $? ----> will return 1 and its not a regular file.

now remove testing3 and touch a file called testing3 and run the previous command

test -f testing3; echo $? ---> it will return 0 and its is a regular file.

  [ -f testing3 ]; echo $?

---> we can also check for sockets as well 

test -S /var/lib/mysql/mysql.sock ; echo $?

---> Zero byte or non-zero byte file

test -s file3; echo $?

check man test for more options.

Shell also Test for Files and Directories 

-s file --- File exists and it's a non-empty file ie, file contains something.
-f file --- File exists and it's a normal file and not a directory
-d dir  --- File exists and it's a directory 
-w file --- File is writable, need write permission on the file
-r file --- File is readable
-x file --- File is Executable

 Operator and Its Meaning

 ! expression ---> Logical NOT

 expression1 -a expression2 ---> Logical AND

 expression1 -o expression2 ---> Logical OR

 Shell Arithmetics

# expr 1 + 1
  expr 2 - 1

  expr 10 / 2

  expr 20 % 3 ---- remainder

  expr 10 \* 10 ---- multiplication

Quotes inside the shell

" " ------> Double quote ----> Anything enclosed in double quote removes meaning of those character ( except \, `, and $ )

 '   ------> Single quote ----> Anything enclosed in single quote remains unchanged

 `   ------> Back quote   ----> To execute command

eg: echo "Today is `date`"

    echo `expr 6 + 3` 

 Reading input from command line/standard input

" read " statement is used to get input (data) from user and store the data in a variable.

eg:- # echo "your name:"
     # read fname
     # echo "Hello $fname, let's be friends.

Command line arguments

 When you run the command # ls file1 file2 file3, ls is the command and file1,file2,file3 are command line arguments passed to it.

Hence command has 3 command line arguments,

---> $# holds number of arguments specified on command line.And $* or $@ refers to all arguments passed to script.

---> $* expands to a single variable containing all the command line parameters separated by space.

---> $@ expands to a list of separated words, each containing one of the command line parameters.

---> $# is the number of parameters excluding $0

These command line arguments to shell script are known as "positional parameters".

---> $1 represent first argument, $2 represents second argument, $3 represents third argument and so on.

 Basic commands in bash environment

---> cat # concatenate files ( standard input to standard output), which works with the beginning of the file.

---> tac # which performs reverse of cat

---> cat test1
---> cat < tst1 # both performs same operation

---> cat -A test1


in the above examp, it prints all lines and contains a $(regular expression) sign which indicates the end of the line. ^I which indicates a tab(if we press tab after ctechz onlt it will show).

-A --- show all
-T --- show Tabs
-s --- squeeze-blank ---- which will remove the blank spaces

---> cat test1 test2 > test1A # all datas in test1 and test2 are updates in test1A

---> tac test1 # it will perform the reverse of the cat, ie, cat will display from the first line of the file to last line and tac will display from the last line to first line.

---> which # tells the location of a command

---> /var/log/messages # system messages files

---> wc # count

wc file1 # it will display number of lines,words,characters in a file.

---> cut # wc -l test1 | cut -d ' ' -f 7
here -d represents delimeter here it is space ' ' --- represents space and -f represents field. Specify the delimeter in a single quote.

---> ls

---> ls --time=atime -lrt test1 # shows the last access time os test1 file

ls --time=ctime -lrt test1 # shows the last modification time

---> sleep # the number of sec the script should sleep for

   sleep 5 -- sleep for 5 sec

---> usleep # it counted in micro sec

---> time # it shows how much time it take to run a command

      time cmd

---> ps -aux # shows all the proceses running.

---> watch  # will refresh in every 2sec, 

    watch tail /var/log/messages

---> date  # date +FORMAT

    date -r filename # gives last modification time of the file

---> expr # man expr

expr 10 * 100 give an error because astrix in bash is a reserved character, is a wildcard so we have to use escape character( \ ) so just escape the character using a back slash.

     expr 10 \* 100

---> let 

ex:- # i=1
     # echo $i -- it will return value 1
     # i=`expr $i + 1` -- it will increment the value
     # echo $i -- it will return value 2

---> expr ctechz = ctechz --- which will trturn 1, which is a boolean true.

---> expr length ctechz --- will return the lenght of the string.

---> expr substr ctechz 1 5 ----> shows substring operation

here 1 mans first character and 5 means characters, ie, it prints up to 5 characters.

   expr substr $var1 1 4
  or expr length $var1

---> touch `date +%F`.log

 Job controls

# seq 50 ---- will print 1 to 50 ( sequence cmd )
 seq 0 9 ---- from zero to nine

 seq helps in constructing loops.

---> # ctrl+z sends a job to background & fg sends the job to foreground.

# jobs  cmd we can use to list the jobs.will list those running in background as well.

you can kill the backgroung jobs by bring it to foreground and press ctrl+c

---> and also we can use & to sent a job to background instead of pressing ctrl+z.

  seq 10000000 > junk.log &

and we can see those jobs running in background using "jobs" command. We can see the file growth using 'watch command"

 # watch ls -l junk.log

sort and uniq

sort will sort the datas that you are passing to it. and uniq command will eliminate the duplicate entries.

# vim data.log

then check using sort # sort data.log

it will sort all the values, then run # sort data.log | uniq

when we sort the values and pass it to uniq it will eliminate the duplicate entries coming when we sorting the file.

---> cut helps to specify the delimeter.

   cat /etc/passwd | cut -d: -f2
   cat /etc/passwd | cut -d: -f1,3

Character translation command " tr "

 # echo DATA1 | tr A-Z a-z  --- here it changes all the uppser case letters of DATA1 to lower case letters.
                 ( a-z A-Z as well )

  -s squeeze-repeats
ex:- # echo FILEE | tr -s A-Z
      FILE --- it will eliminate one repeated E from FILEE.

   # echo FILEE | tr -s A-Z | tr A-Z a-z

 Or else we can use it in another way as well

 # echo FILEE | tr -s A-Z | tr [:upper:] [:lower:]

 -c Compliment 

ex:- # echo DATA1.Log | tr -c A-Z z

 will replace all lowercase letters with z

[ #!/bin/bash
  #Author: Jeffin Mathew
  #Date: 12.08.2012
  #Purpose: purpose of the script

# touch --- for creating files
 # touch file1 file2

 # touch FILE{1,2,3,4,5}

 Built in commands

cd ~  ---> home dir of currently loged in user

read ----> which allows us to read variables from command line.

 # read test  ----> shell waits for us to give a value for test and use echo command to get the value back.

 # read firstname lastname
 jeffin mathew -----> give two values for the abouve variables.

 then echo the value of each variables or echo each values together # echo $firstname $lastname

# read -n 3 answer ---- -n option helps us to specify how many characters it can except before existing.
   echo $answer

we can get the values of all thse variables using # set, 

--> set | grep answer, it will list answer=yes
    set | grep lastname

---> and when we close the shell this variables disappear. And also We can remove this variable using the command # unset variablename.

# unset lastname
# echo $lastname


 if we have a script which is not an executable script while we try to run it say, ./ it will give a permission denied message.( if any command that is executable, then we can finish it using tab completion option or else tab will not work )

 then to execute the previous command run # source --> it will return the answer.
                                          # .

---> export -----> for exporting the variables

   # test=1000
  #  export test
  #  set | grep test

and eg:- # set | grep pwd

 Brace Expansion

# touch test{1,2,3}  ---- will create 3 files named test1,test,test3.

 with this we can add suffix also say, # touch test{1,2,3}_file. it will create files called touch1_file,touch2_file,touch3_file.

# mkdir test{1,2,3,4,5}

# mkdir -p jeffin mathew ctechz

# mkdir test {1,2,3,4,5}{6,1,8,9} ---> each left side characters will get a match in the right.

# rm -rf files{1,2,3} ---> to remove files other that rm -rf *


# vim .basrc

alias rm='rm -rf'
alias cp='cp -prf'
alias vi='vim'

after set like this "source" or "."the file inorder to work at the same time. 

remebmer we can give this alias in either /etc/bashrc or in .bashrc

To know which all aliases are set just run the command # alias

# alias ls='ls -l' ---> we can set alias like this as well. no export is necessary.

# unalias nameOfTheAlias ---> to unset an alias.

  unalias rm

 Exit Status / Error Levels

if we try to run a command that is not exit in the system an error status of 127 will return.

if we run a valid command with a bad argument it will return exit status 1.

While we execute certain command and it return an error, and if its exit status return error number 126 means there are some permission problems.

# exit

---> The exit status is mainly based on the last command it is run in the bash.

Command Chaining

Multiple commands in a single line. We can use | or ; for that.

# command1; command2; command3; command4.

 ctrl+A takes us to the beginning of the command line and Ctrl+E takes us to the end of the command line.

&& ----> command1 && command2 , if we put && (and) in between two commands the second one execute only if the first command is executed successfully or is the first command is return an exit status of zero.

|| ----> command1 || command2 , if we put ||(or) in between two commands the second command will executed only if the first one fails or if the first commands exit status is other than zero.

 I/O Redirection

Standard In and standard Out

When we run a command the standard-in is the keyboard and standard-out is the screen.

' < ' ---> used for Input Redirection

# cat < cmdFile ---> Redirecting the standard input to cat. Here the input is taking from cmdFile.

# grep Hello < cmdFile

 grep searches matching string and returns entire row.

' > ' ---> used for Output Redirection

# cat cmdFile > NewFileName  ----> redirect the output to new file called NewFileName.

' >> ' ---> we can append the commands to a file. if we give only one > it will over ride the existing file.

# grep Hello < cmdFile > cmdFile2.txt


Pipe allows to connects the output stream of a command "A"to the input stream of another command "B".

ls -a we can see hidden . and .. , the single . indicates the current directory and double .. indicates the root directory /.

to count the line count in a directory use # ls -A | wc -l. -A avoids listing . and ..

# ls | wc

3  3  15

3 files, 3 rows, and 15 characters.

 Command Substitution

use back quote for command substitution. ` `

# variable=`ls -l /etc`  ---> if we echo the contents of the variable it display the results in an ugly format. To preserver it in a good format use the following:

# echo "$variable" ---> if you want to preserve the formatting use " " and thus we can preserver the formatting.

To reassign a variable simply override the previous values with the new values.

for input redirection to a variable try, # testFile=`< list.txt`

 # echo $testFile

CS almost same as piping.

 Quoting nuances

While we are using one of the reserve key words in the bash be careful with it, 

eg: # echo i live me $

i love me $ ---> Here $ sign is printed. How ever if $ sigh is followed by any other values then bash interpreter will think what followed after $ will need variable substitution.

 eg: echo i love me $more

    i love me ---> here this much only print '$' and 'more' will not printed this is because bash by default cross reference it's set of variables in search of a variable called 'more'.

---> inorder to print the $ sign with the word 'more' we actually need to escape the $ sign. If we not escape the $ sign the bash interpreter thinks that it is for variable substitution or it is one of the reserver key words.

---> The official escape character in a bash interpreter is the "back slash (\)". When we specify \ the very next character or the character which follows it is escaped and is printed literally. 

eg: # echo i want money $50

i want money 0 ---> it will not print any just print zero

   # echo i want oney \$50 

i want money $50 ---> when we escape $ it will print $50.

# mkdir testing directory with a space

it will create 5 directory instead of one. In order to create it as a one directory we need to escape the space, 

# mkdir testing\ directory\ with\ a\ space ---> the slash after space tells to preserver the space.

---> we can also use double quote for making files or directory with space. 

 # mkdir "testing directory"

and when we echo any thing within a double quote it will echoed but anything followed by a $ sigh will not print say,

# echo "this is $" ---> here $ sign will print, if any value followed by this $ sign is there nothing will print including the $ sign.
# echo "this is $6" ---> Here it will not print $6.

In order to print $6 we have to use 'single quote'. # echo 'this is $6'. Or else we have to use escape character in front of the $ sign and it will print.

Every thing is preserved in single quote.

 Hello World 1

---> When we write a script give a header like #!/bin/bash, This is in-order to understand which interpreter we are using.

---> And if we calling second script from the first there is no need of giving header for the second script as we already specified it in the first script.

We may have one main script which include the other scripts.

 Functions helps to group logical sections of a code. 

# vim

we can declare a function like this inside a script. function is a keyword 

function showdate() {


# in above eg:- after function it comes the function name ie,showdate and open and closed paranthisis.

---> We can declare the function in a few ways. If you maintain the open and closed paranthisis set () then you don't need the keyword "function". ie, we can write like this

showdate() {


# we can declare using just function name itself. In-order to execute the function at the end of it we need to call the function, to call the function just specify the function name.

---> We can declare multiple functions. we can call the function any where, there is no order for it.

---> we can declare variables inside a function and treat it as a local variable and also can declare out side a function and treated it as a global variable and this variables are available within each functions.

---> Here we have to declare the function first and call them after that.

 For loops

Bash by default support three types of loops for loop, while loop,until loop. 

syntax: for argument in [list]; do 
          action item


for argument in [list]
  action item

argument ---- any variable that we set

argument is equal to the first element or each element in the list as it cycles through the list. It assigns value to the argument.

For loop cyclic through lists.


1.     for contries in INDIA JAPAN MALI
      echo $contries

2. DIR="/etc"

  for i in `ls -A $DIR`
 echo $i

3.  for num in `seq 1 100`
  echo $num
for user in `cat $PASSFILE | cut -f1 -d:`
     echo $user
let "COUNT += 1" 

 While Loops

While loop essentially checks whether the exit status is zero,


1.  MIN=0
  while [ "$MIN" -lt "$MAX" ]
      echo $MIN
 let "MIN += 1"
2. while ["``"]
      echo $MIN
 let "MIN += 1"

let command allows you to increment or decrements a values within a script.
 Until Loop

until loop is essentially checks until the exit status is zero.
 ie, until the condition is true.

until [ condition-is-true ]; do command done

 1. NUM=100
 until [ "$NUM" -eq "$MIN" ]
   echo $NUM
   let "NUM -= 1"

2. until [ "$STATUS" -eq "0" ]
 ping -c 1
 echo The host is down
 STATUS=`echo $?`

 Control Structures -- conditions[ if-then-else-elif ]


if [ 1 -eq 1 ]
  echo Both values are equal


 if [ 1 -eq 1 ] OR if [ "ctechz" = "ctechz" ]
  echo Both values are equal
  echo Both values are unequal 


for contries in INDIA JAPAN MALI
    if [ "$countries" = "INDIA" ]
      echo Welcome to INDIA
elif [ "$countries" = "MALI" ]
              echo ONe Love
       echo $countries  



if [ -e $FILE ]
   echo File Exists
   echo NO File

-e checks for files


if [ -d $DIR ]
   echo File Exists
   echo NO File

-d checks for directories


# To compare two files and check which one is newer
# create two file


if [ $File1 -nt $FILE2 ]
   echo $File1 is newer
   echo $FILE2 is newer


Eg7:- nested if then

# This is used to check the command apache is running or not

netstat -antp | grep :80 or httpd > /dev/null 

if [ "$apachestatus" -eq 0 ]

  Echo apache is up and running

 # testing mysql 

   netstat -ant | grep 3306 > /dev/null

   if [ "$mysqlstatus" != 0 ]
  echo MYSQL is not running
echo mysql is running
   echo apache is not running


 Eg8:-  Case function

for contries in INDIA JAPAN MALI Australia France china latnav
    if [ "$countries" = "INDIA" ]
      echo Welcome to INDIA
elif [ "$countries" = "MALI" ]
              echo ONe Love
        elif [ "$countries" = "Australia" ]
echo good bye
       elif [ "$countries" = "France" ]
 echo merry
elif [ "$countries" = "china" ]
 echo wall
 elif [ "$countries" = "latnav" ]
 echo LNA
       echo $countries  

Modify above using case:- 

 for contries in USA Australia France Latvia Argentina Jamaica
     case $countries in USA )
 echo "welcome to US" ;;  -----> ;; (double semicolon is for terminating the case atmt)

# after writing the first case there is no need of writing elif and matching strings, instead just specify the values
    Australia )
echo : good day" ;;
France )
echo "Merri";;
Lativa )
echo "Hi";;
Argentina )
echo "Football";;
Jamaica )
echo "Cricket";;
esac ----> close the case with esac, case reverse. 

Here if it matches appropriate values it prints the echo,

 Positional parameters

Positional parameters are separated by spaces. 
# source 1 2


 echo $#

# source 1 
# source 1 2


 echo $#
seq $1 $2

# source 1 100


 echo $#
if [ $# != 2 ]
   echo This script requires two arguments
    echo "you entered $# parameters"
   exit $badparam
# Begin sequence
seq $1 $2

# source --- not correct
# echo $?

# source 1 10 ---> in the result first one is showing is the number of positional parameters.



 #echo $#

# echo ${10} ----> if u have more than 9 or 10 parameters, just initialise like this
 if [ $# != 2 ]
   echo This script requires two arguments
    echo "you entered $# parameters"
   exit $badparam
# Begin sequence
seq $1 $2

 Select Menus

:: shows usage of select

PS3='Select a choice: '
select var in "Choice1"
#    command
    echo "Hellow world"
   break # if break specify, it immediately exit after executing 

the above will have one choice

--> To iterate in different choice use a Variable "i"

PS3='Select a choice: '
List="Choice1 Choice2 Quit"
select i in $List
  if [ $i = "Choice1" ]
     echo "Hellow world"
 elif [ $i = "Choice2" ]
   echo "GBYE"
   elif [ $i = "Quit" ]
#   break # if break specify, it immediately exit after executing 


PS3='Select a choice: '
List="MySQL System Quit"
select i in $List
  if [ $i = "MySQL" ]
     watch tail /var/log/mysqld.log
 elif [ $i = "System" ]
   watch tail /var/log/messages
   elif [ $i = "Quit" ]
#   break # if break specify, it immediately exit after executing 


 Move Many Files

for file in `ls -A test*`
 echo $file
  mv $file $file.old


if [ $# != 1 ]
  echo at least 1 positional parameter is required!
 exit $BADARG

for file in `ls -A $1*`
 echo $file
  mv $file $file.old


./ test


if [ $# != $REQPARAM ]
  echo at least $REQPARAM positional parameter is required!
 exit $BADARG

for file in `ls -A $1*`
 echo $file
  mv $file $file.$2


./ test new (positional parameters)

Here in the parameters first one shows the pattern to glob for and second one show the extensions.

 NetWork Check

if [ "$#" -eq "0" ]
  ping -c 2 $SITE > /dev/null
if [ $? != 0 ]
 echo `date +%F` ---> command substitution
 echo No connection

# ./ > pinglog.`date`
# ./

Here the logic is, Default is go after google or go with the site specified with positional parameter.

 File Difference

Monitor directory for file changes:-

 Before proceeding with a directory better take a snapshot of the directory,

# cd directory
# ls -A > filelist1 -- will contain all list of files and dir in the main Dir
# wc -l dirsnap
# mkdir /usr/local/filediff/ 

--> move the script file to /usr/local/filediff Dir

ls -A $Monitordir > filelist2
Filediff=`diff filelist1 filelist2 | cut -f2 -d ' '`

for file in $Filediff
 if [ -e $Monitordir/$file ]

# -e shows it exist, here file exist

    echo $file
echo $Filediff


FTP Synchronization

:: contents synchronizing between two hosts,

cd temp2
:: all files in this host is going to sync with remote host

we can do it using tools called lftp, lftp has a functionality called mirroring and re-mirroring.
                                                                      forward-mirroring(push) and reverse mirroring(pull)
:: lftp root@

mkdir temp2 -----> create same dir in second host to where we need to synchronize the files.
:: help mirror -- when u r on lftp prompt

:: first host
touch ftpsync.lftp
this file used to accept commands from the main file

:: # lftp
lftp :~> open -uroot,redhat

2nd file
# vim ftpsunc.lftp
open -uroot,redhat
cd temp2
lcd /root/temp2 ---> ensure our local dir in temp2 
# mirrot ---> we are doing a reverse mirroring her mirror -Rn 

# lftp -f ftpsunc.lftp -- run it

1st file
# vim


lftp -f $LFTPscript


# ./

 Parse Logs

:: parse service logs for unwelcomed connections

#Threshold=5 ---> this is the number of instance that will willing to tolerate.

if [ $# != 1 ]
  echo one parameter is required for threshold values
   exit 165
Threshold=$1 --> $1 positional paramater

Offenses=`awk '/$Badname/ { print $8,$12 }' /var/log/vsftpd/vsftpd.log` | wc -l

# grep $Badname $Logfiles | awk '{ print $8,$12}' 

if [ $Offenses -gt $Threshold ]
  echo $Offenses attempted breaches were detected | mail -s "Breach attempt" root


 BackuP Files

if [ ! -e $Backupdir ]
   echo creating backupdir bcz its not existing
   mkdir ~/backup
   exit 0

ctrl+k , ctrl+uu

Name of shell script must end with a .sh, it helps to identify that its a shell script,Before running make the file executable # chmod 755

Let's check some shell variables and syntax :-

PATH - Sets the search path for any executable command
HOME - user home directory
MAIL - path of the location where mail addressed of the user is stored
USER - User login name.
TERM - indicates the terminal type being used
SHELL - Tells the type of shell that the user user can see when logged in

To see the values do an `echo` of the name of the variable preceeded with a $
# echo $SHELL

No comments:

Post a Comment