UNIX/Linux Bash Shell Scripting

How to format Flash/Pen Drive in Linux

2011-11-18T09:37:00.000-08:00


Note: I have used my device name and number in examples, you have to change it
as your device name and number, otherwise  unwanted device data will be wiped
out.

 Put your USB flash drive in one of your computer's free USB ports. After a few
seconds, Linux will automatically recognize it and an icon for it will appear on
your desktop. If pen drive doesn't mounted automatically, login as root and try
to mount it, still it is not mounted there may be a problem with pen drive or it
is defective.

Finding device: 

 Very very first thing is you should to know what device you are working with.
For that you can use any one of the following methods.

Method 1:  Using  ls /dev/sd*  command

First make sure your usb drive is not plugged in. Then run:

[venu@ras ~]$ ls /dev/sd*
/dev/sda   /dev/sda10  /dev/sda12  /dev/sda2  /dev/sda6  /dev/sda8
/dev/sda1  /dev/sda11  /dev/sda13  /dev/sda5  /dev/sda7  /dev/sda9

Once you have done that, put in your pen drive and run the above command again.

[venu@ras ~]$ ls /dev/sd*
/dev/sda   /dev/sda10  /dev/sda12  /dev/sda2  /dev/sda6  /dev/sda8  /dev/sdb
/dev/sda1  /dev/sda11  /dev/sda13  /dev/sda5  /dev/sda7  /dev/sda9  /dev/sdb1
 
Whatever drive (ex sdb) was not there before is your pen drive. From the above
list my pen drive is sdb. Don't be confuse with /dev/sdb and /dev/sdb1,  sdb is
a drive and sdb1 is first partition in that drive.

Method 2:  Using df command

[venu@ras ~]$ df
Filesystem           1K-blocks      Used Available Use% Mounted on

/dev/sda10            29753556   8008860  20208884  29% /
/dev/sda12            19840892   1528664  17288088   9% /msfiles
/dev/sda11            21825108  16772836   3925716  82% /venu
tmpfs                  1032232         0   1032232   0% /dev/shm
/dev/sdb1              1947636         4   1947632   1% /media/VENU
 
As you can see above my pen drive (/dev/sdb1) is mounted at /media/VENU. If you
have any doubt about which one is your pen drive, do same thing as in method1.
Run df command before and after inserting  pen drive.

Method 3:   dmesg | tail

[venu@ras ~]$ dmesg | tail
sdb: assuming drive cache: write through
SCSI device sdb: 3903359 512-byte hdwr sectors (1999 MB)
sdb: Write Protect is off
sdb: Mode Sense: 0b 00 00 08
sdb: assuming drive cache: write through
 sdb: sdb1
sd 8:0:0:0: Attached scsi removable disk sdb
sd 8:0:0:0: Attached scsi generic sg1 type 0
usb-storage: device scan complete
SELinux: initialized (dev sdb1, type vfat), uses genfs_contexts

Method 4:   mount -l

[venu@ras ~]$ mount -l
/dev/sda10 on / type ext3 (rw) [/]
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
/dev/sda12 on /msfiles type ext3 (rw) [/msfiles1]
/dev/sda11 on /venu type ext3 (rw) [/venu1]
tmpfs on /dev/shm type tmpfs (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
/dev/sdb1 on /media/VENU type vfat (rw,nosuid,nodev,shortname=winnt,uid=500)
[VENU]

Method 5:   fdisk -l 

fdisk command need root privileges. So login as root and run the command:

[root@ras ~]# fdisk -l
Disk /dev/sda: 500.1 GB, 500107862016 bytes
255 heads, 63 sectors/track, 60801 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

   Device Boot      Start         End      Blocks   Id  System

/dev/sda1   *           1        5099    40957686    7  HPFS/NTFS
/dev/sda2            5100       60800   447418282+   f  W95 Ext'd (LBA)
/dev/sda5            5100       10198    40957686    7  HPFS/NTFS
/dev/sda10          50994       54817    30716248+  83  Linux
/dev/sda11          54818       57622    22531131   83  Linux
/dev/sda12          57623       60172    20482843+  83  Linux
/dev/sda13          60173       60694     4192933+  82  Linux swap / Solaris

Disk /dev/sdb: 1998 MB, 1998519808 bytes
32 heads, 63 sectors/track, 1936 cylinders
Units = cylinders of 2016 * 512 = 1032192 bytes

   Device Boot      Start         End      Blocks   Id  System

/dev/sdb1               1        1936     1951456+   b  W95 FAT32

fdisk -l displays all detected drives even drive is unmounted.

Formatting pen drive:

 First decide which file system you want. FAT32 is probably the file system you
want, but that's up to you. Ext3 may not be work on windows, It asks for fomatt-
ing.

1.Once you have Identified your pen drive, unmount it.

[root@ras ~]# umount /dev/sdb1

2.Format pen drive now.

 Depending on distribution different commands are available for formatting, but
in general most used ones that I have seen are mkdosfs or mkfs.vfat for FAT32
and  mke2fs or mkfs.ext3 for Linux filesystems.

For Ms-Dos or Windows file system:

 Use mkdosfs -n "Label" -I /dev/sdx, Replace Label with the name you want the
pen drive to have and /dev/sdx with your drive.

[root@ras ~]# mkdosfs -n "KVMREDDY" -I /dev/sdb1
mkdosfs 2.11 (12 Mar 2005)
                              or
[root@ras ~]# mkfs.vfat -n "KVMREDDY" -I /dev/sdb1
mkfs.vfat 2.11 (12 Mar 2005)

           (Note: I – capital letter of i )

 If you don't want any Label then no need to supply option n. switch I will
force mkdosfs to work properly but it  is not mandatory, you can remove that
also.

For Linux File system:

 Use mkfs.ext3 -L "Label"  /dev/sdx for ext3 file system or mke2fs -L 'Label'
/dev/sdx for ex2, Replace Label with the name you want the pen drive to have
and /dev/sdx with your drive.

Ext3 file system:

[root@ras ~]# mkfs.ext3 -L "KVMREDDY" /dev/sdb1
mke2fs 1.39 (29-May-2006)
Filesystem label=KVMREDDY
OS type: Linux
.............................
[root@ras ~]# 

ext2 file system:  

[root@ras ~]# mke2fs -L 'VENU' /dev/sdb1
mke2fs 1.39 (29-May-2006)
Filesystem label=VENU
OS type: Linux
...........................
[root@ras ~]# 

 After formatting you will be returned to the prompt then remove and insert the
pen drive to have mounted again.

How to Remove RPM GPG Public Key

2011-10-08T04:45:00.000-07:00


 Public keys can be erased after importing just like packages. Here's how to
remove the CentOS GPG public key:

rpm -e <GPG public key>

[root@localhost]# rpm -qa gpg-pubkey*
gpg-pubkey-e8562897-459f07a4
[root@localhost]# rpm -e gpg-pubkey-e8562897-459f07a4
[root@localhost]# rpm -qa gpg-pubkey*
[root@localhost]#

If there are duplicates exist:

For example, Import the same key two times

[root@localhost]# rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
[root@localhost]# rpm -qa gpg-pubkey*
gpg-pubkey-e8562897-459f07a4
[root@localhost]# rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
[root@localhost]# rpm -qa gpg-pubkey*
gpg-pubkey-e8562897-459f07a4
gpg-pubkey-e8562897-459f07a4

Now try to remove Public Key, You will get error message like this:

[root@localhost]# rpm -e gpg-pubkey-e8562897-459f07a4
error: "gpg-pubkey-e8562897-459f07a4" specifies multiple packages

How to solve this:

Use --allmatches switch along with -e, It removes all versions of the package
which match PACKAGE_NAME(Public Key ).

[root@localhost]# rpm -e --allmatches gpg-pubkey-e8562897-459f07a4
[root@localhost]# rpm -qa gpg-pubkey*
[root@localhost]#

How to Import RPM GPG Key

2011-10-07T12:21:00.000-07:00


Note: All the commands tested on CentOs 5.x. Your output may be vary depending 
on distribution and version, so your results may not always look exactly like 
the listings and figures shown here. Almost all everything works well on
RHEL/CentOs/Fedora.

Why to check signature of an rpm:

 The signature confirms that the package was signed by an authorized party and
also confirm the integrity and origin of your file. It is extremely important
to verify the signature of the RPM files before installing them to ensure that
they have not been altered from the original source of the packages.

Checking a package's Signature:

 The --checksig(or -K)  option checks all the digests and signatures contained
in PACKAGE_FILE to ensure the integrity and origin of the package. Note that
signatures are now verified whenever a package is read, and --checksig is useful
to verify all of the digests and signatures associated with a package.

 If you wish to verify that a package has not been corrupted or tampered with,
examine only the md5sum by typing the following command at a shell prompt (where
<rpm-file> is the file name of the RPM package):

rpm -K --nosignature <rpm-file>

 The message <rpm-file>: md5 OK is displayed. This brief message means
that the file was not corrupted by the download. To see a more verbose message,
replace -K with -Kvv in the command.

 For demonstration purpose I downloaded createrepo package from CentOs mirror
and used in examples.

[root@localhost ~]# rpm -K --nosignature createrepo-0.4.11-3.el5.noarch.rpm
createrepo-0.4.11-3.el5.noarch.rpm: sha1 md5 OK

 On the other hand, how trustworthy is the developer who created the package? If
the package is signed with the developer's GnuPG key,you know that the developer
really is who they say they are.

 An RPM package can be signed using Gnu Privacy Guard (or GnuPG), to help you
make certain your downloaded package is trustworthy. GnuPG is a tool for secure
communication; it is a complete and free replacement for the encryption technol-
ogy of PGP, an electronic privacy program. With GnuPG, you can authenticate the
validity of documents and encrypt/decrypt data to and from other recipients.
GnuPG is capable of decrypting and verifying PGP 5.x files as well.

 During installation,GnuPG is installed by default. That way you can immediately
start using GnuPG to verify any packages that you receive from CentOs(RHEL/Fedor
a). Before doing so, you must first import CentOs's public key. If you not impo-
rted correct public key, you will get following error message.

[root@localhost ~]# rpm -K createrepo-0.4.11-3.el5.noarch.rpm
createrepo-0.4.11-3.el5.noarch.rpm: (SHA1) DSA sha1 md5 (GPG) NOT OK (MISSING
KEYS: GPG#e8562897)

Here the GPG in parentheses indicates that there's a problem with the signature,
and the message at the end of the line (MISSING KEYS) shows what the problem is.
Basically, RPM asked GPG to verify the package against a key(GPG#e8562897) that
GPG didn't have, and GPG complained. It means you missed the correct public key.

How to import public keys:

 Digital signatures cannot be verified without a public key. An ascii armored
public key can be added to the rpm database using --import. An imported public
key is carried in a header, and key ring management is performed exactly like
package management. For example, all currently imported public keys can be
displayed by:

rpm -qa gpg-pubkey* 

To verify CentOs (RHEL/Fedora) packages, you must import the CentOs(RHEL/Fedora)
GPG key. To do so, execute the following command at a shell prompt:

[root@localhost ~]# rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5 

This will create duplicate copies if one already exists.
To display a list of all keys installed for RPM verification,execute the command
[root@localhost ~]# rpm -qa gpg-pubkey*
gpg-pubkey-e8562897-459f07a4

                                  or

RPM has the capacity to retrieve the key from a  Mirror: 
[root@ ~]# rpm --import http://mirror.centos.org/centos/RPM-GPG-KEY-CentOS-5
[root@ ~]# rpm -qa gpg-pubkey*
gpg-pubkey-e8562897-459f07a4
gpg-pubkey-e8562897-459f07a4

Note: Depending on distribution and version, you have to change mirror link.


OK, public key imported, now check signature of the createrepo rpm.

[root@localhost ~]# rpm -K createrepo-0.4.11-3.el5.noarch.rpm
createrepo-0.4.11-3.el5.noarch.rpm: (sha1) dsa sha1 md5 gpg OK

 This means that the signature of the package has been verified, and that it is
not corrupted. If you want to know public key builder's name , execute the
command:

[root@~]# rpm -qa gpg-pubkey\* --qf "%{name}-%{version}-%{release}-%{summary}\n"
gpg-pubkey-e8562897-459f07a4-gpg(CentOS-5 Key (CentOS 5 Official Signing Key)
<centos-5-key@centos.org>)
gpg-pubkey-e8562897-459f07a4-gpg(CentOS-5 Key (CentOS 5 Official Signing Key)
<centos-5-key@centos.org>)
gpg-pubkey-2689b887-42315a9a-gpg(Hewlett-Packard Company (HP Codesigning Service
))

Note: For showing difference I imported HP GPG key.

 If you're the curious type and you want to know more information about imported
GPG key, use the following command.

rpm -qi <gpg-pubkey>

[root@localhost data]# rpm -qi gpg-pubkey-e8562897-459f07a4
Name        : gpg-pubkey           Relocations: (not relocatable)
Version     : e8562897             Vendor: (none)
Release     : 459f07a4             Build Date: Fri 07 Oct 2011 05:53:03 PM IST
Install Date: Fri 07 Oct 2011 05:53:03 PM IST      Build Host: localhost
Group       : Public Keys          Source RPM: (none)
Size        : 0                    License: pubkey
Signature   : (none)
Summary     : gpg(CentOS-5 Key (CentOS 5 Official Signing Key) <centos-5-key@
centos.orgi>)
Description :
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: rpm-4.4.2.3 (NSS-3)

mQGiBEWfB6MRBACrnYW6yKMT+MwJlCIhoyTxGf3mAxmnAiDEy6HcYN8rivssVTJk
CFtQBlBOpLV/OW2YtKrCO2xHn46eNfnMri8FGT8g+9JF3MUVi7kiV1He4iJynHXB
+F2ZqIvHf3IaUj1ys+p8TK64FDFxDQDrGQfIsD/+pkSGx53/877IrvdwjwCguQcr
Ioip5TH0Fj0OLUY4asYVZH8EAIqFHEqsY+9ziP+2R3/FyxSllKkjwcMLrBug+cYO
LYDD6eQXE9Mq8XKGFDj9ZB/0+JzK/XQeStheeFG75q3noq5oCPVFO4czuKErIRAB
qKbDBhaTj3JhOgM12XsUYn+rI6NeMV2ZogoQCC2tWmDETfRpYp2moo53NuFWHbAy
XjETA/sHEeQT9huHzdi/lebNBj0L8nBGfLN1nSRP1GtvagBvkR4RZ6DTQyl0UzOJ
RA3ywWlrL9IV9mrpb1Fmn60l2jTMMCc7J6LacmPK906N+FcN/Docj1M4s/4CNanQ
NhzcFhAFtQL56SNyLTCk1XzhssGZ/jwGnNbU/aaj4wOj0Uef5LRGQ2VudE9TLTUg
S2V5IChDZW50T1MgNSBPZmZpY2lhbCBTaWduaW5nIEtleSkgPGNlbnRvcy01LWtl
eUBjZW50b3Mub3JnPohkBBMRAgAkBQJFnwekAhsDBQkSzAMABgsJCAcDAgMVAgMD
FgIBAh4BAheAAAoJEKikR9zoViiXKlEAmwSoZDvZo+WChcg3s/SpNoWCKhMAAJwI
E2aXpZVrpsQnInUQWwkdrTiL5YhMBBMRAgAMBQJFnwiSBYMSzAIRAAoJEDjCFhY5
bKCk0hAAn134bIx3wSbq58E6P6U5RT7Z2Zx4AJ9VxnVkoGHkVIgSdsxHUgRjo27N
F7kBDQRFnwezEAQA/HnJ5yiozwgtf6jt+kii8iua+WnjqBKomPHOQ8moxbWdv5Ks
4e1DPhzRqxhshjmub4SuJ93sgMSAF2ayC9t51mSJV33KfzPF2gIahcMqfABe/2hJ
aMzcQZHrGJCEX6ek8l8SFKou7vICzyajRSIK8gxWKBuQknP/9LKsoczV+xsAAwUD
/idXPkk4vRRHsCwc6I23fdI0ur52bzEqHiAIswNfO521YgLk2W1xyCLc2aYjc8Ni
nrMX1tCnEx0/gK7ICyJoWH1Vc7//79sWFtX2EaTO+Q07xjFX4E66WxJlCo9lOjos
Vk5qc7R+xzLDoLGFtbzaTRQFzf6yr7QTu+BebWLoPwNTiE8EGBECAA8FAkWfB7MC
GwwFCRLMAwAACgkQqKRH3OhWKJfvvACfbsF1WK193zM7vSc4uq51XsceLwgAoI0/
9GxdNhGQEAweSlQfhPa3yYXH
=o/Mx
-----END PGP PUBLIC KEY BLOCK-----

You can view above PGP public key block directly by:

vi /etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5 

Depending on distribution, change file path.

Shell Script to Find Prime Factors of a Number

2011-06-24T22:24:00.000-07:00


In number theory, the prime factors of a positive integer are the prime numbers
that divide that integer exactly, without leaving a remainder. The process of
finding these numbers is called integer factorization, or prime factorization.
The fundamental theorem of arithmetic says that every positive integer has a
unique prime factorization.

Example:

The prime factors of 330 are 2, 3, 5 and 11:

               330 = 2 × 3 × 5 × 11

 There is no other possible set of prime numbers that can be multiplied to
make 330.

 You can find prime factors of a number using UNIX/Linux utility factor. This is
a very convenient and cool UNIX command. Here is its syntax:

$ factor 330
330: 2 3 5 11
$ factor 2121977
2121977: 11 11 13 19 71

 Many Algorithms have been devised for determining the Prime factors of a given
number. They vary quite a bit in sophistication and complexity. It is very diff-
icult to build a general-purpose algorithm for this computationally "hard" prob-
lem, so any additional information which is known about the number in question
or its factors can often be used to save a large amount of time.

 Here I am providing a shell script to find prime factors of a positive integer.
This script does most factorizations within a second. In the worst case scenario
(for some large semi-primes with more than 6-digit factors) factorization will
take a couple of minutes to hours.

#!/bin/bash
# SCRIPT:  primefactors.sh
# USAGE :  primefactors.sh <Positive Integer>
# PURPOSE: Produces prime factors of a given number.
#
###############################################################################
#                           Arguments Checking                                #
###############################################################################

if [ $# -ne 1 ]
then
    echo "Usage: scriptname <Positive Integer>"
    exit 1
fi

expr $1 + 1  &>/dev/null
if [ $? -ne 0 ]
then
    echo "Sorry, You supplied non numerical value"
    exit 1
fi

[ $1 -lt 2 ] && echo "Values < 2 are not prime numbers" && exit 1

num=$1

###############################################################################
#                              Functions                                      #
###############################################################################
# To know how to find prime number check bellow link:
# Shell script to find prime number
# Bellow function finds supplied argument is a prime or not.

primenumber()
{
           primenum=$1
           for ((counter2=2;$((counter2*counter2))<=$primenum;counter2++))
           do
               if [ $((primenum%counter2)) -eq 0 ]
               then
                    return 1
               fi
           done
           return 0
}

primefind()
{
# It's good to check that the number it self is a prime or not before going to
# find prime factors of a number. Comment out bellow line and supply a prime
# number or semi-prime, you will find the difference.
# Ex: primefactors.sh 2121979

        primenumber $1 && echo "$1" && exit 0

        for ((counter1=$2;counter1<=$1;counter1++))
        do
                primenumber $counter1 && factorcheck $1 $counter1 &&  break
        done
}

factorcheck()
{
     prime=$2
     newnum=$1
     remainder=$((newnum%prime))

     if [ $remainder -eq 0 ]
     then
          printf "%dx" $prime
          newnum=$((newnum/prime))
          primefind $newnum 2
          return
     else
          let prime++
          primefind $newnum $prime
    fi
}

###############################################################################
#                                   Main                                      #
###############################################################################

echo -n "Prime Factors of $1: "
primefind $num 2
printf "\b \n"                   # \b is used for removing last x.

OUTPUT:
[root@venu ]# sh primefactors.sh
Usage: scriptname 
[root@venu ]# sh primefactors.sh 21219797
Prime Factors of 21219797: 101x210097
[root@venu ]# sh primefactors.sh 212197
Prime Factors of 212197: 443x479

Running time of script doesn't depend on number,it depends on number of factors,
more factors less time and less factors more time.

[root@venu ]# time sh primefactors.sh 9999999999999999
Prime Factors of 9999999999999999: 3x3x11x17x73x101x137x5882353

real    0m1.345s
user    0m1.225s
sys     0m0.091s

[root@venu ]# time sh primefactors.sh 999999999995
Prime Factors of 999999999995: 5x251x1831x435179

real    1m32.105s
user    1m28.866s
sys     0m3.192s

[root@venu ]# time sh primefactors.sh 99999999000000000
Prime Factors of 99999999000000000: 2x2x2x2x2x2x2x2x2x3x3x5x5x5x5x5x5x5x5x5x11x7
3x101x137

real    0m0.543s
user    0m0.508s
sys     0m0.035s

Menu Driven Shell Script - Using Dialog Utility

2011-01-06T13:29:00.000-08:00



#!/bin/bash
# SCRIPT  : menu_dialog.sh
# PURPOSE : A menu driven Shell script using dialog utility
#           which has following options:
#           Display Today's Date and Time.
#           Display calendar.
#           Delete selected file from supplied directory.
#           List of users currently logged in
#           Disk Statistics
#           Exit
#
##############################################################################
#                 Checking availability of dialog utility                    #
##############################################################################

# dialog is a utility installed by default on all major Linux distributions.
# But it is good to check availability of dialog utility on your Linux box.

which dialog &> /dev/null

[ $? -ne 0 ]  && echo "Dialog utility is not available, Install it" && exit 1

##############################################################################
#                      Define Functions Here                                 #
##############################################################################

###################### deletetempfiles function ##############################

# This function is called by trap command
# For conformation of deletion use rm -fi *.$$

deletetempfiles()
{
    rm -f *.$$
}


######################## Show_time function #################################

# Shows today's date and time

show_time()
{
   dialog --backtitle "MENU DRIVEN PROGRAM" --title "DATE & TIME" \
   --msgbox "\n        Today's Date:   `date +"%d-%m-%Y"` \n\n \
       Today's Time:   `date +"%r %Z"`" 10 60
}

####################### show_cal function ###################################

# Shows current month calendar

show_cal()
{
   dialog --backtitle "MENU DRIVEN PROGRAM" --title "CALENDAR" \
   --msgbox "`cal`" 12 25
}

####################### deletefile function #################################

# Used to delete file under supplied directory, not including sub dirs.

deletefile()
{

   dialog --backtitle "MENU DRIVEN PROGRAM" --title "Directory Path" \
   --inputbox "\nEnter directory path (Absolute or Relative) \
\nPress just Enter for current directory" 12 60 2> temp1.$$

   if [ $? -ne 0 ]
   then
       rm -f temp1.$$
       return
   fi

   rmdir=`cat temp1.$$`

   if [ -z "$rmdir" ]
   then
       dirname=$(pwd)                  # You can also use `pwd`
       rmdir=$dirname/*
   else

       # remove trailing * and / from directory path

       echo "$rmdir" | grep "\*$" &> /dev/null && rmdir=${rmdir%\*}
       echo "$rmdir" | grep "/$" &> /dev/null && rmdir=${rmdir%/}

       # Check supplied directory exist or not

       ( cd $rmdir 2>&1 | grep "No such file or directory" &> /dev/null )

       # Above codeblock run in sub shell, so your current directory persists.

       if [ $? -eq 0 ]
       then
           dialog --backtitle "MENU DRIVEN PROGRAM" \
           --title "Validating Directory" \
           --msgbox "\n $rmdir: No such file or directory \
\n\n Press ENTER to return to the Main Menu" 10 60
           return
       fi

       # Do you have proper permissions ?

       ( cd $rmdir 2> /dev/null )

       if [ $? -ne 0 ]
       then
           dialog --backtitle "MENU DRIVEN PROGRAM" \
           --title "Checking Permissions" \
           --msgbox "\n $rmdir:  Permission denied to access this directory \
\n\n Press ENTER to return to the Main Menu" 10 60
           return
       fi

       if [ ! -r $rmdir ]
       then
           dialog --backtitle "MENU DRIVEN PROGRAM" \
           --title "Checking Permissions" \
           --msgbox "\n $rmdir:  No read permission \
\n\n Press ENTER to return to the Main Menu" 10 60
           return
       fi

   dirname=$rmdir
   rmdir=$rmdir/*             # get all the files under given directory

   fi

   for i in $rmdir            # process each file
   do

      # Store all regular file names in temp2.$$

      if [ -f $i ]
      then
          echo " $i delete? " >> temp2.$$
      fi

   done

   if [ -f temp2.$$ ]
   then
       dialog --backtitle "MENU DRIVEN PROGRAM" \
       --title "Select File to Delete" \
       --menu "Use [UP/DOWN] keys to move, then press enter \
\nFiles under directory $dirname:" 18 60 12 \
       `cat temp2.$$` 2> file2delete.$$
   else
     dialog --backtitle "MENU DRIVEN PROGRAM" --title "Select File to Delete" \
      --msgbox "\n\n There are no regular files in $dirname directory" 10 60
      return
   fi

   rtval=$?

   file2remove=`cat file2delete.$$`

   case $rtval in

       0) dialog --backtitle "MENU DRIVEN PROGRAM" --title "ARE YOU SURE" \
          --yesno "\nDo you Want to Delete File: $file2remove" 7 70


          if [ $? -eq 0 ]
          then
              rm -f $file2remove 2> Errorfile.$$

              # Check file successfully deleted or not.

              if [ $? -eq 0 ]
              then
                  dialog --backtitle "MENU DRIVEN PROGRAM" \
                  --title "Information : FILE DELETED" \
                  --msgbox "\nFile : $file2remove deleted" 8 70
             else
                 dialog --backtitle "MENU DRIVEN PROGRAM" \
                 --title "Information : ERROR ON DELETION" \
                 --msgbox "\nProblem in Deleting File: $file2remove \
\n\nError: `cat Errorfile.$$` \n\nPress ENTER to return to the Main Menu" 12 70
             fi

          else
              dialog --backtitle "MENU DRIVEN PROGRAM" \
              --title "Information : DELETION ABORTED" \
              --msgbox "Action Aborted: \n\n $file2remove not deleted" 8 70
          fi  ;;

      *)  deletetempfiles               # Remove temporary files
          return ;;
   esac

   deletetempfiles                      # remove temporary files
   return
}

########################## currentusers function ############################

currentusers()
{
   who > userslist.$$
   dialog --backtitle "MENU DRIVEN PROGRAM" \
   --title "CURRENTLY LOGGED IN USERS LIST" \
   --textbox userslist.$$ 12 60
}

############################ diskstats function #############################

diskstats()
{
   df -h | grep "^/" > statsfile.$$
   dialog --backtitle "MENU DRIVEN PROGRAM" \
   --title "DISK STATISTICS" \
   --textbox statsfile.$$ 10 60
}

##############################################################################
#                           MAIN STRATS HERE                                 #
##############################################################################

trap 'deletetempfiles'  EXIT     # calls deletetempfiles function on exit

while :
do

# Dialog utility to display options list

    dialog --clear --backtitle "MENU DRIVEN PROGRAM" --title "MAIN MENU" \
    --menu "Use [UP/DOWN] key to move" 12 60 6 \
    "DATE_TIME" "TO DISPLAY DATE AND TIME" \
    "CALENDAR"  "TO DISPLAY CALENDAR" \
    "DELETE"    "TO DELETE FILES" \
    "USERS"     "TO LIST CURRENTLY LOGGED IN USERS" \
    "DISK"      "TO DISPLAY DISK STATISTICS" \
    "EXIT"      "TO EXIT" 2> menuchoices.$$

    retopt=$?
    choice=`cat menuchoices.$$`

    case $retopt in

           0) case $choice in

                  DATE_TIME)  show_time ;;
                  CALENDAR)   show_cal ;;
                  DELETE)     deletefile ;;
                  USERS)      currentusers ;;
                  DISK)       diskstats ;;
                  EXIT)       clear; exit 0;;

              esac ;;

          *)clear ; exit ;;
    esac

done 

OUTPUT:
[venu@localhost ~]$ sh menu_dialog.sh

SAMPLE SCREEN SHOTS:

Main Menu:
Users:

Disk Stats:

Delete File:

Quicksort Shell Script

2011-01-03T11:53:00.000-08:00

   
   Quicksort is a good example of the divide and conquer strategy for
solving problems.  In quicksort,  we divide the array of items to be
sorted into two partitions and then call the quicksort procedure recu-
rsively to sort the two partitions, ie we divide the problem into two
smaller ones and conquer by solving the smaller ones

Quicksort recursive algorithm:

1 Select an element (called as pivot) x(p) of x .
2 Divide x into two batches x1 and x2 so that
  all entries of x1 are < x(p) and
  all entries of x2 are > x(p).
  all entries of x3 are == x(p)
  for each recursive call x3 will be placed to its sorted position.
  To ﬁnish sorting we must sort x1 and x2.
3 Apply steps 1 and 2 again to each of x1
  and x2, using further subdivision.
4 Repeat (recursively) until the sets to be
  sorted have no more than one element.

#!/bin/bash
# SCRIPT : quicksort.sh
# USAGE  : quicksort.sh
# PURPOSE: Sorts the list using quicksort algorithm.
#                         \\\\ ////
#                         \\ - - //
#                            @ @
#                    ---oOOo-( )-oOOo---
#
#####################################################################
#                      Define Functions Here                        #
#####################################################################

printnumbers()
{
   echo ${ARRAY[*]}
}

sortnumbers()
{

    local array=( `echo "$@"` )
    local -a l
    local -a g
    local -a e
    local x=

    if [ ${#array[@]} -lt 2 ]; then
        echo -n ${array[@]}
    else
        local pivot=${array[0]}

        for x in ${array[@]}
        do

          if [ $x -lt $pivot ]
          then
              l=( ${l[@]} $x )
          elif [ $x -gt $pivot ]
          then
              g=( ${g[@]} $x )
          else
              e=(${e[@]} $x)
          fi

        done

      echo "`sortnumbers "${l[@]}"` ${e[@]} `sortnumbers "${g[@]}"`"

    fi
}

#####################################################################
#                       Variable Declaration                       #
#####################################################################

clear

echo "Enter Numbers to be Sorted : "

read -a ARRAY

count=${#ARRAY[@]}

#####################################################################
#                       Main Script Starts Here                     #
#####################################################################

echo "--------------------------------------------------------------"

echo "Numbers Before Sort:"

printnumbers

echo "Numbers After Sort: "

sortnumbers "${ARRAY[@]}"

echo "--------------------------------------------------------------"


OUTPUT:

[venu@localhost shell]$ sh quicksort.sh
Enter Numbers to be Sorted :
12 54 32 90 76 54 -11 5 0 222 -46 32 -8 33 87 21 84 321 9
---------------------------------------------------------------
Numbers Before Sort:
12 54 32 90 76 54 -11 5 0 222 -46 32 -8 33 87 21 84 321 9
Numbers After Sort:
-46 -11 -8 0  5 9 12 21 32 32 33 54 54  76 84 87  90  222 321
---------------------------------------------------------------

Binarysearch Shell Script

2011-01-03T11:23:00.000-08:00

 Binary search works by comparing an input value to the middle element
of the array. The comparison determines whether the element equals the
input, less than the input or greater. When the element being compared
to equals the input the search stops and typically returns the posit-
ion or number of searches of the element.  If the element is not equal
to the input and the element at the middle point is greater than the
input being searched, the current middle point becomes the new high
point and the array is cut in half again and re-tested. If the element
at the middle point is less than the input being searched, the current
middle point becomes the new low point and the array is cut in half
again and retested. This cutting in half and adjusting either the high
point or the low point is repeated until the item is found or the low
point and the high point converge. This is much faster then sequentia-
lly searching an entire array.

#!/bin/bash
# SCRIPT : binarysearch.sh
# USAGE  : binarysearch.sh
# PURPOSE: Searches given number in a sorted list.
#                         \\\\ ////
#                         \\ - - //
#                            @ @
#                    ---oOOo-( )-oOOo---
#
#####################################################################
#                      Define Functions Here                        #
#####################################################################

printnumbers()
{
  echo ${ARRAY[*]}
}

sortnumbers()                               # Using insertion sort
{
for((i=1;i<count;i++))
do
   Temp=${ARRAY[i]}
   j=$((i-1))
   while [ $Temp -lt ${ARRAY[j]} ]
   do
      ARRAY[j+1]=${ARRAY[j]}
      let j--
      if [ $j == -1 ]
      then
         break
      fi
   done
   ARRAY[j+1]=$Temp
done
}

binarysearch()
{
    status=-1
    i=1
    array=($(echo "$@"))
    LowIndex=0
    HeighIndex=$((${#array[@]}-1))

    while [ $LowIndex -le $HeighIndex ]
    do

        MidIndex=$(($LowIndex+($HeighIndex-$LowIndex)/2))
        MidElement=${array[$MidIndex]}

        if [ $MidElement -eq $SearchedItem ]
        then
            status=0
            searches=$i
            return
        elif [ $SearchedItem -lt $MidElement ]
        then
            HeighIndex=$(($MidIndex-1))
        else
            LowIndex=$(($MidIndex+1))
        fi

        let i++

    done
}

#####################################################################
#                       Variable Declaration                       #
#####################################################################

clear

echo "Enter Array Elements : "

read -a ARRAY

count=${#ARRAY[@]}

search=y

#####################################################################
#                       Main Script Starts Here                     #
#####################################################################

# sort the loaded array, must for binary search.
# You can apply any sorting algorithm. I applied insertion sort.

sortnumbers

echo "Array Elements After Sort: "

printnumbers

while [ "$search" == "y" -o "$search" == "Y" ]
do

     echo -n "Enter Element to be searched : "
     read SearchedItem
     binarysearch "${ARRAY[@]}"

     if [ $status -eq 0 ]
     then
         echo "$SearchedItem found after $searches searches"
     else
         echo "$SearchedItem not found in the list"
     fi

     echo -n "Do you want another search (y/n): "
     read search

done

OUTPUT:

[venu@localhost shell]$ chmod 755 binarysearch.sh
[venu@localhost shell]$ ./binarysearch.sh
Enter Array Elements :
12 34 56 21 43 11 -32 87 112 -43 -111 98 100 22 0 11
Array Elements After Sort:
-111 -43 -32 0 11 11 12 21 22 34 43 56 87 98 100 112
Enter Element to be searched : 21       # Middle element
21 found after 1 searches
Do you want another search (y/n): y
Enter Element to be searched : 112
112 found after 5 searches
Do you want another search (y/n): y
Enter Element to be searched : 56       # second middle element(upper)
56 found after 2 searches
Do you want another search (y/n): y
Enter Element to be searched : 0        # second middle element(lower)
0 found after 2 searches
Do you want another search (y/n): y
Enter Element to be searched : -111
-111 found after 4 searches
Do you want another search (y/n): n

Linear Search Shell Script

2011-01-03T03:28:00.000-08:00


#!/bin/bash
# SCRIPT : linearsearch.sh
# USAGE  : linearsearch.sh
# PURPOSE: Searches given number in a list.
#                         \\\\ ////
#                         \\ - - //
#                            @ @
#                    ---oOOo-( )-oOOo---
# A variation of Here Document permits "commenting out" data block.
: <<DATABLOCK

 In computer science, linear search or sequential search is a method
for finding a particular value in a list, that consists in checking
every one of its elements, one at a time and in sequence, until the
desired one is found.

 This is a very straightforward loop comparing every element in the
array with the key. As soon as an equal value is found, it returns.
If the loop finishes without finding a match, the search failed and
-1 is returned.

 For small arrays, a linear search is a good solution because it's so
straightforward. In an array of a million elements, a linear search
will take,on average, 500,000 comparisons to find the key. For a much
faster search, take a look at binary search.

DATABLOCK

#####################################################################
#                      Define Functions Here                        #
#####################################################################

lsearch()
{
   status=-1

   for((i=0;i<count;i++))
   do
      Temp=$1

      if [ $Temp -eq ${ARRAY[i]} ]
       then

          status=0
          searches=$((i+1))
          return

#         return $((i+1))
# Bash function can return value between 0-255, That's why I assigned
# result to a global variable. This is one of the method to capture
# return value of a function.

      fi

   done
}

#####################################################################
#                       Variable Declaration                       #
#####################################################################

clear

echo "Enter Array Elements : "

read -a ARRAY

count=${#ARRAY[@]}

search=y

#####################################################################
#                       Main Script Starts Here                     #
#####################################################################

while [ "$search" == "y" -o "$search" == "Y" ]
do

     echo -n "Enter element to be searched : "
     read num
     lsearch $num

     if [ $status -eq 0 ]
     then
         echo "$num found after $searches searches"
     else
         echo "$num not found"
     fi

     echo -n "Do you want another search (y/n): "
     read search

done

OUTPUT:
$ sh linearsearch.sh
Enter Array Elements :
12 34 56 78 90 23 45 56 67 321 66 88 92
Enter element to be searched : 56
56 found after 3 searches
Do you want another search (y/n): y
Enter element to be searched : 321
321 found after 10 searches
Do you want another search (y/n): y
Enter element to be searched : 100
100 not found
Do you want another search (y/n): n

Happy New Year Shell Script

2011-01-02T08:19:00.001-08:00


Wish You a Happy New Year To All My Friends 



If you don't know shell color codes, read bellow article first.
How to colorize shell scripts

#!/bin/bash
# SCRIPT:  happynewyear.sh
# PURPOSE: Prints Happy new year 2011 on screen.
#                         \\\\ ////
#                         \\ - - //
#                            @ @
#                    ---oOOo-( )-oOOo---
#
##############################################################################
#                              Arguments Checking                            #
##############################################################################

if [ $# -eq 1 ]
then
    fname=$1
else
    echo "Invalid Arguments"
    echo "Usage: happynewyear.sh filename"
    exit
fi

##############################################################################
#                               Main Starts                                  #
##############################################################################

clear
i=0

while read line
do

   if [ $i -lt 8 ] ; then
       COLOR1="\e[1;31;40m" ; COLOR2="\e[0m"     # Dark Red 
   elif [ $i -gt 8 -a $i -lt 17 ] ; then
       COLOR1="\e[1;37;40m" ; COLOR2="\e[0m"     # White 
   elif [ $i -gt 17 -a $i -lt 26 ] ; then
       COLOR1="\e[1;32;40;5m" ; COLOR2="\e[0m"   # Dark Green with blinking 
   fi                                            # effect
   

   newline=`echo "$line" | tr '69' ' @' `
   printf "$COLOR1$newline $COLOR2"        # you can also use echo -e "...."
   let i++
   sleep 0.1


done < $fname

read                                        # Waits for enter



Copy bellow data and save it as newyear.txt

6666666666996666699666666666966666666669999999996699999999966996666669966666666
6666666666996666699666666669996666666669999999996699999999966699666699666666666
6666666666996666699666666699669966666669966666996699666669966669966996666666666
6666666666999999999666666996666996666669999999996699999999966666999966666666666
6666666666999999999666669999999999666669999999996699999999966666699666666666666
6666666666996666699666699999999999966669966666666699666666666666699666666666666
6666666666996666699666996666666666996669966666666699666666666666699666666666666
6666666666996666699669966666666666699669966666666699666666666666699666666666666
6666666666666666666666666666666666666666666666666666666666666666666666666666666
9966666996699999999669966666996666699666666996999999996666666696666666699999999
9996666996699999999669966666996666669966669966999999996666666999666666699999999
9999666996699666666669966666996666666996699666996666666666669969966666699666699
9969966996699999999669966966996666666699996666999999996666699666996666699999999
9966996996699999999669969996996666666669966666999999996666999999999666699999999
9966699996699666666669999699996666666669966666996666666669999999999966699699666
9966669996699999999669996669996666666669966666999999996699666666666996699669966
9966666996699999999669966666996666666669966666999999996996666666666699699666699
6666666666666666666666666666666666666666666666666666666666666666666666666666666
6666666666666666666666699999999666999699999666999666699966666666666666666666666
6666666666666666666666699999999666996666699666699666669966666666666666666666666
6666666666666666666666666666996666999666699666699666669966666666666666666666666
6666666666666666666666666669966666996696699666699666669966666666666666666666666
6666666666666666666666666699666666996669699666699666669966666666666666666666666
6666666666666666666666669966666666996666999666699666669966666666666666666666666
6666666666666666666666699999999666996666699666699666669966666666666666666666666
6666666666666666666666699999999666999699999666999966699996666666666666666666666



For blinking effect run this script in console, not in terminal.

OUTPUT:
$ sh happynewyear.sh newyear.txt

Math in Shell Scripts

2010-12-26T07:36:00.000-08:00


 One thing that often confuses new users to the Unix / Linux shell, is
how to do (even very simple) maths. In most languages, x = x + 1 (or
even x++) does exactly what you would expect. The Unix/Linux shell is
different,however. It doesn’t have any built-in mathematical operators
for variables. It can do comparisons, but maths isn’t supported, not
even simple addition.

 Shell script variables are by default treated as strings,not numbers,
which adds some complexity to doing math in shell script. To keep with
script programming paradigm and allow for better math support, langua-
ges such Perl or Python would be better suited when math is desired.
However, it is possible to do math with shell script.In fact, over the
years, multiple facilities have been added to Unix to support working
with numbers.

 You can do maths using any one of the following methods.

1. Using expr command
2  Using $(()) construct.
3  Using let command
4  Using bc command.
5  Using $[] construct.

expr command:

 expr command performs arithmetic operations on integers. It can
perform the four basic arithmetic operations, as well as the modulus
(remainder function).

$ expr 5 + 10
15
$ a=10 b=5
$ expr $a + $b
15
$ expr $a / $b
2
$ expr $a * $b
expr: syntax error
$ expr $a \* $b
50


  The operand, be it +,-,* etc.,  must be enclosed on either side by
whitespace. Observe that the multiplication operand (*) has to be
escaped to prevent the shell from interpreting it as the filename meta
character. Since expr can handle only integers, division yields only
the integral part.

 expr is often used with command substitution to assign a variable.
For example, you can set a variable x to the sum of two numbers:

$ x=`expr $a + $b`
$ echo $x
15

 Note: As you can see, for expr, you must put spaces around the
 arguments: "expr 123+456" doesn’t work. "expr 123 + 456" works.


With double parentheses: $(()) and (())

 In bash version 3.2 and later you can (and should) use $(()) and (())
for integer arithmetic expressions. You may have may not have spaces
around the operators, but you must not have spaces around the equal
sign, as with any bash variable assignment.

$ c=$(($a+9))
$ echo $c
19
$ c=$((a+9))             #Also correct, no need of $ sign.
$ c=$((a + 9))           #Also correct, no restriction on spaces.
$ c= $((a + b))          #Incorrect, space after assignment operator.


 You may also use operations within double parentheses without
assignment.

$ ((a++))
$ echo $a
11
$ ((a+=1)) ; echo $a
12
$ ((d=a+b+9)) ; echo $d
26
$ ((a+=$b))                #Correct
$ (($a+=1))                #Incorrect

let command:

 The let command carries out arithmetic operations on variables. In
many cases, it functions as a less complex version of expr command.
As you can see, it is also a little picky about spaces, but it wants
the opposite of what expr wanted. let also relaxes the normal rule of
needing a $ in front of variables to be read.

$ let a=10            # Same as 'a=11'
$ let a=a+5           # Equivalent to  let "a = a + 5"

# Quotes permit the use of spaces in variable assignment. (Double
# quotes and spaces make it more readable.)

$ let a=$a + 5        # Without quotes spaces not allowed.
bash: let: +: syntax error: operand expected (error token is "+")


 You need to use quotes if you want to use spaces between tokens of
the expression, for example

$ let "a = a + 5";echo $a
20

 The only construct that is more convenient to use with let is incre-
ment such as

$ let a++ ; echo $a       #  as well as to ((i++))
16

bc: THE CALCULATOR

 Bash doesn't support floating point arithmetic. The obvious candidate
for adding floating point capabilities to bash is bc. bc is not only a
command, it also a pseudo-programming language featuring arrays,funct-
ions,conditional(if) and loops(for and while). It also comes with a
library for performing scientific calculations. It can handle very,
very large numbers. If a computation results in a 900 digit number, bc
will show each and every digit. But you have to treat the variables as
strings.

 Here is what happens when we try to do floating point math with the
shell:

$ let a=12.5
bash: let: a=12.5: syntax error: invalid arithmetic operator (error
token is ".5")
$ ((b=1*0.5))
bash: ((: b=1*0.5: syntax error: invalid arithmetic operator (error
token is ".5")


    I can't explain everything about bc here, it needs another post.
But I will give some examples here.

Most of the bellow examples follow a simple formula:

$ echo '57+43' | bc
100
$ echo '57*43' | bc
2451
$ echo '6^6' | bc         # Power
46656
$ echo '1.5*5'|bc         # Allows floating point math.
7.5

$[] construct: 

$ x=85
$ y=15
$ echo $[x+y]
100
$ echo $[x/y]
5
$ c=$[x*y]
$ echo $c
1275


 Working of above methods shell dependent. Bash shell supports all 5
methods. Following shell script demonstrates above methods.

#!/bin/bash
# SCRIPT:  basicmath.sh
# USAGE:   basicmath.sh
# PURPOSE: Addition, Subtraction, Division and Multiplication of
#          two numbers.
#                       \\\\ ////
#                      \\  - -  //
#                          @ @
#                  ---oOOo-( )-oOOo---
#
#####################################################################
#                      Variable Declaration                         #
#####################################################################

clear                        #Clears Screen

Bold="\033[1m"               #Storing escape sequences in a variable.
Normal="\033[0m"

echo -e "$Bold Basic mathematics using bash script $Normal\n"

items="1. ADDITTION
        2. SUBTRACTION
        3. MULTIPLICATION
        4. DIVISION
        5. EXIT"

choice=

#####################################################################
#                      Define Functions Here                        #
#####################################################################

# If didn't understand these functions, simply remove functions and
# its entries from main script.

exit_function()
{
   clear
   exit
}

#Function enter is used to go  back to menu and clears screen

enter()
{
   unset num1 num2
   ans=
   echo ""
   echo -e  "Do you want to continue(y/n):\c"
   stty -icanon min 0 time 0

# When -icanon is set then one character has been received.
# min 0 means that read should read 0 characters.
# time 0 ensures that read is terminated the moment one character
# is hit.

while [ -z "$ans" ]
do
   read ans
done

#The while loop ensures that so long as at least one character is
# not received read continue to get executed

if [ "$ans" = "y" -o "$ans" = "Y" ]
then
   stty sane          # Restoring terminal settings
   clear
else
   stty sane
   exit_function
fi
}

#####################################################################
#                         Main Starts                               #
#####################################################################

while true
do
   echo -e "$Bold \tPROGRAM MENU $Normal\n"
   echo -e "\t$items \n"
   echo -n "Enter your choice : "
   read choice

   case $choice in
     1) clear
        echo  "Enter two numbers for Addition : "
        echo -n "Number1: "
        read num1
        echo -n "Number2: "
        read num2
        echo "$num1 + $num2 = `expr $num1 + $num2`"
        enter ;;
     2) clear
        echo "Enter two numbers for Subtraction : "
        echo -n "Number1: "
        read num1
        echo -n "Number2: "
        read num2
        echo "$num1 - $num2 = $((num1-num2))"
        enter ;;
     3) clear
        echo "Enter two numbers for Multiplication : "
        echo -n "Number1: "
        read num1
        echo -n "Number2: "
        read num2
        echo "$num1 * $num2 = `echo "$num1*$num2"|bc`"
        enter ;;
    4)  clear
        echo "Enter two numbers for Division : "
        echo -n "Number1: "
        read num1
        echo -n "Number2: "
        read num2
        let div=num1/num2
        echo "$num1 / $num2 = $div"
        enter ;;
    5)  exit_function  ;;
    *)  echo "You entered wrong option, Please enter 1,2,3,4 or 5"
        echo "Press enter to continue"
        read
        clear
   esac

done 

OUTPUT:
 [venu@localhost ~]$ sh basicmath.sh

 Basic mathematics using bash script

        PROGRAM MENU

        1. ADDITTION
        2. SUBTRACTION
        3. MULTIPLICATION
        4. DIVISION
        5. EXIT

Enter your choice : 1

Enter two numbers for Addition :
Number1: 123
Number2: 456
123 + 456 = 579

Do you want to continue(y/n):y

        PROGRAM MENU

        1. ADDITTION
        2. SUBTRACTION
        3. MULTIPLICATION
        4. DIVISION
        5. EXIT

Enter your choice : 3
Enter two numbers for Multiplication :
Number1: 12.5
Number2: 2
12.5 * 2 = 25.0

Do you want to continue(y/n):n

Shell Script to Generate Fibonacci Series

2010-12-22T12:38:00.000-08:00

  By definition in mathematics, the Fibonacci Numbers are the numbers
in the below sequence:
0,1,1,2,3,5,8,13,21,34,55,89,144, ......
  By definition, the first two Fibonacci numbers are 0 and 1, and each
subsequent number is the sum of the previous two. Some sources omit
the initial 0, instead beginning the sequence with two 1s.
  In mathematical terms, the sequence Fn of Fibonacci numbers is defi-
ned by the recurrence relation
    Fn = Fn-1 + Fn-2,
with seed values
   F0 = 0 and F1 = 1.

Iterative Method: 

#!/bin/bash#!/bin/bash
# SCRIPT:  fibo_iterative.sh
# USAGE:   fibo_iterative.sh [Number]
# PURPOSE: Generate Fibonacci sequence.
#                         \\\\ ////
#                         \\ - - //
#                            @ @
#                    ---oOOo-( )-oOOo---
#
#####################################################################
#                     Script Starts Here                            #
#####################################################################

if [ $# -eq 1 ]
then
    Num=$1
else
    echo -n "Enter a Number :"
    read Num
fi

f1=0
f2=1

echo "The Fibonacci sequence for the number $Num is : "

for (( i=0;i<=Num;i++ ))
do
     echo -n "$f1 "
     fn=$((f1+f2))
     f1=$f2
     f2=$fn
done

echo

OUTPUT:
# sh fibo_iterative.sh 18
The Fibonacci sequence for the number 18 is : 
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 
# sh fibo_iterative.sh
Enter a Number :20
The Fibonacci sequence for the number 20 is : 
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 

Recursive Method:

#!/bin/bash
# SCRIPT:  fibo_recursive.sh
# USAGE:   fibo_recursive.sh [Number]
# PURPOSE: Generate Fibonacci sequence.
#                         \\\\ ////
#                         \\ - - //
#                            @ @
#                    ---oOOo-( )-oOOo---
#
#####################################################################
#                      Arguments Checking                           #
#####################################################################

if [ $# -eq 1 ]
then
    Num=$1
else
    echo -n "Enter a Number : "
    read Num
fi

#####################################################################
#                      Define Functions Here                        #
#####################################################################

Fibonacci()
{

case $1 in
 0|1) printf "$1 " ;;
 *) echo -n "$(( $(Fibonacci $(($1-2)))+$(Fibonacci $(($1-1))) )) ";;
esac

#$(( )) construct is used instead of expr command for doing addition.
#$( ) constrict is used instead of back ticks.

}

#####################################################################
#                      Main Script Starts Here                      #
#####################################################################

echo "The Fibonacci sequence for the number $Num is : "

for (( i=0; i<=$Num; i++ ))
do
  Fibonacci $i                     #Calling function Fibonacci
done

echo

OUTPUT:
# sh fibo_recursive.sh 
Enter a Number : 11
The Fibonacci sequence for the number 11 is : 
0 1 1 2 3 5 8 13 21 34 55 89 
# sh fibo_recursive.sh 13
The Fibonacci sequence for the number 13 is : 
0 1 1 2 3 5 8 13 21 34 55 89 144 233 

Be aware that recursion is resource-intensive and executes slowly,
and is therefore generally not appropriate to use in a script.

[root@localhost shell]# time ./fibo_iterative.sh 15
The Fibonacci sequence for the number 15 is :
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610

real    0m0.008s
user    0m0.008s
sys     0m0.000s
[root@localhost shell]# time ./fibo_recursive.sh 15
The Fibonacci sequence for the number 15 is :
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610

real    0m7.875s
user    0m0.908s
sys     0m5.188s

Too many levels of recursion may crash a script with a segfault.

Shell Script to Find Armstrong Numbers Between a Given Range

2010-12-20T12:08:00.000-08:00


#!/bin/bash
# SCRIPT:  armstrong_bw_range.sh
# USAGE:   armstrong_bw_range.sh
# PURPOSE: Finding Armstrong numbers between given range.
#                         \\\\ ////
#                         \\ - - //
#                            @ @
#                    ---oOOo-( )-oOOo---
#Armstrong numbers are the sum of their own digits to the power of
#the number of digits. As that is a slightly brief wording, let me
#give an example:
#153 = 1³ + 5³ + 3³
#Each digit is raised to the power three because 153 has three
#digits. They are totalled and we get the original number again!
#Notice that Armstrong numbers are base dependent,but we'll mainly be
#dealing with base 10 examples.The Armstrong numbers up to 5 digits
#are 1 to 9,153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727, 93084
#
#####################################################################
#                     Script Starts Here                            #
#####################################################################

echo -n "Enter the Lower Limit : "
read Start
echo -n "Enter the Upper Limit : "
read Ending

echo "Armstrong Numbers between $Start and $Ending are: "

while [ $Start -le $Ending ]
do
     Number=$Start
     Length=${#Number}
     Sum=0
     OldNumber=$Number

     while [ $Number -ne  0 ]
     do
          Rem=$((Number%10))
          Number=$((Number/10))
          Power=$(echo "$Rem ^ $Length" | bc )
          Sum=$((Sum+Power))
     done

     if [ $Sum -eq $OldNumber ]
     then
         echo -n "$OldNumber  "
     fi

     let Start++
done
echo


OUTPUT:
# sh armstrong_bw_range.sh
Enter the Lower Limit : 1
Enter the Upper Limit : 500
Armstrong Numbers between 1 and 500 are:
1  2  3  4  5  6  7  8  9  153  370  371  407

# sh armstrong_bw_range.sh
Enter the Lower Limit : 1000
Enter the Upper Limit : 10000
Armstrong Numbers between 1000 and 10000 are:
1634  8208  9474

Shell Script to Check Armstrong Number

2010-12-20T12:00:00.000-08:00


#!/bin/bash
# SCRIPT:  armstrongnumber.sh
# USAGE:   armstrongnumber.sh
# PURPOSE: Check if the given number is Armstrong number ?
#                         \\\\ ////
#                         \\ - - //
#                            @ @
#                    ---oOOo-( )-oOOo---
# Armstrong numbers are the sum of their own digits to the power of
# the number of digits. As that is a slightly brief wording, let me
# give an example:
# 153 = 1³ + 5³ + 3³
# Each digit is raised to the power three because 153 has three
# digits. They are totalled and we get the original number again!
#Notice that Armstrong numbers are base dependent,but we'll mainly be
# dealing with base 10 examples.The Armstrong numbers up to 5 digits
# are 1 to 9,153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727,93084
#
#####################################################################
#                     Script Starts Here                            #
#####################################################################

echo -n "Enter the number: "
read Number
Length=${#Number}
Sum=0
OldNumber=$Number

while [ $Number -ne  0 ]
do
     Rem=$((Number%10))
     Number=$((Number/10))
     Power=$(echo "$Rem ^ $Length" | bc )
     Sum=$((Sum+$Power))
done

if [ $Sum -eq $OldNumber ]
then
    echo "$OldNumber is an Armstrong number"
else
    echo "$OldNumber is not an Armstrong number"
fi


OUTPUT:
# sh armstrongnumber.sh
Enter the number: 8208
8208 is an Armstrong number
# sh armstrongnumber.sh
Enter the number: 4210818
4210818 is an Armstrong number
# sh armstrongnumber.sh
Enter the number: 4376541
4376541 is not an Armstrong number

Decimal to Binary Conversion Shell Script

2010-12-20T06:28:00.000-08:00


#!/bin/bash
# SCRIPT:  dec2binary.sh
# USAGE:   dec2binary.sh Decimal_Number(s)
# PURPOSE: Decimal to Binary Conversion. Takes input as command line
#          arguments.
#                        \\\\ ////
#                       \\  - -  //
#                           @ @
#                   ---oOOo-( )-oOOo---
#
#####################################################################
#                      Script Starts Here                           #
#####################################################################

if [ $# -eq 0 ]
then
    echo "Argument(s) not supplied "
    echo "Usage: dec2binary.sh Decimal_number(s)"
else
echo -e "\033[1mDECIMAL             \t\t BINARY\033[0m"

    while [ $# -ne 0 ]
    do
         DecNum=$1
         Binary=
         Number=$DecNum

         while [ $DecNum -ne 0 ]
         do
              Bit=$(expr $DecNum % 2)
              Binary=$Bit$Binary
              DecNum=$(expr $DecNum / 2)
         done

         echo -e "$Number              \t\t $Binary"
         shift
# Shifts command line arguments one step.Now $1 holds second argument
        unset Binary
   done

fi

#NOTE: Using bc command you can directly get output at command line.
#   $ echo 'obase=2;15' | bc
#     1111
#   $ echo 'obase=2;1023' | bc
#     1111111111
#   $ echo 'obase=2;1024' | bc
#     10000000000
# No need of ibase=10, because default ibase is 10. 

OUTPUT:
# sh dec2binary.sh 7 16 255 256 1023 1024
DECIMAL                          BINARY
7                                111
16                               10000
255                              11111111
256                              100000000
1023                             1111111111
1024                             10000000000

# sh dec2binary.sh 9223372036854775807
DECIMAL                          BINARY
9223372036854775807              1111111111111111111111111111111111111
11111111111111111111111111

#sh dec2binary.sh 9223372036854775808
DECIMAL                          BINARY
dec2binary.sh:line 13:[:9223372036854775808:integer expression expected
9223372036854775808

NOTE:My bash can handle upto 9223372036854775807.
But with bc command you can do more.

# echo 'obase=2;9223372036854775808'|bc
1000000000000000000000000000000000000000000000000000000000000000

Binary to Decimal Conversion Shell Script

2010-12-20T06:22:00.000-08:00


#!/bin/bash
# SCRIPT:  binary2dec.sh
# USAGE:   binary2dec.sh Binary_Numbers(s)
# PURPOSE: Binary to Decimal Conversion. Takes input as command line
#          arguments.
#                        \\\\ ////
#                       \\  - -  //
#                           @ @
#                   ---oOOo-( )-oOOo---
#
#####################################################################
#                      Script Starts Here                           #
#####################################################################
if [ $# -eq 0 ]
then
    echo "Argument(s) not supplied "
    echo "Usage: binary2dec.sh Binary_Number(s)"
else
    echo -e "\033[1mBINARY             \t\t DECIMAL\033[0m"

    while [ $# -ne 0 ]
    do
         Binary=$1
         Bnumber=$Binary
         Decimal=0
         power=1

         while [ $Binary -ne 0 ]
         do
              rem=$(expr $Binary % 10 )
              Decimal=$((Decimal+(rem*power)))
              power=$((power*2))
              Binary=$(expr $Binary / 10)
         done

         echo -e "$Bnumber             \t\t $Decimal"
         shift
    done

fi

#NOTE: Using bc command you can directly get output at command line.
# Here we're converting the binary number 111 to a base 10 (decimal)
# number.
#
# $ echo 'ibase=2;obase=A;111' | bc
# 7
#
#Note that the obase is "A" and not "10".The reason for this is you've
# set the ibase to 2, so if you now had tried to use "10" as the value
# for the obase, it would stay as "2", because "10" in base 2 is "2".
# So you need to use hex to break out of binary mode or use obase=1010
#
# $ echo 'ibase=2;obase=1010;10000' | bc
# 16
# $ echo 'ibase=2;obase=1010;1000001' | bc
# 65
#
# You can omit obase=A, because default obase is 10(decimal).
# $ echo 'ibase=2;1000001' | bc
# 65

OUTPUT:
# sh binary2dec.sh 100 1111 1111111 1000000
BINARY                           DECIMAL
100                              4
1111                             15
1111111                          127
1000000                          64

# sh binary2dec.sh 1111111111111111111
BINARY                           DECIMAL
1111111111111111111              524287

# sh binary2dec.sh 10000000000000000000
BINARY                           DECIMAL
binary2dec.sh:line 28:[:10000000000000000000:integer expression expected
10000000000000000000

NOTE:My bash can handle upto 9223372036854775807.
But with bc command you can do more.

# echo 'ibase=2;10000000000000000000'|bc
524288
# echo 'ibase=2;110000000000000000000'|bc
1572864

How to Validate Integer Input using Shell script

2010-12-19T11:25:00.000-08:00


Method 1:

#!/bin/bash
# SCRIPT:  validinteger.sh
# USAGE:   validinteger.sh [ Input value to be validated ]
# PURPOSE: validate integer input, allow negative integers also
#
#             \\\\ ////
#            \\  - -  //
#                @ @
#        ---oOOo-( )-oOOo---
#
# Using the $? exit status variable or integer comparison operators, a
# script may test if a parameter contains only digits, so it can be
# treated as an integer.
#
#####################################################################
#                      Arguments Checking                           #
#####################################################################

if [ $# -eq 0 ]
then
    echo -n "Enter input to test: "
    read Number
else
    Number=$1
fi

# You can also use bellow one liner
#[ $# -eq 0 ] && { echo -n "Enter input:";read Number; } || Number=$1

#####################################################################
#                     Main Script Starts Here                       #
#####################################################################

# Check the input is an integer or not

if [ $Number -ne 0 -o $Number -eq 0 2>/dev/null ]
then

# An integer is either equal to 0 or not equal to 0.
# 2>/dev/null suppresses error message.

    echo "Supplied Input $Number is an Integer"

else

    echo "Supplied Input $Number is not an Integer."
fi

# You can compare number itself also

#  if [ $Number -eq $Number 2> /dev/null ]
#  then
#    echo "Supplied Input $Number is an Integer"
#  else
#    echo "Supplied Input $Number is not an Integer."
#  fi

OUTPUT:
# chmod 755 validinteger.sh
# ./validinteger.sh -12345
Supplied Input -12345 is an Integer
# ./validinteger.sh 12345A
Supplied Input 12345A is not an Integer.
# ./validinteger.sh
Enter input to test: 876549
Supplied Input 876549 is an Integer
# ./validinteger.sh
Enter input to test: -345k123
Supplied Input -345k123 is not an Integer.

Method 2 : 


#!/bin/bash
# SCRIPT:  validinteger2.sh
# USAGE:   validinteger2.sh [ Input value to be validated ]
# PURPOSE: validate integer input, allow negative integers also
#
#
#             \\\\ ////
#            \\  - -  //
#                @ @
#        ---oOOo-( )-oOOo---
#
# In this method if you want to allow negative integers, it gets a
# tiny bit more complicated. You must have basic knowledge of string
# manipulation methods.
#
#####################################################################
#                      Arguments Checking                           #
#####################################################################

if [ $# -eq 0 ]
then
    echo -n "Enter input to test: "
    read Number
else
    Number=$1
fi

#####################################################################
#                     Main Script Starts Here                       #
#####################################################################

# Check first character is -

if [ "${Number:0:1}" = "-" ]    #extract first character
then
    RemNumber="${Number:1}"     #extract except first char
else
    RemNumber="$Number"
fi

# You can extract substring using bellow method also

#if [ "$(echo $Number|cut -c 1)" = "-" ]
#then
#    RemNumber=$(echo $Number|cut -c 2-)
#else
#    RemNumber="$Number"
#fi

if [ -z "$RemNumber" ]
then
    echo "Supplied Input $Number is not an Integer"
else

    NoDigits="$(echo $RemNumber | sed 's/[[:digit:]]//g')"

    if [ -z "$NoDigits" ]
    then
        echo "Supplied Input $Number is an Integer"
    else
        echo "Supplied Input $Number is not an Integer."
    fi
fi

OUTPUT:
# chmod 755 validinteger2.sh
# ./validinteger2.sh -987612
Supplied Input -987612 is an Integer
# ./validinteger2.sh -A987612
Supplied Input -A987612 is not an Integer.
# ./validinteger2.sh
Enter input to test: -123456789
Supplied Input -123456789 is an Integer
# ./validinteger2.sh
Enter input to test: A234K78
Supplied Input A234K78 is not an Integer.

Method 3: 

#!/bin/bash
# SCRIPT:  validinteger3.sh
# USAGE:   validinteger3.sh [ Input value to be validated ]
# PURPOSE: validate integer input, allow negative integers also
#
#                           \\\\ ////
#                          \\  - -  //
#                              @ @
#                      ---oOOo-( )-oOOo---
#
# In this method input value validated using ASCII value range of
# numbers (48 - 57).
# Sample script provided by Bond, Thank you Bond.
#
#####################################################################
#                      Arguments Checking                           #
#####################################################################

if [ $# -eq 0 ]
then
    echo -n "Enter input to test: "
    read Number
else
    Number=$1
fi

# You can also use bellow one liner
#[ $# -eq 0 ] && { echo -n "Enter input:";read Number; } || Number=$1

#####################################################################
#                     Main Script Starts Here                       #
#####################################################################

# Check first character is - ?
# This is another method to extract substring using Substring Removal
# method.

  if [ "${Number%${Number#?}}" = "-" ]  #extract first char
  then
      RemNumber="${Number#?}"           #extract all except first char
  else
      RemNumber="$Number"
  fi

if [ -z "$RemNumber" ]
then
    echo "Supplied Input $Number is not an Integer"
else

    Length=${#RemNumber}              # Counting length of the string

    for ((i=0; i < Length; i++))
    do

       char=${RemNumber:$i:1}          # Reads character one by one

       code=`printf '%d' "'$char"`     # Get ASCII value of char

       # Compare code with ASCII value range of Intergers ( 48 - 57 )

       if [ $code -lt 48 ] || [ $code -gt 57 ]
       then
           echo "Supplied Input $Number is not an Integer"
           exit 1
       fi

    done

    echo "Supplied Input $Number is an Integer."

fi

OUTPUT:
$ sh validinteger3.sh -1234
Supplied Input -1234 is an Integer.
$ sh validinteger3.sh -12-12
Supplied Input -12-12 is not an Integer
$ sh validinteger3.sh 
Enter input to test: -
Supplied Input - is not an Integer
$ sh validinteger3.sh 
Enter input to test: 123a456
Supplied Input 123a456 is not an Integer

Shell Script to Check Whether a String is Palindrome or not

2010-07-31T16:18:00.000-07:00


Palindrome: A palindrome is a word, phrase, number or other sequence
of units that can be read the same way in either direction (the adjus-
tment of punctuation and spaces between words is generally permitted).

Examples: 

Phrases:    Dammit, I'm mad!
Quotations: Able was I ere I saw Elba.
            Madam, I'm Adam.
Names:      Some people have names that are palindromes.Lon Nol (1913-
            1985) was Prime Minister of Cambodia.
            Palindromic names are very common in Finland. Examples
            include Emma Lamme,Sanna Rannas, Anni Linna and Asko Oksa.
Words:      civic,radar,level,rotator,rececar,reviver.
            The command "Level, madam, level!", composed only of words
            that are themselves palindromes, is both a character-by-
            character and a word-by-word palindrome.
Numbers:    5335, 123454321
Dates:      01/02/2010 (dd/mm/yyyy format)

Method 1:

#!/bin/bash
# SCRIPT: palindrome1.sh
# USAGE: palindrome.sh     or  palindrome.sh STRING
# PURPOSE:  Script to test if a given string is a palindrome.
#
# In this script I uses the well known method, compare first character
# with last character, up to middle of the string. One mismatch in the
# scanning leads to immediate termination of the scanning as it is
# not a palindrome. To extract character from string, I will use cut
# command with the -c option with the position number.
#
#####################################################################
#                      Arguments Checking                           #
#####################################################################

if [ $# -eq 0 ]
then
     echo -n "Enter a String: "
     read orgstr
else
     orgstr=$*
fi

# You can also use single statement
#[ $# -eq 0 ] && (echo -n "Enter a String:"; read String) || String=$*

#####################################################################
#                     Variable Initialization                       #
#####################################################################

# Remove all punctuations from input string and convert upper case to
# lower or lower case to upper.

String="$(echo $orgstr | sed 's/[^[:alnum:]]//g' | \
tr '[:upper:]' '[:lower:]')"

Flag=0

# Find length of the string.
len=${#String}

#You can also calculate string length using bellow commands.
#len=`echo $str | wc -c`
#len=$((len-1))

#get the mid value up to which the comparison would be done.
mid=$((len/2))

#####################################################################
#                     Main Script Starts Here                       #
#####################################################################

for ((i=1;i<=mid;i++))
do
   c1=`echo $String|cut -c$i`           # extracts from beginning
   c2=`echo $String|cut -c$len`         # extracts from last

   if [ $c1 != $c2 ]
   then
        Flag=1


        break 2             # break N breaks out of N levels of loop.
   fi

   let len--
done

if [ $Flag -eq 0 ]
then
     echo "\"$orgstr\" is a Palindrome"
else
     echo "\"$orgstr\" is not a Palindrome"
fi


OUTPUT:

[root@www ]# ./palindrome1.sh Dammit, I\'m mad!
"Dammit, I'm mad!" is a Palindrome
[root@www ]# ./palindrome1.sh
Enter a String: 01/02/2010
"01/02/2010" is a Palindrome
[root@www ]# ./palindrome1.sh Hello world
"Hello world" is not a Palindrome


Method 2: 

#!/bin/bash
# SCRIPT: palindrome2.sh
# USAGE: palindrome.sh     or  palindrome.sh STRING
# PURPOSE: Script to test if a given string is a palindrome.
#
# In this script I uses the well known method, compare first character
# with last character, up to middle of the string. One mismatch in the
# scanning leads to immediate termination of the  scanning as it is
# not a palindrome. To extract a character from the string, I will use
# string manipulation operations.So you need to know how to manipulate
# strings to understand this script. I will give little bit of explan-
# tion at the end of this script.
#
#####################################################################
#                      Arguments Checking                           #
#####################################################################

[ $# -eq 0 ] && { echo -n "Enter a String: "; read orgstr ;} || \
orgstr=$*

#####################################################################
#                     Variable Initialization                       #
#####################################################################

# Remove all punctuations from input string and convert upper case to
# lower or lower case to upper.

String="$(echo $orgstr | sed 's/[^[:alnum:]]//g' | \
tr '[:upper:]' '[:lower:]')"

# Find length of the string.
len=${#String}

#get the mid value up to which the comparison would be done
mid=$(($len/2))

i=0
Flag=0

#####################################################################
#                     Main Script Starts Here                       #
#####################################################################

while [ $i -lt $mid ]
  do
      fchar=${String:$i:1}
      let i++
      bchar=${String: -$i:1}
      if [ "$fchar" != $bchar ]
      then
      Flag=1
      break 2              # break N breaks out of N levels of loop.
      fi
done

if [ $Flag -eq 0 ]
then
     echo "\"$orgstr\" is a Palindrome"
else
     echo "\"$orgstr\" is not a Palindrome"
fi


Substring Extraction:

${string:position}
    Extracts substring from $string at $position.
${string:position:length}
    Extracts $length characters of substring from $string at $position

Bash numbers first character of string as '0'.

${string: 0: 1} will extracts one character from the 0th character of
the string, ie it will only get the 0th character. ${string: 2: 1}
will get the third character. Also ${string: -1: 1} will extracts the
last one character, ${string: -3:1} will get the third last character.

Note:  ${string: -1:1} in this construct don't forget to give space
before -1, otherwise you will get full string.

For example

[root@localhost www]# tempvar=madam
[root@localhost www]# echo ${tempvar: -1:1}
m
[root@localhost www]# echo ${tempvar:-1:1}
madam

You can also use following command

[root@localhost www]# echo ${tempvar:(-1):1}
m

OUTPUT:

[root@www ]# ./palindrome2.sh Able was I ere I saw Elba
"Able was I ere I saw Elba" is a Palindrome
[root@www ]# ./palindrome2.sh 123454321
"123454321" is a Palindrome
[root@www ]# ./palindrome2.sh
Enter a String: 12345654321
"12345654321" is a Palindrome
[root@www ]# ./palindrome2.sh
Enter a String: 1234564321
"1234564321" is not a Palindrome


Method 3: 

#!/bin/bash
# SCRIPT: palindrome3.sh
# USAGE: palindrome.sh     or  palindrome.sh STRING
# PURPOSE: Script to test if a given string is a palindrome.
#
# This simply uses the 'rev' utility which is used to reverse lines of
# a file. Then check if the reverse of the string is same as the
# original.rev command is part of util-linux-ng or util-linux package.
#

if `which rev &>/dev/null`   # Checks rev command exist or not
then
     [ $# -eq 0 ] && { echo -n "Enter a String: "; read orgstr ;} || \
     orgstr=$*

     String="$(echo $orgstr | sed 's/[^[:alnum:]]//g' | \
     tr '[:upper:]' '[:lower:]')"

     if [ "$(echo $String | rev)" = "$String" ]
     then
          echo "\"$orgstr\" is a palindrome"
     else
          echo "\"$orgstr\" is not a palindrome"
     fi

else
     echo "Install util-linux or util-linux-ng package"
fi


OUTPUT:

[root@www ]# ./palindrome3.sh 01/02/2010
"01/02/2010" is a palindrome
[root@www ]# ./palindrome3.sh 01/03/2010
"01/03/2010" is not a palindrome
[root@www ]# ./palindrome3.sh
Enter a String: Hello World
"Hello World" is not a palindrome
[root@www ]# ./palindrome3.sh
Enter a String: rotator
"rotator" is a palindrome


Method 4:

#!/bin/bash
# SCRIPT: palindrome4.sh
# USAGE: palindrome.sh     or  palindrome.sh STRING
# PURPOSE:  Script to test if a given string is a palindrome.
#
# In this method we are not using 'rev' command to reverse the string.
# Using Substring Removal method or Substring Extraction method we
# will reverse the string, then compare it with oldstring.
#
#####################################################################
#                      Arguments Checking                           #
#####################################################################

[ $# -eq 0 ] && { echo -n "Enter a String: "; read orgstr ;} || \
orgstr=$*

#####################################################################
#                     Variable Initialization                       #
#####################################################################

String="$(echo $orgstr | sed 's/[^[:alnum:]]//g' | \
tr '[:upper:]' '[:lower:]')"

oldstring=$String
newstring=

#####################################################################
#                     Main Script Starts Here                       #
#####################################################################

while [ -n "$String" ]
do
     temp=${String#?}
     letter=${String%"$temp"}
     String=$temp
     newstring=${letter}${newstring}
done

if [ "$oldstring" = "$newstring" ]
then
     echo "\"$orgstr\" is a palindrome"
else
     echo "\"$orgstr\" is not a palindrome"
fi

# ${string#substring} is a Substing Removal operation. If you want to
# use Substring Extraction method, use bellow code.

#i=0
#while [ $i -lt ${#String} ]
#do
#    letter=${String:$i:1}
#    newstring=${letter}${newstring}
#    let i++;
#done
#
#if [ "$String" = "$newstring" ]
#then
#     echo "\"$orgstr\" is a palindrome"
#else
#     echo "\"$orgstr\" is not a palindrome"
#fi


Substring Removal:

${string#substring}
    Strips shortest match of $substring from front of $string.

Example:

[root@www]# tempvar=madam
[root@www]# echo ${tempvar#m}
adam
[root@www]# echo ${tempvar#ma}
dam
[root@www]# echo ${tempvar#?}
adam


${string%substring}
   Strips shortest match of $substring from back of $string.

Example:

[root@www]# temp=${tempvar#?}
[root@www]# echo $temp
adam
[root@www]# echo ${tempvar%$temp}
m

OUTPUT:

[root@www ]# ./palindrome4.sh Madam, I\'m Adam
"Madam, I'm Adam" is a palindrome
[root@www ]# ./palindrome4.sh Madam I Adam
"Madam I Adam" is not a palindrome
[root@www ]# ./palindrome4.sh
Enter a String: 123454321
"123454321" is a palindrome
[root@www ]# ./palindrome4.sh
Enter a String: 1234564321
"1234564321" is not a palindrome

Insertion Sort Shell Script

2010-07-29T09:34:00.000-07:00


#!/bin/bash#!/bin/bash
# SCRIPT: insertionsort.sh
#
# LOGIC: Here, sorting takes place by inserting a particular element
# at the appropriate position, that’s why the name insertion sorting.
# In the First iteration, second element ARRAY[1] is compared with
# the first element ARRAY[0]. In the second iteration third element
# is compared with first and second element. In general, in every
# iteration an element is compared with all the elements before it.
# While comparing if it is found that the element can be inserted at
# a suitable position, then space is created for it by shifting the
# other elements one position up and inserts the desired element at
# the suitable position. This procedure is repeated for all the
# elements in the list.
#
#####################################################################
#                      Define Functions Here                        #
#####################################################################

printnumbers()
{
echo ${ARRAY[*]}
}

sortnumbers()
{
for((i=1;i<count;i++))
do
   Temp=${ARRAY[i]}
   j=$((i-1))
   while [ $Temp -lt ${ARRAY[j]} ]
   do
      ARRAY[j+1]=${ARRAY[j]}
      let j--
      if [ $j == -1 ]
      then
         break
      fi
   done
   ARRAY[j+1]=$Temp
done
}

#####################################################################
#                       Variable Initialization                     #
#####################################################################

echo "Enter numbers to be sorted"

read -a ARRAY

count=${#ARRAY[@]}

#####################################################################
#                       Main Script Starts Here                     #
#####################################################################

echo "---------------------------------------------------------------"

echo "Numbers Before Sort:"

printnumbers

sortnumbers

echo "Numbers After Sort: "

printnumbers

echo "---------------------------------------------------------------"



OUTPUT:

[root@www blog]# sh insertionsort.sh
Enter Numbers to be Sorted :
12 76 34 -34 67 9 -56 5 99 -3 17
---------------------------------------------------------------
Numbers Before Sort:
12 76 34 -34 67 9 -56 5 99 -3 17
Numbers After Sort:
-56 -34 -3 5 9 12 17 34 67 76 99
---------------------------------------------------------------

NOTE: If we complement the while condition in this program, it will
give out the sorted array in descending order.

Selection Sort Shell Script

2010-07-29T09:29:00.000-07:00


#!/bin/bash#!/bin/bash
# SCRIPT: selectionsort.sh
#
# LOGIC : Here, to sort the data in ascending order, the first element
# ARRAY[0] is compared with all the other elements till the end of the
# array. If it is greater than any other the elements then they are
# interchanged. So after the first iteration of the outer for loop
# smallest element will be placed at the first position. The same pro-
# cedure is repeated for the other elements too.
#
#####################################################################
#                      Define Functions Here                        #
#####################################################################

printnumbers()
{
echo ${ARRAY[*]}
}

swap()
{
temp=${ARRAY[$1]}

ARRAY[$1]=${ARRAY[$2]}

ARRAY[$2]=$temp
}

sortnumbers()
{
for ((i=0;i<count;i++))
do
min=$i
  for ((j=i+1;j<count;j++))
  do
     if [ ${ARRAY[j]} -lt ${ARRAY[min]} ]
     then
     min=$j
     fi
  done
  swap $i $min
done
}

#####################################################################
#                       Variable Initialization                     #
#####################################################################

echo "Enter Numbers to be Sorted : "

read -a ARRAY

count=${#ARRAY[@]}

#####################################################################
#                       Main Script Starts Here                     #
#####################################################################

echo "---------------------------------------------------------------"

echo "Numbers Before Sort:"

printnumbers

sortnumbers

echo "Numbers After Sort: "

printnumbers

echo "---------------------------------------------------------------"



OUTPUT:

[root@www blog]# sh selectionsort.sh
Enter Numbers to be Sorted :
34 76 -8 12 23 5 9 -2 88 41 62
---------------------------------------------------------------
Numbers Before Sort:
34 76 -8 12 23 5 9 -2 88 41 62
Numbers After Sort:
-8 -2 5 9 12 23 34 41 62 76 88
---------------------------------------------------------------

NOTE: If we complement the if condition in this program, it will give
out the sorted array in descending order.

Bubble Sort Shell Script

2010-07-29T09:23:00.000-07:00


#!/bin/bash
# SCRIPT: bubblesort.sh
# LOGIC:
# Bubble sort is a simple sorting, it works by repeatedly stepping
# through the list to be sorted, comparing two items at a time and
# swapping them if they are in the wrong order. If you are sorting
# the data in Ascending order, at the end of the first pass, the
# "heaviest" element has move to bottom. In the second pass, the
# comparisons are made till the last but one position and now second
# largest element is placed at the last but one position. And so
# forth.
#
#####################################################################
#                      Define Functions Here                        #
#####################################################################

printnumbers()
{
echo ${ARRAY[*]}

#You can also use bellow code
#for ((i=0;i<count;i++))
#do
#echo -n " ${ARRAY[i]} "
#done
}

exchange()
{
temp=${ARRAY[$1]}

ARRAY[$1]=${ARRAY[$2]}

ARRAY[$2]=$temp

}

sortnumbers()
{
for (( last=count-1;last>0;last--))
do
    for((i=0;i<last;i++))
    do
      j=$((i+1))
      if [ ${ARRAY[i]} -gt ${ARRAY[j]} ]
      then

       exchange $i $j

      fi
    done
done
}

#####################################################################
#                       Variable Initialization                     #
#####################################################################

echo "Enter Numbers to be Sorted"

read -a ARRAY

count=${#ARRAY[@]}

#####################################################################
#                       Main Script Starts Here                     #
#####################################################################

echo "--------------------------------------------------------------"

echo "Numbers Before Sort:"

printnumbers

echo

sortnumbers

echo "Numbers After Sort: "

printnumbers

echo "--------------------------------------------------------------"



OUTPUT:

[root@www blog]# sh bubblesort.sh
Enter Numbers to be Sorted :
78 34 12 98 21 8 36 98 12 88 7 5 61 -12 62 -1 77 -46
------------------------------------------------------
Numbers Before Sort:
78 34 12 98 21 8 36 98 12 88 7 5 61 -12 62 -1 77 -46

Numbers After Sort:
-46 -12 -1 5 7 8 12 12 21 34 36 61 62 77 78 88 98 98
------------------------------------------------------

NOTE: If we complement the if condition in this program, it will give
out the sorted array in descending order.


Method2: Without Using Arrays

#!/bin/bash
# SCRIPT: bubblesort2.sh
# Without using arrays
#
#####################################################################
#                       Define Functions Here                       #
#####################################################################

printnumbers()
{
k=1
while [ $k -le $max ]
do
eval echo -n "\$x$k"
echo -n " "
let k++
done
echo
}

#####################################################################
#                        Variable Initialization                    #
#####################################################################

echo -n "Enter Total Numbers to be Sorted : "
read max
count=1
while [ $count -le $max ]
do
echo -n "Enter number $count: "
read x$count
let count++
done

#####################################################################
#                       Main Script Starts Here                     #
#####################################################################

echo -e "\nElements Before Sort"
printnumbers

for (( last=count-1;last>0;last--))
do
  for ((i=1;i<last;i++))
  do
     j=$((i+1))
     eval sval=\$x$i
     eval nval=\$x$j

#The eval command evaluates the command line to complete any shell
#substitutions necessary and then executes the command. So $i and $j
#substituted first then $x1 and $x2 evaluated.

     if [ $sval -gt $nval ]
     then
     eval x$i=$nval
     eval x$j=$sval
     fi
   done
done

echo  "Elements After Sort: "
printnumbers



OUTPUT:

[root@www shell]# sh bubblesort2.sh
Enter Total Numbers to be Sorted : 6
Enter number 1: 12
Enter number 2: -4
Enter number 3: 6
Enter number 4: -11
Enter number 5: 43
Enter number 6: 9

Elements Before Sort
12 -4 6 -11 43 9
Elements After Sort:
-11 -4 6 9 12 43

How to Read a File Line by Line in a Shell Script

2010-05-14T23:45:00.000-07:00


 There are many ways to handle any task on a Unix platform,  but some
techniques that are used to process a file waste a lot of CPU time.
Most of the wasted time is spent in unnecessary variable assignment and
continuously opening and closing the same file over and over. Using a
pipe also has a negative impact on the timing.

 In this article I will explain various techniques for parsing a file
line by line. Some techniques are very fast and some make you wait for
half a day. The techniques used in this article are measurable, and I
tested each technique with time command so that you can see which tec-
hniques suits your needs.

 I don't explain in depth every thing, but if you know basic shell
scripting, I hope you can understand easily.

 I extracted last five lines from my /etc/passwd file, and stored in a
file "file_passwd".

[root@www blog]# tail -5 /etc/passwd > file_passwd
[root@www blog]# cat file_passwd
venu:x:500:500:venu madhav:/home/venu:/bin/bash
padmin:x:501:501:Project Admin:/home/project:/bin/bash
king:x:502:503:king:/home/project:/bin/bash
user1:x:503:501::/home/project/:/bin/bash
user2:x:504:501::/home/project/:/bin/bash

 I use this file whenever a sample file required.

Method 1:  PIPED while-read loop

#!/bin/bash
# SCRIPT:  method1.sh
# PURPOSE: Process a file line by line with PIPED while-read loop.

FILENAME=$1
count=0
cat $FILENAME | while read LINE
do
       let count++
       echo "$count $LINE"
done

echo -e "\nTotal $count Lines read"

 With catting a file and piping the file output to a while read loop a
single line of text is read into a variable named LINE on each loop
iteration. This continuous loop will run until all of the lines in the
file have been processed one at a time.

 Bash can sometimes start a subshell in a PIPED "while-read" loop. So
the variable set within the loop will be lost (unset) outside of the
loop. Therefore, $count would return 0, the initialized value outside
the loop.

Output:

[root@www blog]# sh method1.sh file_passwd
1 venu:x:500:500:venu madhav:/home/venu:/bin/bash
2 padmin:x:501:501:Project Admin:/home/project:/bin/bash
3 king:x:502:503:king:/home/project:/bin/bash
4 user1:x:503:501::/home/project/:/bin/bash
5 user2:x:504:501::/home/project/:/bin/bash

Total 0 Lines read

Method 2:  Redirected "while-read" loop

#!/bin/bash
#SCRIPT:  method2.sh
#PURPOSE: Process a file line by line with redirected while-read loop.

FILENAME=$1
count=0

while read LINE
do
      let count++
      echo "$count $LINE"

done < $FILENAME

echo -e "\nTotal $count Lines read"

 We still use the while read LINE syntax, but this time we feed the
loop from the bottom (using file redirection) instead of using a pipe.
You will find that this is one of the fastest ways to process each
line of a file. The first time you see this it looks a little unusual,
but it works very well.

 Unlike method 1, with method 2 you will get total number of lines out
side of the loop.

Output:

[root@www blog]# sh method2.sh file_passwd
1 venu:x:500:500:venu madhav:/home/venu:/bin/bash
2 padmin:x:501:501:Project Admin:/home/project:/bin/bash
3 king:x:502:503:king:/home/project:/bin/bash
4 user1:x:503:501::/home/project/:/bin/bash
5 user2:x:504:501::/home/project/:/bin/bash

Total 5 Lines read

Note: In some older shell scripting languages, the redirected loop
would also return as a subshell.

Method 3:while read LINE Using File Descriptors

 A file descriptor is simply a number that the operating system assigns
to an open file to keep track of it. Consider it a simplified version
of a file pointer. It is analogous to a file handle in C.

 There are always three default "files" open, stdin (the keyboard),
stdout (the screen), and stderr (error messages output to the screen).
These, and any other open files, can be redirected. Redirection simply
means capturing output from a file, command, program, script, or even
code block within a script  and sending it as input to another file,
command, program, or script.

 Each open file gets assigned a file descriptor. The file descriptors
for stdin,stdout, and stderr are 0,1, and 2, respectively. For opening
additional files, there remain descriptors 3 to 9 (may be vary depend-
ing on OS). It is sometimes useful to assign one of these additional
file descriptors to stdin, stdout, or stderr as a temporary duplicate
link. This simplifies restoration to normal after complex redirection
and reshuffling .

 There are two steps in the method we are going to use. The first step
is to close file descriptor 0 by redirecting everything to our new file
descriptor 3. We use the following syntax for this step:

  exec 3<&0

 Now all of the keyboard and mouse input is going to our new file des-
criptor 3. The second step is to send our input file, specified by the
variable $FILENAME, into file descriptor 0 (zero), which is standard
input. This second step is done using the following syntax:

    exec 0<$FILENAME

 At this point any command requiring input will receive the input from
the $FILENAME file. Now is a good time for an example.

#!/bin/bash
#SCRIPT:  method3.sh
#PURPOSE: Process a file line by line with while read LINE Using
#File Descriptors

FILENAME=$1
count0=
exec 3<&0
exec 0< $FILENAME

while read LINE
do
        let count++
        echo "$count $LINE"
done

exec 0<&3
echo -e "\nTotal $count Lines read"

 while loop reads one line of text at a time.But the beginning of this
script does a little file descriptor redirection. The first exec comm-
and redirects stdin to file descriptor 3. The second exec command red-
irects the $FILENAME file into stdin, which is file descriptor 0. Now
the while loop can just execute without our having to worry about how
we assign a line of text to the LINE variable. When the while loop
exits we redirect the previously reassigned stdin, which was sent to
file descriptor 3, back to its original file descriptor 0.

 exec 0<&3

In other words we set it back to the system’s default value.

Output:

[root@www tempdir]# sh method3.sh file_passwd 
1 venu:x:500:500:venu madhav:/home/venu:/bin/bash
2 padmin:x:501:501:Project Admin:/home/project:/bin/bash
3 king:x:502:503:king:/home/project:/bin/bash
4 user1:x:503:501::/home/project/:/bin/bash
5 user2:x:504:501::/home/project/:/bin/bash

Total 5 Lines read

Method 4: Process file line by line using awk

 awk is pattern scanning and text processing language. It is useful
for manipulation of data files, text retrieval and processing. Good
for manipulating and/or extracting fields (columns) in structured
text files.

 Its name comes from the surnames of its authors: Alfred Aho, Peter
Weinberger, and Brian Kernighan.

 I am not going to explain everything here.To know more about awk just
Google it.

At the command line, enter the following command:

$ awk '{ print }' /etc/passwd 

 You should see the contents of your /etc/passwd file appear before
your eyes.Now, for an explanation of what awk did. When we called awk,
we specified /etc/passwd as our input file. When we executed awk, it
evaluated the print command for each line in /etc/passwd, in order.All
output is sent to stdout, and we get a result identical to catting
/etc/passwd. Now, for an explanation of the { print } code block. In
awk, curly braces are used to group blocks of code together, similar
to C. Inside our block of code,we have a single print command. In awk,
when a print command appears by itself, the full contents of the curr-
ent line are printed.

Here is another awk example that does exactly the same thing:

$ awk '{ print $0 }' /etc/passwd 

 In awk, the $0 variable represents the entire current line, so print
and print $0 do exactly the same thing. Now is a good time for an
example.

#!/bin/bash
#SCRIPT:  method4.sh
#PURPOSE: Process a file line by line with awk

FILENAME=$1

awk '{kount++;print  kount, $0}
     END{print "\nTotal " kount " lines read"}' $FILENAME


Output:

[root@www blog]# sh method4.sh file_passwd
1 venu:x:500:500:venu madhav:/home/venu:/bin/bash
2 padmin:x:501:501:Project Admin:/home/project:/bin/bash
3 king:x:502:503:king:/home/project:/bin/bash
4 user1:x:503:501::/home/project/:/bin/bash
5 user2:x:504:501::/home/project/:/bin/bash

Total 5 lines read

Awk is really good at handling text that has been broken into multiple
logical fields, and allows you to effortlessly reference each individ-
ual field from inside your awk script. The following script will print
out a list of all user accounts on your system:

awk -F":" '{ print $1 "\t " $3  }' /etc/passwd

 Above, when we called awk, we use the -F option to specify ":" as the
field separator. By default white space (blank line) act as filed sep-
arator. You can set new filed separator with -F option. When awk proc-
esses the print $1 "\t " $3 command, it will print out the first and
third fields that appears on each line in the input file. "\t" is used
to separate field with tab.

Method 5: Little tricky with head and tail 
commands

#!/bin/bash
#SCRIPT:  method5.sh
#PURPOSE: Process a file line by line with head and tail commands

FILENAME=$1
Lines=`wc -l < $FILENAME`

count=0

while [ $count -lt $Lines ]
do
let count++
LINE=`head -n $count $FILENAME | tail -1`
echo "$count $LINE"
done
echo -e "\nTotal $count lines read"

On each iteration head command extracts top $count lines, then tail
command extracts bottom line from that lines. A very stupid method,
but some people still using it.

Output:

[root@www blog]# sh method5.sh file_passwd
1 venu:x:500:500:venu madhav:/home/venu:/bin/bash
2 padmin:x:501:501:Project Admin:/home/project:/bin/bash
3 king:x:502:503:king:/home/project:/bin/bash
4 user1:x:503:501::/home/project/:/bin/bash
5 user2:x:504:501::/home/project/:/bin/bash

Total 5 lines read


Time Comparison for the Five Methods

 Now take a long breath, we are going test each technique. Before you
get into test each method of parsing a file line by line create a large
file that has the exact number of lines that you want to process.
Use bigfile.sh script to create a large file.

$ sh bigfile.sh 900000 

bigfile.sh with 900000 lines as an argument,it has taken more than two
hours to generate bigfile.4227. I don't know exactly how much time it
has taken. This file is extremely large to parse a file line by line,
but I needed a large file to get the timing data greater than zero.

[root@www blog]# du -h bigfile.4227
70M     bigfile.4227
[root@www blog]# wc -l bigfile.4227
900000 bigfile.4227


[root@www blog]# time ./method1.sh bigfile.4227 >/dev/null

real    6m2.911s
user    2m58.207s
sys     2m58.811s
[root@www blog]# time ./method2.sh bigfile.4227 > /dev/null

real    2m48.394s
user    2m39.714s
sys     0m8.089s
[root@www blog]# time ./method3.sh bigfile.4227 > /dev/null

real    2m48.218s
user    2m39.322s
sys     0m8.161s
[root@www blog]# time ./method4.sh bigfile.4227 > /dev/null

real    0m2.054s
user    0m1.924s
sys     0m0.120s
[root@www blog]# time ./method5.sh bigfile.4227 > /dev/null
I waited more than half day, still i didn't get result, then I created
a 10000-line file to test this method.
[root@www tempdir]# time ./method5.sh file.10000 > /dev/null

real    2m25.739s
user    0m21.857s
sys     1m12.705s

Method 4 came in first place,it has taken very less time 2.05 seconds,
but we can't compare Method 4 with other methods, because awk is not
just a command, but a programming language too.

 Method 2 and method 3 are tied for second place, they  produce mostly
the same real execution time at 2 minutes and 48 seconds . Method 1
came in third at 6 minutes and 2.9 seconds.

 Method 5 has taken more than half a day. 2 minutes 25 seconds to pro-
cess just a 10000 line file, how stupid it is.

Note: If file contain escape characters, use read -r instead of read,
then Backslash does not act as an escape character. The back-slash is
considered to be part of the line. In  particular, a backslash-newline
pair may not be used as a line continuation.

Shell Script to Display Time and Date in the Top Right Corner of the Screen.

2010-04-20T06:05:00.000-07:00


Using tput command:

#!/bin/bash
# SCRIPT: digclock.sh
# USAGE:  ./digiclock &
# PURPOSE: Displays time and date in the top right corner of the
#          screen using tput command.
# To stop this digclock use command "kill pid"
################################################################

####################### VARIABLE DECLARATION ###################

 # To place the clock on the appropriate column, subtract the
 # length of $Time and $Date, which is 22, from the total number
 # of columns

  Columns=$(tput cols)
  Startpoint=$(($Columns-22))

 # If you're in an X Window System terminal,you can resize the
 # window, and the clock will adjust its position because it is
 # displayed at the last column minus 22 characters.

  Color1=`tput setab 2`        # Green background color for time
  Color2=`tput setab 6`        # Cyan  background color for date
  Normal=`tput sgr0`           # back to normal screen colors

####################### MAIN PROGRAM ###########################

# The script is executed inside a while without conditions

while :
do
  Time=`date +%r`
  Date=`date +"%d-%m-%Y"`
  tput sc                   #Save the cursor position&attributes
  tput cup 0 $Startpoint

 # You can also use bellow one liner
 # tput cup 0 $((`tput cols`-22))
 # But it is not efficient to calculate cursor position for each
 # iteration. That's why I placed variable assignment before
 # beginning of the loop.

 # print time and date in the top right corner of the screen.

  echo -n $Color1$Time $Color2$Date$Normal

 # restore the cursor to whatever was its previous position

  tput rc

 # Delay for 1 second

  sleep 1

done


Using ANSI escape sequences:

 The ANSI escape sequences don't work in all terminal emulators, but
they do fine in xterm. Here's the script:

#!/bin/bash
# SCRIPT: digclock.sh
# USAGE:  ./digiclock &
# PURPOSE: Displays time and date in the top right corner of the
#          screen using ANSI escape sequences.
# To stop this digclock use command kill pid.
################################################################

#################### VARIABLE DECLARATION ######################

 # To place the clock on the appropriate column, subtract the
 # length of $Time and $Date, which is 22, from the total number
 # of columns

  Columns=$(tput cols)
  Startpoint=$(($Columns-22))

 # If you're in an X Window System terminal,you can resize the
 # window, and the clock will adjust its position because it is
 # displayed at the last column minus 22 characters.

########################### MAIN PROGRAM #######################

# The script is executed inside a while without conditions.

while :
do
  Time=`date +%r`
  Date=`date +"%d-%m-%Y"`
  echo -en "\033[s"    #save current screen position & attributes

  tput cup 0 $Startpoint

 # You can also use bellow one liner.
 # tput cup 0 $((`tput cols`-22))
 # But it is not efficient to calculate cursor position for each
 # iteration. That's why I placed variable assignment before
 # beginning of the loop

 # print time and date in the top right corner of the screen

  echo -en "\033[42m$Time \033[46m$Date\033[0m"

 #restore current screen position & attributes

  echo -e -n "\033[u"

 #Delay for 1 second

  sleep 1
done

 Save the script as digclock.sh,change permissions to 755 using chmod,
and run it with ./digclock.sh & or . digclock.sh & or sh digclock &.
The time and date should now appear at the top right of your screen.

Output:



 When you run digclock.sh, the terminal will return the job number and
process identifier (PID) of the digclock.sh process. From above output
you can find job number is "1" and PID is "15800".

You can end the execution of the script by two ways:

1. Using the kill command and specifying the job number or process ID.
   If you don't remember job number or PID, you can get job number by
   running jobs command and PID by ps command.

$ jobs
[1]+  Running                 ./digclock.sh &
$ shell]# ps | grep digclock
15800 pts/1    00:00:00 digclock.sh

 To kill this job/process, either kill %1 or kill 15800 works.

$ kill %1
$
[1]+  Terminated              ./digclock.sh
              or
$ kill 15800
$
[1]+  Terminated              ./digclock.sh

2. Using the fg command. The fg command switches a job running in the
   background into the foreground, Then press Ctrl+c to terminate the
   job. If no job number is specified, then fg command acts upon the
   currently running job.

$ fg 1
./digclock.sh

Ctrl+c
$

 With this script, you can display not only a clock, but other useful
information as well. For example,monitoring free space with df command
or CPU's load average with uptime command. Samba, Apache, and many
other servers have status commands where you can extract pieces of
information to show this way.

How to Handle Cursor Movement in a Shell Script

2010-04-18T08:19:00.000-07:00


Using ANSI escape sequences :

 ANSI escape sequences or tput allow you to move the cursor around the
screen at will. This is more useful for full screen user interfaces
generated by shell scripts, but can also be used in prompts.

The movement escape sequences are as follows:

        - Position the Cursor:
          \033[<L>;<C>H
             Or
          \033[<L>;<C>f
          puts the cursor at line L and column C.
        - Move the cursor up N lines:
          \033[<N>A
        - Move the cursor down N lines:
          \033[<N>B
        - Move the cursor forward N columns:
          \033[<N>C
        - Move the cursor backward N columns:
          \033[<N>D
        - Clear the screen, move to (0,0):
          \033[2J
        - Erase to end of line:
          \033[K
        - Save cursor position:
          \033[s
        - Restore cursor position:
          \033[u

 The latter two codes are NOT honored by many terminal emulators. The
only ones that I'm aware of that do are xterm and nxterm - even though
the majority of terminal emulators are based on xterm code. As far as
I can tell, rxvt, kvt, xiterm, and Eterm do not support them. They are
supported on the console.

$ echo -en "\033[s\033[7B\033[1;34m BASH BASH\033[u\033[0m"

 Above line  saves the current cursor position(\033[s), then move the
cursor seven lines down the screen(\033[7B),print the word "BASH BASH"
in dark blue color(\033[1;34m), and then return to where it started to
produce a normal prompt(\033[u), and also back to the normal color
(\033[0m).

Example:

$ echo -en "\033[s\033[7B\033[1;34m BASH BASH\033[u\033[0m"
$






BASH BASH

Using tput command:

 As with so many things in Unix, there is more than one way to achieve
the same ends.A utility called tput can also be used to move the cursor
around the screen, get back information about the status of the termi-
nal, or set colors.

 man tput doesn't go into much detail about the available commands,but
man terminfo will give you a huge list of capabilities, many of which
are device independent, and therefore better than the escape sequences
previously mentioned.

Here is some useful tput capabilities:

tput Cursor Movement Capabilities:

tput cup Y X
        Move cursor to screen location X,Y (top left is 0,0)

tput sc
        Save the cursor position

tput rc
        Restore the cursor position

tput lines
        Output the number of lines of the terminal

tput cols
        Output the number of columns of the terminal

tput cub N
        Move N characters left

tput cuf N
        Move N characters right
tput cuu N
        up N lines

tput cud N
        down N lines

tput Colour Capabilities :

tput setab [1-7] 
        Set a background colour using ANSI escape

tput setb [1-7] 
        Set a background colour

tput setaf [1-7] 
        Set a foreground colour using ANSI escape

tput setf [1-7] 
        Set a foreground colour

tput Text Mode Capabilities: 

tput bold 
        Set bold mode

tput dim 
        turn on half-bright mode

tput smul 
        begin underline mode

tput rmul 
        exit underline mode

tput rev 
        Turn on reverse mode

tput smso 
        Enter standout mode (bold on rxvt)

tput rmso 
        Exit standout mode

tput sgr0 
        Turn off all attributes (doesn't work quite as expected).

tput Clear and Insert Capabilities :

tput ech N 
        Erase N characters

tput clear 
        clear screen and home cursor

tput el1 
        Clear to beginning of line

tput el 
        clear to end of line

tput ed 
        clear to end of screen

tput ich N 
        insert N characters (moves rest of line forward!)

tput il N 
        insert N lines

  This is by no means a complete list of what terminfo and tput allow,
in fact it's only the beginning. man tput and man terminfo if you want
to know more.

Example:

$ tput sc;tput cup 4 35;tput setaf 2;echo "Hello World";\
> tput rc;tput sgr0
$ 

                                   Hello World


Bellow example shows two different ways to achieve same task:

$ tput sc;tput  cud 7;tput setaf 4;echo BASH BASH; tput rc;\
> tput sgr0
$ echo -en "\033[s\033[7B\033[0;34m BASH BASH\033[u\033[0m"

Creating a User Group and Shared Directory

2010-03-28T11:26:00.000-07:00


 To understand this article you should to be familiar with Linux adva-
nced file permissions, otherwise go throw bellow link before following
this article.
Advanced File Permissions

My Obejective: 
 I have a folder which I want to share with "rw" permissions for a
selected group of users. Let's say the folder is /home/project and I
want to share it with the group development. What I want is not only
having users accessing files in /home/project with rw access, but also
to ensure that all files created in /home/project will have ownership
username:development  and permissions -rw-rw-r--.

 Sharing a directory among users in same group is one of the essential
tasks.To let a group of users work on a set of files without infringing
on security, you'll have to do this:

1.Create a common group for these users in /etc/group

# groupadd development
check group created or not
# tail -1 /etc/group
development:x:501:

2.Add user project administrator (padmin) and setup password

# useradd -g development -d /home/project -c "Project Admin" \
-m padmin
# tail -1 /etc/passwd
padmin:x:501:501:Project Admin:/home/project:/bin/bash
#passwd padmin

3.Create separate user accounts for the rest of users but specify the
  same home directory.

# useradd -d /home/project/ -g development user1
# passwd user1
 Add another user:
# useradd -d /home/project/ -g development user2
# passwd user2

Create as many user accounts as you want.

4.Make sure the home directory and all subdirectories are not owned by
  any of the users. Use chown to surrender ownership to padmin.

# chown padmin:development /home/project/
# ls -ld /home/project/
drwxrwxr-x 18 padmin development 4096 Mar 28 16:18 /home/project/

5.Make the directories group-writable and set their SGID and Sticky
  Bits with chmod 3775  (1 for sticky and 2 for SGID).

# chmod -R 3775 /home/project/
# ls -ld /home/project/
drwxrwsr-t 18 padmin development 4096 Mar 28 18:22 /home/project/

 In this scenario, every user of the group has write permission on the
directory and can create files and directories, but can only delete
those he owns. SGID bit ensures  that all files created in
/home/project will have ownership username:development  and Sticky bit
ensures that only owner can delete files those he owns

 Note that setting the SGID permission on a directory only affects the
groupID of new files and subdirectories created after the SGID bit is
set, and is not applied to existing entities. Setting the setgid bit
on existing subdirectories must be done manually.

Can You Inherit File Permissions?

 When you create a file or directories under a directory the default
permission for them will be determined by your umask, files or
directories won't inherit parent directory permissions, only SGID bit
inherited by newly created directories under it. So even your shared
directory has group writable, you can't edit other users files.

Login as user1 and create a temp file.

# su – user1
$ touch temp ; ls -l temp
-rw-r--r-- 1 user1 development 0 Mar 28 18:54 temp

Now logins as user2 and try to edit temp file.

# su - user2
$ cat > temp
-bash: temp: Permission denied

 There is no way to inherit permissions from a directory, it's contro-
lled by the process's umask. But there is a way to make file permissi-
ons group writable when it is created.Add umask 002 command to .bashrc
file if it exist, otherwise create it and add the command.

# su - padmin
$ ls -l .bashrc
-rwxrwsr-t 1 padmin development 124 Mar 28 13:05 .bashrc
$ cat >> .bashrc
umask 002
Ctrl+d

Now login as user1 and create a temp file.

# su - user1
$ touch temp ; ls -l temp
-rw-rw-r-- 1 user1 development 0 Mar 28 19:38 temp

File created with default group writable permissions.

Note: Inform already logged in users to logout and login again.

   Have you thought about using ACLs? They will give you much finer
grained control over the permissions you can set on files and directo-
ries. ACLs will also allow you to set a default mask for any given
directory.

 To know more about ACLs(Access Control Lists) Google it as Linux acls
 or wait for my next article.

UNIX/Linux Advanced File Permissions - SUID,SGID and Sticky Bit

2010-03-27T10:51:00.000-07:00


   After you have worked for a while with Linux you discover probably
that there is much more to file permissions than just the "rwx" bits.
When you look around in your file system you will see "s" and "t"

$  ls -ld /tmp
drwxrwxrwt 29 root root 36864 Mar 21 19:49 /tmp

$  which passwd
/usr/bin/passwd

$  ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 22984 Jan  6  2007 /usr/bin/passwd

 What is this "s" and "t" bit? The vector of permission bits is really
4 * 3 bits long. Yes there are 12 permission bits,not just 9.The first
three bits are special and are frequently zero. And you almost always
learn about the trailing 9 bits first.Some people stop there and never
learn those first three bits.

 The forth permission bit is used only when a special mode of a file
needs to be set. It has the value 4 for SUID, 2 for SGID and 1 for the
sticky bit. The other 3 bits have their usual significance.

 Here we will discuss about the 3 special attributes other than the
common read/write/execute:

     1.Set-User-Id (SUID)
        2.Set-Group-Id (SGID)
        3.Sticky Bit

Set-User_Id (SUID): Power for a Moment:  

 By default, when a user executes a file, the process which results in
this execution has the same permissions as those of the user. In fact,
the process inherits his default group and user identification.

 If you set the SUID attribute on an executable file, the process res-
ulting in its execution doesn't use the user's identification but the
user identification of the file owner.

 The SUID mechanism,invented by Dennis Ritchie,is a potential security
hazard. It lets a user acquire hidden powers by running such a file
owned by root.

$ ls -l /etc/passwd /etc/shadow /usr/bin/passwd
-rw-r--r-- 1 root root  2232 Mar 15 00:26 /etc/passwd
-r-------- 1 root root  1447 Mar 19 19:01 /etc/shadow

 The listing shows that passwd is readable by all, but shadow is unre-
adable by group and others. When a user running the program belongs to
one of these two categories (probably, others), so access fails in the
read test on shadow. suppose normal user wants to change his password,
How can he do that? He can do that by running /usr/bin/passwd. Many
UNIX/Linux programs have a special permission mode that lets users
update sensitive system files –like /etc/shadow --something they can't
do directly with an editor. This is true of the passwd program.

$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 22984 Jan  6  2007 /usr/bin/passwd

The s letter in the user category of the permission field represents a
special mode known as the set-user-id (SUID). This mode lets a process
have the privileges of the owner of the file during the instance of
the program. Thus when a non privileged user executes passwd, the eff-
ective UID of the process is not the user's, but of root's – the owner
of the program. This SUID privilege is then used by passwd to edit
/etc/shadow.

What is effective user-id:

 Every process really has two user IDs: the effective user ID and the
real user ID. (Of course, there's also an effective group ID and real
group ID.Just about everything that's true about user IDs is also true
about group IDs) Most of the time,the kernel checks only the effective
user ID. For example, if a process tries to open a file, the kernel
checks the effective user ID when deciding whether to let the process
access the file.

  Save the following script under the name reids.pl and make it
executable (chmod 755 reids.pl). 

#!/usr/bin/perl
# print real UID
print "Real UID: $<\n";
# print real GID
print "Real GID: $(\n";
# print effective UID
print "Effective UID: $>\n";
# print effective GID
print "Effective GID: $)\n";

check file permissions:

$ ls -l reids.pl
-rwxr-xr-x 1 venu venu 203 Mar 24 10:40 reids.pl

Note: For security reasons the s-bit works only when used on binaries
(compiled code) and not on scripts (an exception are perl scripts).
Scripts,i.e. programs that cannot be executed by the kernel directory
but need an interpreter such as the Bourne shell or Java,can have
their setuid bit set, but it doesn't have any effect. There are some
platforms that honor the s bits even on scripts ( some System V vari-
ants, for example), but most systems don't because it has proven such
a security headache - most interpreters simply aren't written with
much security in mind. Set the SUID bit on shell script is useless,
that's why I am using perl script here.

 When you run the script you will see that the process that runs it
gets your user-ID and your group-ID:

$ ./reids.pl
Real UID: 500
Real GID: 500 500
Effective UID: 500
Effective GID: 500 500

Note: If you get an error like this:
Can't do setuid (cannot exec sperl)

In Debian install perl-suid using following command:
apt-get install perl-suid

In Centos install perl-suidperl using following command:
yum install perl-suidperl

 Now change owner ship to  another user (Do it as an administrator).

# chown king /home/venu/reids.pl
# ls -l /home/venu/reids.pl
-rwxr-xr-x 1 king venu 203 Mar 24 10:40 /home/venu/reids.pl

Now run the script again.

$ ./reids.pl
Real UID: 500
Real GID: 500 500
Effective UID: 500
Effective GID: 500 500

 What you observed, the output of the program depends only on the user
that runs it and not the one who owns the file.

How to assign SUID permission: 

 The SUID for any file can be set (mostly by the superuser) with a
special syntax of the chmod command. This syntax uses the character s
as the permission. Now add SUID permission to the script reids.pl :

# chmod u+s /home/venu/reids.pl     (Do it from root account)

Now return from the super user mode to the usual non privileged mode.

$ ls -l reids.pl
-rwsr-xr-x 1 king venu 203 Mar 24 10:40 reids.pl

 To assign SUID in an absolute manner, simply prefix 4 to whatever
octal string you would otherwise use (like 4755 instead of 755).

 The file reids.pl is owned by king and has the s-bit set where norma-
lly the x is for the owner of the file. This causes the file to be
executed under the user-ID of the user that owns the file rather than
the user that executes the file. If venu runs the program then this
looks as follows:

$ perl reids.pl
Real UID: 500
Real GID: 500 500
Effective UID: 503
Effective GID: 500 500

 Effective user id of process is 503, this is not the venu's , but of
king's - the owner of the program. As you can see this is a very powe-
rful feature especially if root owns the file with s-bit set. Any user
can then do things that normally only root can do.

Caution:    When you write a SUID program then you must make sure that
it can only be used for the purpose that you intended it to be used.
As administrator, you must keep track of all SUID programs owned by
root that a user may try to create or copy. The find command easily
locate them:

# find /home -perm -4000 -print | mail root

  The extra octal bit (4) signifies the SUID mode, but find treats the
  "–" before 4000 as representing any other permissions.

Set-Group_Id (SGID):

 The set-group-id (SGID) is similar to SUID except that a program with
SGID set allows the user to have the same power as the group which
owns the program. The SGID bit is 2,and some typical examples could be
chmod g+s reids.pl or chmod 2755 reids.pl.
You can remove SGID bit using following commands:

$ chmod g-s reids.pl
$ chmod 755 reids.pl       (Absolute manner)

 It is really useful in case you have a real multi-user setup where
users access each others files. As a single homeuser I haven't really
found a lot of use for SGID. But the basic concept is the same as the
SUID,Similar to SUID, SGID also grants privileges and access rights to
the process running the command, but instead of receiving those of the
file's owner it receives those of the file's group. In other words,the
process group owner will be set to the file's group. 

 I explain it with an example. I have created two user accounts king 
and venu with same home directory project. king belongs to king and
development groups, venu belongs to venu and development groups.

# groups king venu
king : king development
venu : venu development

venu's default group is venu and king's default group is king.

 Login as king and create reids.pl  file again and make it executable
(using  chmod 755 reids.pl) .

$ id
uid=503(king) gid=503(king) groups=501(development),503(king)
$ ls -l reids.pl
-rwxr-xr-x 1 king development 203 Mar 25 19:00 reids.pl

Now login as venu and run the program:

$ id
uid=501(venu) gid=504(venu) groups=501(development),504(venu)
$ perl reids.pl
Real UID: 501
Real GID: 504 504 501
Effective UID: 501
Effective GID: 504 504 501

The effective GID of the process is the venu's,but not of the king's 
-the owner of the program.

Now login as king and assign SGID bit to reids.pl program:

$ chmod 2755 reids.pl; ls -l reids.pl
-rwxr-sr-x 1 king development 203 Mar 25 19:00 reids.pl

Now login as venu and run the reids.pl program:

$ perl reids.pl
Real UID: 501
Real GID: 504 504 501
Effective UID: 501
Effective GID: 501 504 501

 Real GID and Effective GID are different,here Effective GID is the
king's - the owner of the program.

Set SGID on a directory:

 When SGID is set on a directory it has a special meaning. Files crea-
ted in a directory with SGID set will inherit the same group ownership
as the directory itself,not the group of the user who created the file.
If the SGID is not set the file's group ownership corresponds to the
user's default group.

 In order to set the SGID on a directory or to remove it, use the
following commands:

$ chmod g+s directory     or     $ chmod 2755 directory
$ chmod g-s directory     or     $ chmod 755 directory

 As I mentioned earlier venu and king's home directory is same that is
/home/project. I changed group ownership of /home/project directory
to development.

# ls -ld /home/project/
drwxrwxr-x 16 root development 4096 Mar 26 00:22 /home/project/

Now login as king and create a temp file.

$ whoami
king
$ pwd
/home/project/
$ touch temp; ls -l temp
-rw-r--r-- 1 king king 0 Mar 26 12:34 temp

 You can see from the ls output that the group owner for project is
development, and that the SGID bit has not been set on the directory
yet. When king creates a file in project, the group for the file is
king (king's primary gid).

 Set SGID bit on project directory. For that login as administrator
and set SGID bit using following command:

# chmod g+s /home/project/
# ls -ld /home/project/
drwxrwsr-x 15 root development 4096 Mar 26 12:34 /home/project/

 From the ls output above, you know the SGID bit is set because of the
s in the third position of the group permission set,which replaces the
x in the group permissions.

Now login as king and create temp2 file.

$ whoami
king
$ touch temp2; ls -l temp2
-rw-r--r-- 1 king development 0 Mar 26 13:49 temp2

 Notice the group ownership for temp2 file. It inherits group permiss-
ion from the parent directory.

 Enabling SGID on a directory is extremely useful when you have a
group of users with different primary groups working on the same set
of files.

        For system security reasons it is not a good idea to set many
program's set user or group ID bits any more than necessary,since this
can allow an unauthorized user privileges in sensitive system areas.If
the program has a flaw that allows the user to break out of the inten-
ded use of the program, then the system can be compromised.

Sticky bit:

 The sticky bit(also called the saved text bit) is the last permission
bit remaining to be discussed. It applies to both regular files and
directories. When applied to a regular file, it ensures that the text
image of a program with the bit set is permanently kept in the swap
area so that it can be reloaded quickly when the program's turn to use
the CPU arrives. Previously, it made sense to have this bit set for
programs like vi and emacs. Today,machines with ultra-fast disk drives
and lots of cheap memory don't need this bit for ordinary files and
that is also useless.

 However, the sticky bit become a useful security feature when used
with a directory. The UNIX/Linux system allows users to create files
in /tmp, but none can delete files not owned by him. That's possible
because sticky bit set for /tmp directory.

 The /tmp directory is typically world-writable and looks like this
in a listing:

# ls -ld /tmp
drwxrwxrwt 32 root root 36864 Mar 27 12:38 /tmp

 Everyone can read,write and access the directory.The t indicates that
only the user (root and owner of the directory,of course) that created
a file in this directory can delete that file.

 In order to set or to remove the sticky bit, use the following
commands:

$ chmod +t directory     or    $ chmod 1754 directory
$ chmod -t directory     or    $ chmod  754 directory

 Note: 754 permissions for a directory are powerful enough to guard
your directories from intruders with malicious intentions, that's why
I used 754 as default,if yow want you can change it.

Example: 

I logged in as king and created a temp file.

$ whoami
king
$ pwd
/home/project/
$ touch temp; ls -l
-rw-r--r-- 1 king  king           0 Mar 27 13:44 temp

Now logged in as venu and try to delete temp file.

$ whoami
venu
$ rm temp
rm: remove write-protected regular empty file `temp'? Y
$ ls temp
ls: temp: No such file or directory

So what happened? venu deleted file owned by king.

Assign sticky bit to the project directory.As a owner of the directory
or administrator.

# chmod +t /home/project
# ls -ld /home/project/
drwxrwxr-t 15 root development 4096 Mar 27 13:46 /home/project/

 From the ls output above, you know the sticky bit is set because of
the t in the third position of the other permission set,which replaces
the x in the other permissions.

Now repeat same steps again,then you get the following message:

$ whoami
venu
$ ls -l temp
-rw-r--r-- 1 king king 0 Mar 27 17:36 temp
$ rm temp
rm: remove write-protected regular empty file `temp'? y
rm: cannot remove `temp': Operation not permitted


Observation: Login as normal user and create a file.
[venu@localhost ~]$ touch sample
[venu@localhost ~]$ ls -l sample 
-rw-rw-r-- 1 venu venu 0 Dec 21 03:41 sample

Now change permissions to 644

[venu@localhost ~]$ chmod 644 sample 
[venu@localhost ~]$ ls -l sample 
-rw-r--r-- 1 venu venu 0 Dec 21 03:41 sample

Now assign SUID permission.

[venu@localhost ~]$ chmod u+s sample 
[venu@localhost ~]$ ls -l sample 
-rwSr--r-- 1 venu venu 0 Dec 21 03:41 sample

After setting SUID, if you see 'S' then it means that the file has no 
executable permissions for that user.

Now remove SUID permission and change permissions to 744. Then assign 
SUID permission. You should see a smaller 's' in the executable permi-
ssion position.

[venu@localhost ~]$ chmod u-s sample 
[venu@localhost ~]$ chmod 744 sample 
[venu@localhost ~]$ chmod u+s sample 
[venu@localhost ~]$ ls -l sample 
-rwsr--r-- 1 venu venu 0 Dec 21 03:41 sample

Same is applicable for SGID and Stickybit.

Linux File and Directory Permissions

2010-03-18T08:41:00.000-07:00


What are file permissions:

Every file or folder in Linux has access permissions. There are three
types of permissions (what allowed to do with a file):

read access (symbolized by the letter r)
write access (symbolized by the letter w)
execute access (symbolized by the letter x)

Permissions are defined for three types of users:

the owner of the file (symbolized by the letter u )
the group that the owner belongs to (symbolized by the letter g)
other users (symbolized by the letter o)

Thus, Linux file permissions are nine bits of information. The table
below shows the syntax:

1 2 3 4 5 6 7 8 9 10
File User Permissions Group Permissions Other Permissions
Type Read Write Execute Read Write Execute Read Write Execute
d r w e r w e r w e

- > The first character is not a permission bit, it simply indicates
    the type of file as indicated in the table below:

Character  Type of file
- regular file
d directory
l symbolic link
s socket
p named pipe
c character device file (unbuffered)
b blocked device file (buffered)

Remaining nine bits are permission bits.

-> Characters 2-4 show owner of the file permissions.
    Character 2 indicates read permission, character 3 indicates write
     permission, and character 4 indicates execute permission.
-> Characters 5-7 show group permissions(group to which belong the file).
     Character 5=read, 6=write, 7=execute .
-> Characters 8-10 show permissions for all other users. (users who are
  neither a member of the Group nor the owner of the file)
     Character 8=read, 9=write, 10=execute.

Ownership: When you create a file, you automatically become its
owner. The owner has full authority to tamper with a file's contents
and permissions –a privilege not available with others except the root
user.Similarly, You can create, modify  or remove files in a directory
if you are the owner of the directory.

Group Ownership: When creating a user account,the system admin-
istrator also assigns the user to some group. People working on a
project are generally assigned a common group, and all files created
by group members (who have separate user ids) will have the same group
owner. However, make no mistake : The privileges of the group are set
by the owner of the file and not by the group members.

ls -l   : Listing File Attributes

$ ls -l sample
-rwxr-xr-- 1 king development 0 Mar 15 00:26 sample

 ls -l displays most attributes of a file – like its permissions,size
and ownership details. If file is a directory,to list attributes of a
directory use “ls -ld”.

 As you can see in this example, the "ls -l" command gives a lot of
information about the file "sample":

     - Its name, "sample";
     - Its permissions, "-rwxr-xr--";
     - Its owner, "king";
     - Its group, "development";
     - And other information time,size,date etc..

Permissions: rwx r-x r--

  r   Read access is allowed
w Write access is allowed
    x Execute access is allowed    
  - No permissions


 The first group (rwx) has all three permissions.The file is readable,
writable and executable by the owner of the file,King. But do we Know
who the owner is? Yes we do. The third column shows king as the owner
and the first permissions group applies to king. You have to log in
with the username king for these privileges to apply to you.

 The second group (r-x) has a hyphen in the middle slot, which indica-
tes the absence of write permission by the group owner of the file.
This group owner is development, and all users belonging to the devel-
opment group have read and execute permissions only.

 The third group (r--) has the write and execute bits absent. This set
of permissions is applicable to others i.e., those who are neither the
owner king nor belong to the development group. So this file is not
world writable.

chmod: CHANGING FILE PERMISSIONS

  If you are owner of the file you can set different permissions for
the three categories of users --owner,group, and others.It's important
that you understand them because a little learning here can be a
dangerous thing.A faulty file permission is a sure recipe for disaster.

 The chmod (change mode) command is used to set the permissions of
one or more files for all three categories of users.It can be run only
by the user(the owner) and the superuser. The command can be used in
two ways:

     1.In a relative manner by specifying the changes to the current
       permissions.
     2.In an absolute manner by specifying the final permissions.

Relative Permissions: 

  When changing permissions in a relative manner, chmod only changes
the permissions specified in the command line and leaves the other
permissions unchanged. In this mode it uses the following syntax:

   chmod category operation permission filename(s).

  Bellow table shows letters to represent category, operation and
permission:
Category Operation Permission  
u   User +   Assigns permission r   Read Permission
g   Group -   Removes permission w   Write Permission
o   Other =   Assigns absolute permission x   Execute Permission
a   All(ugo) 

 Now let's consider an example. First create a file temp.

$ cat > temp
Hello world
Ctrl+d
$ ls -l temp
-rw-r--r-- 1 root root 12 Mar 16 13:32 temp

 To assign execute permissions to the User of the file temp, we need
to frame a suitable expression by using appropriate characters from
each of the three columns of above Table. Since the file needs to be
executable only by the user,the expression required is u+x:

$ chmod u+x temp
$ ls -l temp
-rwxr--r-- 1 root root 12 Mar 16 13:32 temp

  The command assigns(+) execute(x) permissions to the user(u), but
other permissions remain unchanged. To enable group and others to exe-
cute this file, you have to use multiple characters to represent the
user category(ugo) or simply use a it implies ugo.

$ chmod ugo+x temp
$ ls -l temp
-rwxr-xr-x 1 root root 12 Mar 16 13:32 temp

chmod command also accept more than one file name in the command line.
When you need to assign the same set of permissions to a group files,
all the file names have to be specified with a single chmod command:

$ chmod u+x temp1 temp2 temp3

 Permissions are removed with the - operator. To remove the read
permission from both group and others, use the expression go-r:

$ chmod go-r temp ; ls -l temp
-rwx--x--x 1 root root 12 Mar 16 13:32 temp

  chmod also accepts multiple expressions delimited by commas. For
instance, to restore the original permissions to the file temp,you
have to remove the execute permission from all(a-x) and assign read
permission to group and others(go+r):

$ chmod a-x,go+r temp; ls -l temp
-rw-r--r-- 1 root root 12 Mar 16 13:32 temp

 More than one permission can also be set; u+rwx is a valid chmod
expression.So setting write and execute permissions for others is no
problem:

$ chmod o+rwx temp; ls -l temp
-rw-r--rwx 1 root root 12 Mar 16 13:32 temp

Absolute Permissions:

    Some times you don't need to now what a file's current permissions
are,but want to set all nine permission bits explicitly.The expression
used by chmod here is a string of three octal numbers(base 8).Each type
of permission is assigned a number as shown :

       I. Read permission    - 4
      II. Write permission   - 2
     III. Execute permission - 1

     For each category we add the numbers that represent the assigned
permissions. For instance, 6 represents read and write permissions,and
7 represents all permissions.

This table shows what numeric values mean:

Octal digit Text equivalent Meaning   
0 ---     All types of access are denied   
1 --x  Execute access is allowed only   
2 -w-     Write access is allowed only   
3 -wx Write and execute access are allowed   
4 r-- Read access is allowed only   
5  r-x Read and execute access are allowed   
6 rw- Read and write access are allowed   
7 rwx  Everything is allowed   


   We see that "1" stands for execute only, "2" stands for write only,
"4" stands for read only.To combine the permissions you can simply add
1, 2 and 4 to get a needed combination. For instance, to get read and
write permissions,you add 4 (read) and 2 (write), thus getting 6 (read
and write). To get read and execute permissions, you add  4 (read) and
1 (execute), thus getting 5 (read and execute).

 To take a simple example,if a file has read and write permissions for
the user, the octal representation of the user's permissions will be
4 + 2 = 6. When this exercise is repeated for the other categories, the
result will be a three character string representing three octal digi-
ts, with each octal digit indicating the permissions for the category.
The sequence followed is user,group and others. You can use this method
to assign read and write permissions to all three categories.

Examples:

  To assign all permissions to the owner,read and write permissions to
the group,and only execute permission to the others, use this:

$ chmod 761 sample ; ls -l sample
-rwxrw---x 1 king development 0 Mar 15 00:26 sample

 Assign yourself full access to read and modify the file,allow members
of the group to read it and do not allow any others access:

$ chmod 640 sample ; ls -l sample
-rw-r----- 1 king development 0 Mar 15 00:26 sample

Some octal permissions and their meaning:

Permissions Meaning
644 owner: read and write permissions,
group: only read permissions,
others: only read permissions. 
755     owner: read, write and execute permissions,
group: read and execute permissions,
      others: read and execute permissions. 
754  owner: read, write and execute permissions,
 group: read and execute permissions,
others: only read permissions. 


  As long as you're the owner of a file, you can use the chmod command
to set the permissions any way you like.

umask: Default file and Directory permissions: 


  The UNIX system has the following default permissions for all files
and directories:

rw-rw-rw-(octal 666) for regular files.
rwxrwxrwx(octal 777) for directories.

  However,you don't see these permissions when you create a file or a
directory. To understand this let us first create an empty file called
sample using the touch command and then try to list it.

$ touch sample ; ls -l sample
-rw-r--r-- 1 king development 0 Mar 18 00:41 sample

 How come that the file permissions for this file have been set to 644
What Unix does is it uses the value stored in a variable called umask
to decide the default permissions. The umask value tells Unix which of
the three permissions are to be denied rather than granted.The current
value of umask can be easily determined by just typing umask.

# umask
0022  (Default umask value for admin is 0022)

$ umask
0002  (Default umask value for normal user is 0002)

 Here, the first 0 indicates that what follows is an octal number.This
octal number which has to be subtracted from the system default to ob-
tain the actual default. This becomes 664 (666-002) for ordinary files
and 775 (755-002) for directories.When you crate a file on this system
,it will have the permissions rw-rw-r--.

umask is a shell built-in command though it also exists as an external
command. A user can also use this command to set a new default. Here's
an extreme setting:

$ umask 000                           All read-write permissions on

  A umask value of 000 means that you haven't subtracted anything, and
this could be a dangerous. The system's default then applies (666 for
files and 777 for directories). All files and directories are then
writable by all;  nothing could be worse than that! However,  a mask
value of 666 or 777 doesn't make much sense either; you'll then be cr-
eating files and directories with no permissions.

   For instance, if you want all new directories to get permissions
rwxr-xr--- and files to get permissions rw-r----- by default(modes 750
and 640), you'll need to use a umask value which removes all rights to
other,and write permissions to the group : 027. The command to use is:

$ umask 027

 One important thing to remember is that,no one not even the administ
rator can turn on permissions not specified in the system wide default
settings. However you can always use chmod as and when required. The
system wide umask setting is placed in one of the machine's startup
scripts, and is automatically made available to all users.

Directory Permissions:


    Unix treats every thing as a file, directories too are treated by
Unix as files.A directory, as Unix perceives, is a file which contains
the names of the files present in the directory.Hence a read permission
on a directory allows the listing of the directory contents and
nothing else.

     Directories also have their own permissions and the significance
of these permissions differ from those of ordinary files. Read and
write access to an ordinary file are also influenced by the permissio-
ns of the directory housing them. It's possible that a file can't be
accessed even though it has read permission, and can be removed even
when it's is write protected.

Here are some typical permissions required on directories:

To understand permissions first create temp directory and create some
files in that directory.

$ mkdir temp
$ cd temp
$ touch a b
$ pwd
/home/project/temp
$ ls -l
total 8
-rw-r--r-- 1 king development 0 Mar 18 18:56 a
-rw-r--r-- 1 king development 0 Mar 18 18:56 b

-> Execute permission is required for a user to cd into a directory.

    change temp directory permissions to 400(Read only permission).
Then try to change directory, you won't be permitted.

$ chmod 400 temp
$ cd temp
cd: temp: Permission denied
$ ls temp
a  b 

->  Read permission is required for a user to use a command such as ls
to view the files contained in a directory.

$ chmod 300 temp
$ ls temp
ls: temp: Permission denied
$ cd temp
$ pwd
/home/project/temp

-> Execute-only permission allows a user to access the files in a
directory as long as the user knows the names of the files in the
directory, and the user is allowed to read the files.

$ chmod 100 temp
$ ls temp/
ls: temp/: Permission denied
$ cat temp/a
Hello world

-> Write permission allows the user to create, delete, or modify any
files or sub directories, even if the file or sub directory is owned by
another user.

Difference in access permissions for files and 
directories:


 Access permissions for files and folders mean different things from
the user standpoint. The table below shows the difference.

Access type File Directory         
 Read If the file contents can
 be read   If the directory listing can 
be obtained  
Write If user or process can 
write to the file
(change its contents) If user or process can change
directory contents somehow: create
new or delete existing files in the
directory or rename files.  
 Execute If the file can 
be executed If user or process can access the
directory, that is, go to it (make 
it to be the current working direc
tory)

Character	Type of file
-	regular file
d	directory
l	symbolic link
s	socket
p	named pipe
c	character device file (unbuffered)
b	blocked device file (buffered)

Category	Operation	Permission
u User	+ Assigns permission	r Read Permission
g Group	- Removes permission	w Write Permission
o Other	= Assigns absolute permission	x Execute Permission
a All(ugo)

Octal digit	Text equivalent	Meaning
0	`---`	All types of access are denied
1	`--x`	Execute access is allowed only
2	`-w-`	Write access is allowed only
3	`-wx`	Write and execute access are allowed
4	`r--`	Read access is allowed only
5	`r-x`	Read and execute access are allowed
6	`rw-`	Read and write access are allowed
7	`rwx`	Everything is allowed

Permissions	Meaning
644	owner: read and write permissions, group: only read permissions, others: only read permissions.
755	owner: read, write and execute permissions, group: read and execute permissions, others: read and execute permissions.
754	owner: read, write and execute permissions, group: read and execute permissions, others: only read permissions.

Access type	File	Directory
Read	If the file contents can be read	If the directory listing can be obtained
Write	If user or process can write to the file (change its contents)	If user or process can change directory contents somehow: create new or delete existing files in the directory or rename files.
Execute	If the file can be executed	If user or process can access the directory, that is, go to it (make it to be the current working direc tory)

Shell Script to Upload a File to the Remote FTP Server

2010-02-27T09:27:00.000-08:00


#!/bin/bash
# SCRIPT  : upload.sh
# USAGE   : ./upload.sh [-d remote directory path] -f "File-to-upload"
#           -d option is optional by default it takes servers home dir
#                               or
#           ./upload.sh "Filename-to-upload"
#
# PURPOSE : Upload file to remote ftp server.

############### DEFINE FUNCTIONS HERE ##############

Usage()
{
  echo "                     USAGE                                  "
  echo " $0 [-d \"Remote Directory Path\"] -f \"Filename-to-upload\""
  echo "-------------------------- or -----------------------------"
  echo " $0 Filename-to-upload"
  exit 1
}

################# ARGUMENTS CHECKING #################

while getopts d:f: choice
do
   case $choice in
   d) Dname=$OPTARG;;
   f) Fname=$OPTARG;;
   esac
done

[ $# -eq 1 ] && Fname=$1
[ -z $Dname ] && Dname="/"                  #change it to suit
[ -z $Fname ] && echo "Bad Arguments" && Usage

[ ! -e $Fname ] && echo "$0: $Fname  no such file" && exit 1

############### DEFINE VARIABLES HERE ################

Server="ftp.checksoftware.com"               #Remote ftp server.
Username="anonymous"                         #Remote ftp user name.
Password="venuk@gmail.com"                   #Remote ftp Password.

# change above to suit

############### MAIN PROGRAM STARTS HERE #############

# Remove comment lines within the here document before run the script

ftp -n $Server <<ServerEnd
user "$Username" "$Password"

# binary command Set the file transfer type to support binary file
# transfer.So you can transfer all type of files.

binary

# hash command is used for printing hash-sign("#") for each data block
# transferred. The size of data block is system dependent.In my box it
# is 1024 bytes. hash command is a toggle switch, by default it is set
# off most systems.

hash                           # comment it if you don't need it

cd $Dname

# pwd command prints current directory on the remote host. This shows
# your file is uploading to which directory.

pwd                            # comment it if you don't need it

put "$Fname"
bye
ServerEnd

exit 0

OUTPUT:


[root@www ~]# ./upload.sh 
Bad Arguments
                     USAGE                                  
 ./upload.sh [-d "Remote Directory Path"] -f "Filename-to-upload"
-------------------------- or -----------------------------
 ./upload.sh Filename-to-upload
[root@www ~]# ./upload.sh -f samplepic.jpg -d /incoming
Hash mark printing on (1024 bytes/hash mark).
257 "/incoming" is current directory.
###############################################
[root@www ~]# ./upload.sh samplepic.jpg 
Hash mark printing on (1024 bytes/hash mark).
257 "/" is current directory.
samplepic.jpg: Permission denied

Shell Colors: colorizing shell scripts

2010-01-01T02:17:00.000-08:00


      Shell scripts commonly used ANSI escape codes for color output.
Following table shows Numbers representing colors in Escape Sequences.













Color Foreground Background
Black   30  40
Red  31  41
Green   32  42
Yellow   33  43
Blue   34  44
Magenta   35  45
Cyan   36  46
White   37  47
 The numbers in the above table work for xterm terminal.Result may vary
for other terminal emulators.

Use the following template for writing colored text.

echo -e "\033[COLORm Sample text"

The "\033[" begins the escape sequence.You can also use "\e[" instead
of "\033[". COLOR specifies a foreground color, according to the table
above.The "m" terminates escape sequence, and text begins immediately
after that.

Note: With an echo, the -e option enables the escape sequences.You can
also use printf instead of echo.


printf "\e[COLORm sample text\n"

To print Green text

echo -e "\033[32m Hello World"
             or
printf "\e[32m Hello World"

The problem with above statement is that the blue color that starts
with the 32 color code is never switched back to the regular color, so
any text you type after the prompt and even prompt also is still in the
Green color.

To return to the plain, normal mode, we have yet another sequence.

echo -e "\033[0m"

Now you won't see anything new on the screen, as this echo statement
was not passed any string to display. But it has done its job, which
was to restore the normal viewing mode. Whatever yor type now will be
avoid of any fancy effects.

Escape sequence also allow you to control the manner in which 
characters are displayed on the screen.

The following table summarizes numbers representing text attributes
in Escape Sequences.













ANSI CODE Meaning
0 Normal Characters
1 Bold Characters
4 Underlined Characters
5 Blinking Characters
7 Reverse video Characters

Note: Blink attribute doesn't work in any terminal emulator, but it
will work on the console.


Combining all these Escape Sequences, you can get more fancy effect.
Use the following template for writing colored text on a colored
background.

echo -e "\033[COLOR1;COLOR2m sample text\033[0m"

The semicolon separated numbers "COLOR1" and "COLOR2" specify a
foreground and a background color.The order of the numbers does not
matter, since the foreground and background numbers fall in non-
overlapping ranges."m" terminates the escape sequence, and the text
begins immediately after that.Although setting the colors separately
also work (i.e. \033[44m\033[32m).

There are some differences between colors when combining colors with
bold text attribute.

The following table summarises these differences.














Bold off color Bold on color
0;30 Balck 1;30 Dark Gray
0;31 Red 1;31 Dark Red
0;32 Green 1;32 Dark Green
0;33 Brown 1;33 Yellow
0;34 Blue 1;34 Dark Blue
0;35 Magenta 1;35 Dark Magenta
0;36 Cyan 1;30 Dark Cyan
0;37 Light Gray 1;30 White

The following shell script prints all the colors and codes on the
screen.

#!/bin/bash
# This script echoes colors and codes

echo -e "\n\033[4;31mLight Colors\033[0m  \t\t\033[1;4;31mDark Colors\033[0m"

echo -e "\e[0;30;47m Black    \e[0m 0;30m \t\e[1;30;40m Dark Gray  \e[0m 1;30m"
echo -e "\e[0;31;47m Red      \e[0m 0;31m \t\e[1;31;40m Dark Red   \e[0m 1;31m"
echo -e "\e[0;32;47m Green    \e[0m 0;32m \t\e[1;32;40m Dark Green \e[0m 1;32m"
echo -e "\e[0;33;47m Brown    \e[0m 0;33m \t\e[1;33;40m Yellow     \e[0m 1;33m"
echo -e "\e[0;34;47m Blue     \e[0m 0;34m \t\e[1;34;40m Dark Blue  \e[0m 1;34m"
echo -e "\e[0;35;47m Magenta  \e[0m 0;35m \t\e[1;35;40m DarkMagenta\e[0m 1;35m"
echo -e "\e[0;36;47m Cyan     \e[0m 0;36m \t\e[1;36;40m Dark Cyan  \e[0m 1;36m"
echo -e "\e[0;37;47m LightGray\e[0m 0;37m \t\e[1;37;40m White      \e[0m 1;37m"

OUTPUT:


Some examples:

Block background and white text

echo -e "\033[40;37m Hello World\033[0m"

Reverse video text attribute option interchanges fg and bg colors.
Bellow statement prints block on white

echo -e "\033[40;37;7m Hello World\033[0m"

echo -e "\033[33;44m Yellow text on blue background\033[0m"
echo -e "\033[1;33;44m Bold yellow text on blue background\033[0m"
echo -e "\033[1;4;33;44mBold yellow underlined text on blue background\033[0m"

The "tput" command:

         Other than echo there is a command called tput using which we
can control the way the output is displayed on the screen.But it is
less flexible than ANSI escape sequences.

Color	Foreground	Background
Black	30	40
Red	31	41
Green	32	42
Yellow	33	43
Blue	34	44
Magenta	35	45
Cyan	36	46
White	37	47

ANSI CODE	Meaning
0	Normal Characters
1	Bold Characters
4	Underlined Characters
5	Blinking Characters
7	Reverse video Characters

Bold off	color	Bold on	color
0;30	Balck	1;30	Dark Gray
0;31	Red	1;31	Dark Red
0;32	Green	1;32	Dark Green
0;33	Brown	1;33	Yellow
0;34	Blue	1;34	Dark Blue
0;35	Magenta	1;35	Dark Magenta
0;36	Cyan	1;30	Dark Cyan
0;37	Light Gray	1;30	White

Copy Progress Bar Shell Script V2

2009-12-28T22:46:00.000-08:00

This is the upgrade version of the ddcopy_progress.sh script posted on 2nd November.


#!/bin/bash
#
# SCRIPT:  ddcopy.sh
# PURPOSE: Copies files and shows the progress of copying.
#
#............................USAGE...........................
# This script copies only files not directories
# ddcopy <Source filename or Path>  <Destination filename or Path>
# ddcopy <Source filename or Path>  <Destination Directory or Path>


##################################################################
#                  Arguments Checking                            #
##################################################################

if [ $# -eq 0 ]           # Look for parameters supplied or not
then
    echo "$0: missing file operand"
    exit 1
fi

if [ $# -eq 1 ]           # Look for exactly one parameter
then
    echo  "$0 : missing destination file operand after '$1'"
    exit 1
fi

if [ $# -eq 2 ]
then
  Source="$1"
  Dest="$2"
  if [ ! -e "$1" ]           # Check source file exist or not
  then
      echo "$0: cannot stat '$1': No such file or directory"
      exit 1
  elif [ -d "$1" ]
  then
      echo "$0: Source file '$1' is a directory"
      exit 1
  fi

   egrep -q "^\/|\/$" <<<$2

   if [ $? -eq 0 -a ! -d $2 ]
   then
       echo "$0: cannot create regular file '$2' : Is a directory"
       exit 1
   fi

   if [ -d "$2" ]
   then
  filename=`basename "$1"`
  $(egrep -q "\/$" <<<$2) && Dest="$2$filename" || Dest="$2/$filename"
   fi

   if [ -e "$Dest" -a -f "$Dest" ]
   then
      echo -n "$0: $Dest already exist : overwrite '$Dest' (y/n)?  "
      read answer
      if [ "$answer" = "n" -o "$answer" = "N" ]
      then
          exit 1
      fi
   fi
fi

###################################################################
#               DEFINE VARIABLES HERE                             #
###################################################################

Seek=0               # skip BLOCKS bs-sized blocks at start of output
Skip=0               # skip BLOCKS bs-sized blocks at start of input
Bsize=128000         # block size
size=`stat -c %s "$Source"`

# Bellow 25MB files copied directly with copy command
# If you want progress bar for < 25MB files also, remove bellow
# if block

if [ $size -lt 25000000 ]
then
    cp "$Source" "$Dest"
    exit 0
fi

blocks=$((size/Bsize))      # total blocks of input file

lastblock=$((size%Bsize))   # last block,  which size  < $Bsize

# If last block size is > 0 then add 1 block to existing blocks.

if [ $lastblock -gt 0 ]
then
    let blocks++
fi

# I am dividing screen width 60 as 20 parts.Each part is filled
# with a colour after each iteration.

# Make blocks count dividable by 20.

addblocks=$((blocks%20))
if [ $addblocks -gt 0 ]
then
   adjustblocks=$((20-addblocks))
   blocks=$((blocks+adjustblocks))
fi

Count=$((blocks/20))

# Count variable contain number of blocks to be copied for
# each iteration

###################################################################
#            MAIN PROGRAM STARTS HERE                             #
###################################################################

printf "\e[40m\e[43m%60s\n\e[A" " "

for ((i=1;i<=20;i++))
do

  dd if="$Source" of="$Dest" bs=128kB seek=$Seek skip=$Skip \
  count=$Count 2>/dev/null

   Skip=$((Skip+$Count))
   Seek=$((Seek+$Count))
   j=$((j+3))                     # 60/20 each part is 3 chars length

   printf "\e[40m\e[7m%${j}s\n\e[A" " "
#  echo -e "\033[7m   \c"

done
printf "\e[0m\n"
#echo -e "\033[0m"

OUTPUT:
Screen Shot1:

Screen Shot2:

Screen Shot3:

Linux Baby Rocker

2009-11-24T14:20:00.000-08:00

Hello friends,
I have watched this video on Youtube.I hope you will also enjoy it.

Original link for this video is http://www.youtube.com/watch?v=bYcF_xX2DE8

Shell Script To Produce Prime Numbers Within A Range

2009-11-17T11:58:00.000-08:00


#!/bin/bash
# SCRIPT: primenumbers.sh
# USAGE : ./primenumbers.sh <Range Value>
#                      or;
#         ./ primenumbers.sh <Start Range Value> <End Range Value>
# PURPOSE: Produce prime numbers within a range lmit.

############### DEFINE FUNCTIONS HERE ##############

Usage()
{
    echo "********BAD ARGUMENTS**********"
    echo "Usage: scriptname <Range Value >"
    echo "               or                   "
    echo "Usage: scriptname <Start Range Value> <End Range Value>"
    exit 1
}

################# ARGUMENTS CHECKING #################

[ $# -gt 2 -o $# -lt 1 ] && Usage
[ $# -eq 1 ] && Bnum=2 &&  Enum=$1
[ $# -eq 2 ] && Bnum=$1  Enum=$2 && [ $1 -gt $2 ] && Usage
[ $1 -lt 2 ] && Bnum=2

############### MAIN PROGRAM STARTS HERE #############

count=1

while [ $Bnum -le $Enum ]
do
num=$Bnum
Prime="yes"
i=1

#while [ $i -lt $((num/2)) ]
while [ $((i*i)) -lt $((num-1)) ]
do
  let i++
  if [ $((num%i)) -eq 0 ]          # you can also use `expr $num % $i`
  then
      Prime="no"
      break
  fi
done

[ "$Prime" = "yes" ] && printf "%5d " $num && let count++

# count is used to print 10 values in a row

[ $count -eq 11 ] && count=1 &&  echo
let Bnum++
done
echo

OUTPUT:


$ ./primenumbers.sh 1 350
    2     3     5     7    11    13    17    19    23    29 
   31    37    41    43    47    53    59    61    67    71 
   73    79    83    89    97   101   103   107   109   113 
  127   131   137   139   149   151   157   163   167   173 
  179   181   191   193   197   199   211   223   227   229 
  233   239   241   251   257   263   269   271   277   281 
  283   293   307   311   313   317   331   337   347   349 

$ ./primenumbers.sh 1900 2500
 1901  1907  1913  1931  1933  1949  1951  1973  1979  1987 
 1993  1997  1999  2003  2011  2017  2027  2029  2039  2053 
 2063  2069  2081  2083  2087  2089  2099  2111  2113  2129 
 2131  2137  2141  2143  2153  2161  2179  2203  2207  2213 
 2221  2237  2239  2243  2251  2267  2269  2273  2281  2287 
 2293  2297  2309  2311  2333  2339  2341  2347  2351  2357 
 2371  2377  2381  2383  2389  2393  2399  2411  2417  2423 
 2437  2441  2447  2459  2467  2473  2477 

$ ./primenumbers.sh 200
    2     3     5     7    11    13    17    19    23    29 
   31    37    41    43    47    53    59    61    67    71 
   73    79    83    89    97   101   103   107   109   113 
  127   131   137   139   149   151   157   163   167   173 
  179   181   191   193   197   199 

[root@localhost shell]# ./primenumbers.sh 200 100
********BAD ARGUMENTS**********
Usage: scriptname <Range Value>
               or                   
Usage: scriptname <Start Range Value> <End Range Value>

NOTE:
this script can't find the highest prime number,but it can figure out the highest prime number your system is capable of calculating.

Shell Script to Find Prime Number

2009-11-17T08:46:00.000-08:00

Reposted on 18-06-2011 and Method 4 was deleted.

The simplest primality test is as follows: Given an input number n,
check whether any integer m from 2 to n − 1 divides n. If n is divisi-
ble by any m then n is composite, otherwise it is prime.

Method 1:

Now most people who write finding  prime number in shell script(Almost
in all languages) may start with something simple, like:

#!/bin/bash
# SCRIPT: prime1.sh
# USAGE : ./prime1.sh
# PURPOSE: Finds whether given number is prime or not
#####################################################################

echo -n "Enter a number: "
read num
i=2

while [ $i -lt $num ]
do
  if [ `expr $num % $i` -eq 0 ]
  then
      echo "$num is not a prime number"
      echo "Since it is divisible by $i"
      exit
  fi
  i=`expr $i + 1`
done

echo "$num is a prime number "

Output:
[root@venu ]# ./prime1.sh
Enter a number: 1879
1879 is a prime number
[root@venu ]# ./prime1.sh
Enter a number: 119
119 is not a prime number
Since it is divisible by 7

Using here string you can supply input non interactively.

[root@venu ]# ./prime1.sh  <<<2239
Enter a number: 2239 is a prime number

 However, rather than testing all m up to n−1, it is only necessary to
test m up to sqrt n: if n is composite then it can be factored into
two values,at least one of which must be less than or equal to sqrt n.

 Don't use method 1, it is very worst method, I hope that you will
agree with me at the end of this post.

Method 2a:

#!/bin/bash
# SCRIPT: prime2a.sh
# USAGE : ./prime2a.sh
# PURPOSE: Finds whether given number is prime or not
#####################################################################

echo -n "Enter a number: "
read num

#####################################################################
#                       Integer Validation                          #
#####################################################################

# If you are a  beginner you can skip this integer validation block.

expr $num + 1  &> /dev/null

if [ $? -ne 0 ]
then
    echo "Sorry, You supplied non numerical value"
    exit 1
fi

[ $num -lt 2 ] && echo "Values < 2 are not prime numbers" && exit 1

#####################################################################
#                Main Script Starts Here                            #
#####################################################################

i=2
sqrtofnum=`echo "sqrt($num)"|bc`

while [ $i -le $sqrtofnum ]
do
  if [ `expr $num % $i` -eq 0 ]
  then
      echo "$num is not a prime number"
      echo "Since it is divisible by $i"
      exit
  fi
  let i++
done

echo "$num is a prime number "

Output:
[root@venu ]# ./prime2a.sh <<<169
Enter a number: 169 is not a prime number
Since it is divisible by 13
[root@venu ]# ./prime2a.sh <<<3181
Enter a number: 3181 is a prime number

Here is same method without using bc command:


Method 2b:

#!/bin/bash
# SCRIPT: prime2b.sh
# USAGE : ./prime2b.sh
# PURPOSE: Finds whether given number is prime or not
#####################################################################

echo -n "Enter a number: "
read num

#####################################################################
#                 Integer Validation                                #
#####################################################################

# If you are a beginner you can skip integer validation block.

expr $num + 1  &> /dev/null

if [ $? -ne 0 ]
then
    echo "Sorry, You supplied non numerical value"
    exit 1
fi

[ $num -lt 2 ] && echo "Values < 2 are not prime numbers" && exit 1

#####################################################################
#                Main Script Starts Here                            #
#####################################################################

i=1
newnum=$((num-1))

while [ $((i*i)) -lt $newnum ]
do
  let i++
  if [ `expr $num % $i` -eq 0 ]
  then
      echo "$num is not a prime number"
      echo "Since it is divisible by $i"
      exit
  fi
done

echo "$num is a prime number "

Output:
[root@venu ]# ./prime2b.sh <<<361
Enter a number: 361 is not a prime number
Since it is divisible by 19
[root@venu ]# ./prime2b.sh <<<3571
Enter a number: 3571 is a prime number

Method 3a:

#!/bin/bash
# SCRIPT: prime3a.sh < Number to check >
# USAGE : ./prime3a.sh
# PURPOSE: Finds whether a given number is prime or not.

#####################################################################
#                       ARGUMENTS CHECKING                          #
#####################################################################

# If you are a beginner you can skip Arguments checking part.

if [ $# -ne 1 ]
then
    echo "Usage: scriptname <number to check>"
    exit 1
fi

expr $1 + 1  &> /dev/null

if [ $? -ne 0 ]
then
    echo "Sorry, You supplied non numerical value"
    exit 1
fi

[ $1 -lt 2 ] && echo "Values < 2 are not prime numbers" && exit 1

#####################################################################
#                   MAIN PROGRAM STARTS HERE                        #
#####################################################################

num=$1
sqrtofnum=`echo "sqrt($num)" | bc `
i=2

while [ $i -le $sqrtofnum ]
do
  if [ $(((num/i)*i)) -eq $num ]
  then
      echo "$num is not a prime number"
      echo "Since it is divisible by $i"
      exit 0
  fi

  let i++           # you can also use i=`expr $i + 1`
done

echo "$num is a prime number"

Output:
[root@venu ]# ./prime3a.sh 529
529 is not a prime number
Since it is divisible by 23
[root@venu ]# ./prime3a.sh 3571
3571 is a prime number

Here is same method without using bc command:


Method 3b:

#!/bin/bash
# SCRIPT: prime3b.sh
# USAGE : ./prime3b.sh <Number to check >
# PURPOSE: Finds whether a given number is prime or not.

#####################################################################
#                       ARGUMENTS CHECKING                          #
#####################################################################

# If you are a beginner you can skip Arguments checking part.

if [ $# -ne 1 ]
then
    echo "Usage: scriptname <number to check>"
    exit 1
fi

expr $1 + 1  &> /dev/null
if [ $? -ne 0 ]
then
    echo "Sorry, You supplied non numerical value"
    exit 1
fi

[ $1 -lt 2 ] && echo "Values < 2 are not prime numbers" && exit 1

#####################################################################
#                   MAIN PROGRAM STARTS HERE                        #
#####################################################################

num=$1
newnum=$((num-1))
i=1

while [ $((i*i)) -lt $newnum ]
do

  let i++           # you can also use i=`expr $i + 1`

  if [ $(((num/i)*i)) -eq $num ]
  then
      echo "$num is not a prime number"
      echo "Since it is divisible by $i"
      exit 0
  fi

done

echo "$num is a prime number"

Output:
[root@venu ]# ./prime3b.sh 12009
12009 is not a prime number
Since it is divisible by 3
[root@venu ]# ./prime3b.sh 16127
16127 is a prime number

Now using time command to test which script runs fast.

OUTPUT 1:
[root@venu ]# time sh prime1.sh <<<99991
Enter a number: 99991 is a prime number

real    5m6.590s
user    1m13.882s
sys     3m29.807s
[root@venu ]# time sh prime2a.sh <<<99991
Enter a number: 99991 is a prime number

real    0m0.558s
user    0m0.159s
sys     0m0.409s
[root@venu ]# time sh prime2b.sh <<<99991
Enter a number: 99991 is a prime number

real    0m0.534s
user    0m0.141s
sys     0m0.405s
[root@venu ]# time sh prime3a.sh 99991
99991 is a prime number

real    0m0.037s
user    0m0.034s
sys     0m0.003s
[root@venu ]# time sh prime3b.sh 99991
99991 is a prime number

real    0m0.041s
user    0m0.034s
sys     0m0.007s

OUTPUT 2:
[root@venu ]# time sh prime1.sh <<<319993
Enter a number: 319993 is a prime number

real    16m44.993s
user    4m3.943s
sys     12m17.365s
[root@venu ]# time sh prime2a.sh <<<319993
Enter a number: 319993 is a prime number

real    0m0.883s
user    0m0.218s
sys     0m0.529s
[root@venu ]# time sh prime2b.sh <<<319993
Enter a number: 319993 is a prime number

real    0m0.739s
user    0m0.238s
sys     0m0.494s
[root@venu ]# time sh prime3a.sh 319993
319993 is a prime number

real    0m0.072s
user    0m0.054s
sys     0m0.007s
[root@venu ]# time sh prime3b.sh 319993
319993 is a prime number

real    0m0.089s
user    0m0.061s
sys     0m0.008s

I hope, now you understood, Just one line of code makes the difference.
Method 1 takes more and more time to find prime number.

How to Pass Arguments to Shell Script

2009-11-15T01:19:00.000-08:00


Like UNIX commands, shell scripts also accept arguments from the command line.
They can, therefore, run non interactively and be used with redirection and
pipelines.

Positional Parameters:

Arguments are passed from the command line into a shell program using the
positional parameters $1 through to $9. Each parameter corresponds to the
position of the argument on the command line.

The first argument is read by the shell into the parameter $1, The second
argument into $2, and so on. After $9, the arguments must be enclosed in
brackets, for example, ${10}, ${11}, ${12}.Some shells doesn't support this
method. In that case, to refer to parameters with numbers greater than 9, use
the shift command; this shifts the parameter list to the left. $1 is lost,while
$2 becomes $1, $3 becomes $2, and so on. The inaccessible tenth parameter
becomes $9 and can then be referred to.

Example:

#!/bin/bash
# Call this script with at least 3 parameters, for example
# sh scriptname 1 2 3

echo "first parameter is $1"

echo "Second parameter is $2"

echo "Third parameter is $3"

exit 0

Output:
[root@localhost ~]# sh parameters.sh 47 9 34

first parameter is 47

Second parameter is 9

Third parameter is 34

[root@localhost ~]# sh parameters.sh 4 8 3

first parameter is 4

Second parameter is 8

Third parameter is 3


 In addition to these positional parameters, there are a few other special
parameters used by shell.Their significance is noted bellow.

$* - It stores the complete set of positional parameters as a single string.
$@ - Same as $*, But there is subtle difference when enclosed in double quotes.
$# - It is set to the number of arguments specified.This lets you design scripts
     that check whether the right number of arguments have been entered.
$0 - Refers to the name of the script itself.

Setting Values of Positional Parameters

You can't technically call positional parameters as shell variables because all
variable names start with a letter. For instance you can't assign values to $1,
$2.. etc. $1=100 or $2=venu is simply not done. There is one more way to assign
values to the positional parameters, using the set command.

$ set Helping hands are holier than praying lips

The above command sets the value $1 with “Helping” , $2 with “hands” and so on.
To verify, use echo statement to display their values.

$ echo $1 $2 $3 $4 $5 $6 $7

Helping hands are holier than praying lips

You can simply use $* or $@

$ echo $*

Helping hands are holier than praying lips

$ echo $@

Helping hands are holier than praying lips

Using Shift on Positional Parameters

We have used set command to set upto 9 words. But we can use it for more.

$ set A friend who helps when one is in trouble is a real friend

$ echo $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11

A friend who helps when one is in trouble A0 A1


Observe that last two words in the output. These occurred in the output because
at a time we can access only 9 positional parameters. When we tried to refer to
$10 it was interpreted by the shell as if you wanted to out put the value of $1
and a 0. Hence we got A0 in the output.
Does that mean the words following the ninth word have been lost? No. If not,
then where have they gone?. They are very much there, safe with the shell But to
reach them we must do the following.

$shift 4

$ echo $1 $2 $3 $4 $5 $6 $7 $8 $9

when one is in trouble is a real friend


Now where have the first seven words gone? They have been shifted out.The first
four words lost for ever, as we did not take the precaution to store them else-
where. What should we have done is:

$ set A friend who helps when one is in trouble is a real friend

$ a=$1

$ b=$2

$ c=$3

$ d=$4

$ shift 4

$ echo $a $b $c $d $1 $2 $3 $4 $5 $6 $7 $8 $9

A friend who helps when one is in trouble is a real friend


Note:In the Korn  and bash shells you can refer directly to arguments where
n is greater than 9 using braces. For example, to refer to the 57th positional
parameter, use the notation ${57}.some shells may not support this method.


$ set A friend who helps when one is in trouble is a real friend

$ echo ${12}

real

$ echo ${13}

friend


   Bracket notation for positional parameters leads to a fairly simple way of
referencing the last argument passed to a script on the command line.

$ echo ${!#}

friend


$* and $@

Let us look at the subtle difference between $* and $@.

First create three files  fileA, fileB, “file temp”
cat > fileA
I LOVE INDIA
Ctrl+d

cat > fileB
HELLO WORLD
Ctrl+d

cat > temp\ file
This file name contains blank space
Ctrl+d

Example: 

#!/bin/bash
# Usage: sh arguments.sh fileA fileB temp\ file

echo -e "\033[1mDisplay files content using \$* \033[0m"

cat $*

echo -e "\033[1mDisplay files content using \$@ \033[0m"

cat $@

exit 0

Run the script with file names as arguments.

Output:
[root@localhost ~]# sh arguments.sh fileA fileB temp\ file
Display files content using $* 
I LOVE INDIA
HELLO WORLD
cat: temp: No such file or directory
cat: file: No such file or directory
Display files content  using $@ 
I LOVE INDIA
HELLO WORLD
cat: temp: No such file or directory
cat: file: No such file or directory

So there is no difference between cat $* and cat $@.

Modify arguments.sh script as

#!/bin/bash
# Usage: sh arguments.sh fileA fileB temp\ file

echo -e "\033[1mDisplay files content using \"\$*\" \033[0m"

cat "$*"

echo -e "\033[1mDisplay files content  using \"\$@\" \033[0m"

cat "$@"

exit 0

Now again run the script with file names as arguments.

Output:
[root@localhost ~]# sh arguments.sh fileA fileB temp\ file 
Display files content using "$*" 
cat: fileA fileB temp file: No such file or directory
Display files content  using "$@" 
I LOVE INDIA
HELLO WORLD
This file name contain blank space

Now there is a difference, the two cat commands would become:

   cat “fileA fileB temp file”
   cat fileA fileB 'temp file'

 On execution, the first of these commands would give an error since there does
not exist a file with the name “fileA fileB temp file”. As against this, the
second cat command would display the contents of the files fileA, fileB and
“temp file”. So what you observed ,when not enclosed within "double quotes"
$* and $@ behaves exactly similarly, and when enclosed in "double quotes" there
is a subtle difference.

Shell Script to Check Whether Given Year is a Leap Year or Not?

2009-11-12T01:17:00.000-08:00

Method 1:
#!/bin/bash
#
#  SCRIPT : leapyear.sh
#  PURPOSE: Checks whether given year is a leap year or not
#  USAGE  : sh leapyear.sh  
#           If Year value not supplied, it takes current year as default
#
# This script based on, One year has the length of 365 days, 5 hours,
# 48 minutes and 47 seconds. Because this is rather non-functional,
# a normal year has been given 365 days and a leap year 366 days.

#####################################################
############### DEFINE FUNCTIONS HERE ####################
#####################################################

Leap()
{
#  This function tells you if the argument is a leap year or not...

YEAR=$1
NO_OF_DAYS=$(cal $YEAR |egrep "^[ 0-9][0-9]| [ 0-9][0-9]$" |wc -w)

# A single parameter to cal specifies the year (1 - 9999) to be displayed;
# note the year must be fully specified: “cal 89” will not display a calendar
# for 1989.

# Use egrep or grep -E both are same

# cal command pipes total months and dates to egrep, egrep remove all lines
# not starting with number or ending with number, then pipes remaining lines
# to wc command. wc command counts total number of words(days).

if [[ $NO_OF_DAYS -eq 365 ]]
then
       echo "$YEAR Is Not A Leap Year "
else
       echo "$YEAR Is A Leap Year"
fi

}

#####################################################
############### MAIN PROGRAM STARTS HERE #################
#####################################################

Year=${1:-$(date +%Y)}
if [ $Year -lt 1 -o $Year -gt 9999 ]
then
    echo "Illegal Year Value: Use 1-9999"
    exit 1
fi

Leap $Year

Method 2:
#!/bin/bash
#
#  SCRIPT : leapyear.sh
#  PURPOSE: Checks whether given year is a leap year or not
#  USAGE  : sh leapyear.sh  
#           If Year value not supplied, it takes current year as default
#
#  This script based on,A leap year comes every 4 years,
#  but not every 100 years, then again every 400 years.


#####################################################
############### ARGUMENTS CHECKING #####################
#####################################################

YEAR=${1:-`date +%Y`}

if [ $YEAR -lt 1 -o $YEAR -gt 9999 ]
then
     echo "Illegal Year Value: Use 1-9999"
     exit 1
fi

#####################################################
############### DECLARE VARIABLES HERE ###################
#####################################################

rem1=$((YEAR%4))
rem2=$((YEAR%100))
rem3=$((YEAR%400))

#####################################################
############## MAIN PROGRAM STARTS HERE ##################
#####################################################

if [ ${rem3} = "0" ]
then
       echo "$YEAR Is A Leap Year"
       exit
fi

if [ ${rem2} = "0" -a ${rem3} != "0" ]
then
       echo "$YEAR Is Not A Leap Year"
       exit
fi

if [ ${rem1} = "0" -a ${rem2} != "0" ]
then
       echo "$YEAR Is A Leap Year"
else
       echo "$YEAR Is Not A Leap Year"
fi

OUTPUT:

[root@localhost shell]# ./leapyear.sh
2009 Is Not A Leap Year
[root@localhost shell]# ./leapyear.sh 2100
2100 Is Not A Leap Year
[root@localhost shell]# ./leapyear.sh 2104
2104 Is A Leap Year
[root@localhost shell]# ./leapyear.sh 21000
Illegal Year Value: Use 1-9999
[root@localhost shell]# ./leapyear.sh 1996
1996 Is A Leap Year

Copy Progress Bar Shell Script

2009-11-02T04:21:00.000-08:00

This script not replaces cp command. This is a sample script for practice purpose.
I am going to develop more elegant script, which fulfil most of the cp command strengths.
I will post complete version of the script as soon as possible,
I shall really appreciate all comments and suggestions to improve this script.


#!/bin/bash
#
# SCRIPT:  ddcopy_progress.sh
# PURPOSE: This script is used to watch progress of copying.
#
# Note:   I am using destination file as $$.temp .This is because,
#         after testing you can easily delete temp files using
#         rm -f *.temp

#############################################
#                    Arguments Checking                                                   #
#############################################

if [ $# -ne 1 ]            # Look for exactly one parameter
then
    echo "..............Usage Error........."
    echo  "Usage: $0 Sourcefil"
    exit 1
fi

if [ ! -e $1 ]             # Check source file exist or not
then
    echo "File $1 not exist"
    exit 1
fi

#############################################
#                DEFINE VARIABLES HERE                                                #
#############################################

Seek=0                      # Skip BLOCKS bs-sized blocks at start of output
Skip=0                      # Skip BLOCKS bs-sized blocks at start of input
Bsize=128000                # Block size
size=`stat -c %s $1`
blocks=$((size/Bsize))      # Total blocks of input file

lastblock=$((size%Bsize))   # Last block,  which size  < $Bsize

# If last block size is > 0 then add 1 block to existing blocks.

if [ $lastblock -gt 0 ]
then
    let blocks++
fi

# I am dividing screen width 60 as 20 parts.Each part is filled with color
# after each iteration.

# Make blocks count dividable by 20.

addblocks=$((blocks%20))
if [ $addblocks -gt 0 ]
then
   adjustblocks=$((20-addblocks))
   blocks=$((blocks+adjustblocks))
fi

Count=$((blocks/20))

# Count variable contain number of blocks to be copied for each iteration

###############################################
#              MAIN PROGRAM STARTS HERE                                              #
###############################################

printf "\e[40m\e[43m%60s\n\e[A" " "

for ((i=1;i<=20;i++))
do

   dd if=$1 of=$$.temp bs=128kB seek=$Seek skip=$Skip count=$Count 2>/dev/null
   Skip=$((Skip+$Count))
   Seek=$((Seek+$Count))
   j=$((j+3))                       # 60/20 each part is 3 chars length
   printf "\e[40m\e[7m%${j}s\n\e[A" " "
#  echo -e "\033[7m   \c"
#  sleep 1                          # Uncomment it for small files

done
printf "\e[0m\n"
#echo -e "\033[0m"

Output:
Screen Shot1:

Screen Shot2:

Screen Shot3:

Screen Shot4:

Observation:
I tested above script with different block count.But I didn't get accurate result.
Some times less count script given good result, some times more block count given
good result.
I copied 1.8 GB Movie file with this script.With time command it has give bellow
result.

real 1m12.646s
user 0m0.043s
sys 0m7.854s

From my observation this script has taken less time compared with mouse copy and
paste method. Copy and paste has taken 1m14.02s averagely.

Shell Script to Create a File with Specified Number of Lines

2009-11-01T11:56:00.000-08:00


#!/bin/bash
#
# SCRIPT:  bigfile.sh
# PURPOSE: This script is used to create a text file that
#          has a specified number of lines that is specified
#          on the command line.
#

usage()
{
echo "............USAGE ERROR............"
echo "USAGE: $0 <number_of_lines_to_create>"
}

# Argument Checking

if [ $# -ne 1 ]             # Looking for exactly one parameter
then
     usage                    # Usage error was made
     exit 1                    # Exit on a usage error
fi

# Define files and variables here

LINE_LENGTH=80              # Number of characters per line
OUT_FILE=bigfile.$$          # New file to create
>$OUT_FILE                       # Initialize to a zero-sized file
TOTAL_LINES=$1               # Total number of lines to create
LINE_COUNT=0                 # Character counter
CHAR=X                             # Character to write to the file

#   Beginning of Main

while ((LINE_COUNT < TOTAL_LINES))          
do
     CHAR_COUNT=0        # Initialize the CHAR_COUNT to zero on every new line

     while ((CHAR_COUNT < LINE_LENGTH))     # Each line is fixed length
     do
          echo -e "$CHAR\c" >> $OUT_FILE      # Echo a single character
          let CHAR_COUNT++                          # Increment the character counter
     done

     let LINE_COUNT++                       
     echo>>$OUT_FILE                                    # Give a newline character
done

Shell Script to Find Factorial of a Number

2009-10-27T08:41:00.000-07:00

Method 1:
#!/bin/bash
# fact1
# Finding factorial of a given number
#

echo "Enter a number"
read num
fact=1
n=$num
while [ $num -ge 1 ]
do

  fact=`echo $fact \* $num|bc`
  
  # You can use bellow commands also 
  # fact=$((fact*num))
  # fact=`expr $fact \* $num`
  # But maximum integer value that bash can handle is 
  # 9223372036854775807.
  # An  operation  that takes a variable  outside these 
  # limits  will give an erroneous result. To solve this
  # problem store numbers as strings and use bc for math.
  
  let num--

done
echo "factorial of $n is $fact"

Method 2:
#!/bin/bash
# fact2
# Usage : sh fact2 Number

factorial ()  
{
local number=$1
if [ $number -eq 0 ]
then
    Factorial=1
else
    let "next = number - 1"
    factorial $next
    Factorial=`echo $number \* $Factorial | bc`
#   let "Factorial = $number * $Factorial"
fi
return $Factorial 2>/dev/null
}

# Bash function returns integer value only.
# But maximum integer value that bash can handle is 
# 9223372036854775807.
# An operation that takes a variable outside these limits 
# will give an erroneous result. That's why I redirected 
# stderror output to /dev/null

# Main program starts here.
if [ $# -ne 1 ]
then
    echo "Invalid Arguments"
    echo "Usage: ./fact2.sh  Number "
    exit 1
fi
factorial $1
echo "Factorial of $1 is $Factorial"

Output:
[root@localhost shell]# ./fact1
Enter a number
8 
factorial of 8 is 40320
[root@localhost shell]# ./fact1
Enter a number
23
factorial of 23 is 25852016738884976640000

[root@localhost shell]# ./fact2 
Invalid Arguments
Usage: ./fact2.sh  Number 
[root@localhost shell]# ./fact2 7
Factorial of 7 is 5040
[root@localhost shell]# ./fact2 33
Factorial of 33 is 8683317618811886495518194401280000000

For Loop Example-2

2009-10-26T09:50:00.000-07:00


#!/bin/bash
# Usage: forloop2.sh     or  forloop2.sh number
# Example using for loop
# Prints following format
#     *
#    * *
#   * * *
#    * *
#     *

n=${1-10}    # If command line argument not supplied default is 10
t=`expr $((2*$n - 1 ))`
a=$n
b=$(($a+1))
for (( i=1 ; i<=$n ;i++ ))
do
  echo -e -n "\033[47m"
  a=$(($b-1))
  b=$a
  k=1
for (( j=1 ; j<=$t ; j++ ))
  do
      if [ $j -eq $a ]
      then
         echo -e "\033[43m * \033[47m\c"
         if [ $k -lt $i ]
         then
            a=$((a+2))
            let k++
         fi
      else
         echo -n "   "
     fi
  done
  echo  ""
done

n=$(($n-1))
a=1
b=$a
for (( i=$n ; i>=1 ;i-- ))
do
  echo -e -n "\033[47m"
  a=$(($b+1))
  b=$a
  k=1
  for (( j=1 ; j<=$t ; j++ ))
  do
      if [ $j -eq $a ]
      then
         echo -e "\033[43m * \033[47m\c"
         if [ $k -lt $i ]
         then
            a=$((a+2))
            let k++
         fi
      else
         echo -n "   "
     fi
  done
  echo  ""
done
echo -e "\033[0m"

Output:

How to Execute a Shell Script

2009-10-10T09:55:00.000-07:00

Defining the Shell Type

To make a bash script crate a new file with a starting line like:
#!/bin/bash 
       It is important that the path to the bash is proper and 
first two  characters  must be “#!” . The shell from which you 
are starting the script will find this line and hand the whole
script  over to bash. Without this  line the  script  would be 
interpreted  by the same  type of shell as the one, from which
it was started.But since the syntax is different for all shells, 
it is necessary to define the shell with that line.
Some typical interpreters for shebang lines:

• #!/bin/bash — Execute using the Bourn-again shell
• #!/bin/sh — Execute using the Bourn shell (if available) or a 
             Bourne compatible shell such as Bourne-again shell
• #!/usr/bin/ksh --- Execute using korn shell

Note:
    In computing, a shebang (also called a hashbang, hashpling, 
pound  bang, or  crunchbang) refers to the  characters "#!" when 
they are the first two characters in a text file. In a Unix-like 
operating system, the program loader takes the presence of these 
two  characters as an indication that the  file is a script, and 
tries to execute  that script using the interpreter specified by 
the rest of  the first line in the file. For instance, shell 
scripts for the Bourne shell start with the first line:
#!/bin/sh

Executing a shell script

   Once a shell script is created, there are several ways to 
execute it. However, before executing a shell script you must
assign proper permissions. Using chmod command you can change
file permissions.For example giving execute permission to the 
file “temp”:
chmod +x temp
First create a sample shell script “temp”. 

$cat > temp
#!/bin/bash
echo "My name is  `whoami`" 
echo "Users  are `users`" 
echo "OS name is `uname -s`" 
echo "current shell is $SHELL"
ctrl+d

Method 1 to execute a shell script:
 
./scriptname

   You must assign execute permission to the script.

   With this method script is executed by interpreter  which is 
defined at sha-bang line.

 Note:             Script path should be relative to the current 
directory then  only this method works. If you want to execute a 
script in the current directory you use ./scriptname. In fact if
you want to execute  a  script in the  parent  directory of your 
current location you can use ../scriptname , as .  means current 
and .. means parent.

Run temp script.

[root@localhost shell]# ./temp 
My name is  root 
Users  are root root 
OS name is Linux 
current shell is /bin/bash 

now change sha-bang line with #!/bin/ksh and execute the script

[root@localhost shell]# ./temp 
bash: ./temp: /bin/ksh: bad interpreter: No such file or directory 

now change sha-bang line with #!/bin/zsh and execute the script

[root@localhost shell]# ./temp
My name is  root
Users  are root root
OS name is Linux
current shell is /bin/bash

So wrong path to interpreter  or bad interpreter gives error message.

Method 2 to execute a shell script:

  you can execute the bash script by specifying the filename 
as an argument to the bash,sh,zsh commands.
  This is a bad way  to call a script,  since it will override 
the #! at the beginning of the script.Depending on command you
used, current shell spawns relative subshell.

$sh temp
     or
$bash temp
     or
$zsh temp
Output:
My name is  root 
Users  are king root root sai venu 
OS name is Linux 
Current shell is /bin/bash 

Note:  It is good to use proper command. Suppose your script is
korn shell script,then run it as:
ksh temp

Caution:   In this method shell runs script in sub shell. 
So you can't access some shell builtin variable values.
For example run bellow shell script:

#!/bin/bash
lines=$LINES
cols=$COLUMNS
echo $lines
echo  $cols

Output:
    $ sh sample
It prints nothing

Note:  To solve this problem export current shell variables 
using “export” command.Before executing script, export all
variables you need.

Example:
$ export LINES COLUMNS
$ sh sample
24 
80

Method 3 to execute a shell script:

     you can execute the bash script by specifying the filename 
as an argument to the . (dot) or source command. In this method
script will be run in current shell.
Example:
$ . temp
   or
$ source temp

Output:
[root@localhost shell]#  . temp 
My name is  root 
Users  are king root root sai venu 
OS name is Linux 
current shell is /bin/bash 

[root@localhost shell]# source temp 
My name is  root 
Users  are king root root sai venu 
OS name is Linux 
current shell is /bin/bash 

Caution:
  Try to unset variables at the end of the script. Otherwise 
you will get add results. Variable and functions used in the 
script will be alive after execution of the script.

Example:
create two files
cat > sample2
n=100 
m=200 
echo "n=$n  m=$m" 
ctrl+d

cat > sample3
n=$((n+m)) 
m=$((m+25)) 
echo "n=$n  m=$m" ctrl+d

Execute scripts using sh command

[root@localhost shell]# sh sample2 
n=100  m=200 
[root@localhost shell]# sh sample3 
n=0  m=25 

Now execute scripts using . Or source command

[root@localhost shell]# . sample2 
n=100  m=200 
[root@localhost shell]# . sample3 
n=300  m=225 

So be careful. Try to unset variables at the end of the script.

Method 4 to execute a shell script:    

   You can also execute scripts by just typing its name alone.
However, for this method to work, the directory containing the
script must be defined in your PATH variable and file must has 
executable permission.

For example run “temp” script directly

[root@localhost shell]# temp 
bash: temp: command not found 

   Now add your home directory to PATH variable(I am assuming 
script located at home directory).

PATH=${PATH}:$HOME

Now execute script with name, you will get result.

[root@localhost ~]# temp 
My name is  root 
Users  are king root root sai venu 
OS name is Linux 
current shell is /bin/bash 

 Suppose  you changed “temp” script name to “ls”, what will
happen, which result you will get.

[root@localhost ~]# mv temp ls 
[root@localhost ~]# ls 
Desktop  ls  sample  sample2  sample3 

So you will get “ls” command output. Why ?

    When you type name of any command at $ prompt, what shell 
do is it first look that command in it's internal part(called 
as internal command,which is part of shell itself, and always
available to execute),if found as internal command shell will 
execute it, if not found then shell will look  PATH  setting, 
and try to find our requested commands executable file in all 
of the directories mentioned in PATH settings,if found it will 
execute it, other wise it will give message 
“bash:XXXX:command not found”.

So don't use command name as shell script.

Note:If you have two different files with same name in different 
directories, which file will execute?
The directory which comes first in PATH setting will be executed. 

Example:
First create a file “testscript” in home directory.

$  cat > testscript
whoami
ctrl+d

Then create a directory “bin” in home directory 
$ mkdir bin
Now create a file with same name “testscript”  in  bin dirctory.
$ cd bin
$ cat > testscript
date
ctrl+d

Then add “bin” directory to PATH variable.If your “bin” directory 
already in PATH setting leave it.

PATH=${PATH}:$HOME/bin

now check your path settings

[root@localhost ~]# echo $PATH 
 /usr/lib/qt-3.3/bin:/usr/kerberos/sbin:/usr/kerberos/bin:
/usr/lib/ccache:/usr/local/sbin:/usr/sbin:/sbin:/usr/local/
bin:/usr/bin:/bin:/root/bin:/root

/root and /root/bin added to your PATH.
I added /root/bin  directory before /root directory.

now execute “testscript” script

[root@localhost ~]# testscript  
Sat Oct 10 06:57:14 IST 2009

Bash for loop example-1

2009-10-07T08:19:00.000-07:00

#!/bin/bash
 # Usage: script.sh number
# A for loop example produces following output
#
#             *
#          *     *
#       *     *     *
#    *     *     *     *
# *     *     *     *     *
#
Method1
c=1
n=$1
echo -e "\033[47m\c"  #colourizing output
for ((row=1;row<=n;row++))
do
        for ((i=row;i<n;i++))
        do
                echo -n '   '
        done
        for ((k=1;k<=c;k++))
        do
           if [ $((k%2)) -eq 0 ]
           then
             echo -n "   "
           else
             echo -e "\033[43m * \033[47m\c"
           fi
        done
        for ((i=row;i<n;i++))
        do
                echo -n '   '
        done
 c=$((c+2))
        echo
done
echo -e "\033[0m"   #Restoring colours
unset c i k n row
Method2
#!/bin/bash
n=$1
t=$((2*n - 1 ))
a=$n
b=$((a+1))
echo -e -n "\033[47m"
for (( i=1 ; i<=$n ;i++ ))
do
  a=$(($b-1))
  b=$a
  k=1
  for (( j=1 ; j<=$t ; j++ ))
  do
      if [ $j -eq $a ]
      then

         echo -e "\033[43m * \033[47m\c"
         if [ $k -lt $i ]
         then

            a=$((a+2))
   let k++
         fi
      else
         echo -n "   "
     fi

  done
echo
done
echo -e "\033[0m"

Output:

Bash for Loop Syntax

2009-10-07T07:58:00.000-07:00

A 'for loop' is a bash programming language statement which allows code to be repeatedly
executed. A for loop is classified as an iteration statement i.e. it is the repetition of a process
within a bash script.

For example, you can run UNIX command or task 5 times or read and process list of files using
a for loop. A for loop can be used at a shell prompt or within a shell script itself.

for loop syntax
Numeric ranges for syntax is as follows:

for VARIABLE in 1 2 3 4 5 .. N
do
command1
command2
commandN
done

Examples:
#!/bin/bah
for i in 1 2 3 4 5
do
echo "Welcome $i times"
done

Using “seq” command

#!/bin/bash
for i in $(seq 1 2 20)
do
echo "Welcome $i times"
done

To know more about “seq” command check manual using “man seq” command

Bash 3.0+ version supports following syntax also

#!/bin/bash
for i in {1..5}
do
echo "Welcome $i times"
done

Three expression syntax

for (( EXP1; EXP2; EXP3 ))
do
command1
command2
command3
done

Example:
#!/bin/bash
for (( c=1; c<=5; c++ ))
do
echo "Welcome $c times..." done

Shell Script To Print Pyramid - Using while Loop

2009-10-07T06:10:00.000-07:00


 #!/bin/bash
 # Usage: scriptname argument
 # Here argument is height of pyramid
 # Output would be pyramid pattern of stars
 #       0                 *
 #       1                ***
 #       2               *****
 #       3              *******
 #       4             *********
 #       5            ***********
 #       6           *************
 #       .          ***************
 #       .         *****************
 #       .        *******************
 #       n-1     *********************
 #                ---\/--- | ---\/---
 #                  n - 1      n - 1
 #
clear
n=$1
row=1;
echo -e "\033[47m"
        while [[ $row -le $n ]]
        do
        loop=1;
        spaces=$((n-row))
        stars=$((2*row - 1))

           while [[ $loop -le $spaces ]]
           do
                echo -n ' '
                let loop++
           done
        loop=1;
           while [[ $loop -le $stars ]]
           do
                echo -e '\033[43m*\033[47m\c'
                let loop++
           done
        loop=1;
           while [[ $loop -le $spaces ]]
           do
                echo -n ' '
                let loop++
           done
        echo
        let row++
        done
echo -e "\033[0m"
unset row loop spaces stars n

Output:
[root@localhost blog]# sh while_pyramid 22

Shell Script To Print Pyramid-Using for Loop

2009-10-07T05:35:00.000-07:00

#!/bin/bash
# Usage: scriptname argument
# Here argument is height of pyramid
# Output would be pyramid pattern of stars

#       0                 *
#       1                ***
#       2               *****
#       3              *******
#       4             *********
#       5            ***********
#       6           *************
#       .          ***************
#       .         *****************
#       .        *******************
#      n-1     *********************
#                ---\/--- | ---\/---
#                  n - 1      n - 1
#

clear
n=$1
echo -e "\033[47m"  #used for colourizing output
for ((row=1;row<=n;row++)) 
do
    spaces=$((n-row))
    stars=$((2*$row - 1))
    for ((i=1;i<=spaces;i++))
    do
        echo -n ' '
    done 
    for ((i=1;i<=stars;i++))
    do 
        echo -e '\033[43m*\033[47m\c'
    done
    for ((i=1;i<=spaces;i++))
    do  
         echo -n ' ' 
    done
    echo
done
echo -e "\033[0m"
unset n i spaces stars row
# Unset variables is a good programming practice

Output:
[root@localhost blog]# sh for_pyramid 22

Sample System Monitor Shell Script - Using Options

2009-09-22T22:22:00.000-07:00

#!/bin/bash
# sys_monitor2.sh
# Usage: sys_monitor2.sh [-u|-d|-f (D/M)| -c number | -m number]
# Sample system monitor script using options
# Tested under Fedora 9

Invalidoptions()
{
  echo "Usage: `basename $0` [OPTIONS]"
  echo "OPTIONS:"
  echo -e "\t -d      for display today's date"
  echo -e "\t -u      for Logged in users list"
  echo -e "\t -f ARG  for Disk and Memory Statistics"
  echo -e "\t        (ARG=D for disk statistics; ARG=M for memory statistics)"
  echo -e "\t -c ARG  for Top CPU consuming process"
  echo -e "\t         (ARG=10 means top 10 process)"
  echo -e "\t -m ARG  for Top Memory consuming process"
  echo -e "\t         (ARG=10 means top 10 process)"
  echo -e "\t Note: Only one option at a time and -f,-c and -m require argument"
  exit 1
}

Isnumber()
{
  if [ $1 -eq $1 2> /dev/null ]
     then
     :
  else
     echo -e "You supplied bad argument, \"$1\" is not a number"
     Invalidoptions
  fi
}

if [ $# -lt 1 -o $# -gt 2 ]
then
  Invalidoptions
fi

if [ $# -eq 1 -a "$1" != "-d" -a "$1" != "-u" -a "$1" != "-f" -a "$1" != "-c" ]
then
  Invalidoptions
fi

if [ $# -eq 2 ] && [ "$1" != "-f" -a "$1" != "-c" -a "$1" != "-m" ]
then
  Invalidoptions
fi

choice=
top="head -$2"
while getopts udf:c:m: choice
do
case $choice in
  d) echo -e " Today's Date: \c"
     date +"  %d-%h-%Y       Time:  %T";;
  u) echo -e "\tCurrently Logged In Users"
     who;;
  f)
    if [ "$OPTARG" = "D" ]
    then
        echo -e "\t\tDisk Statistics"
        df -h | grep "%"
    elif [ "$OPTARG" = "M" ]
    then
        echo -e "\t Memory Statistics "
        free -m | awk 'BEGIN{printf "\t\tTotal\tUsed\tFree\n"; OFS="\t" }\
 /Mem/||/Swap/{printf "\t"; print $1,$2,$3,$4}'
    else
       Invalidoptions
    fi;;
  m) Isnumber $OPTARG
     k3sort="sort -nr -k 3"
     echo -e " PID   PPID  MEM  CPU COMMAND "
     ps -Ao pid= -o ppid= -o pmem= -o pcpu= -o comm=|$k3sort|$top;;
  c) Isnumber $OPTARG
     k4sort="sort -nr -k 4"
     echo -e " PID   PPID  MEM  CPU COMMAND "
     ps -Ao pid= -o ppid= -o pmem= -o pcpu= -o comm=|$k4sort|$top;;

esac
done

Output:

[root@localhost blog]# sh sys_monitor2.sh -u
     Currently Logged In Users
root     tty7         2009-09-23 13:48 (:0)
root     pts/2        2009-09-23 14:36 (:0.0)

[root@localhost blog]# sh sys_monitor2.sh -d
Todays Date:   23-Sep-2009       Time:  16:50:38

[root@localhost blog]# sh sys_monitor2.sh -m 5
PID   PPID  MEM  CPU COMMAND
3122  3102  9.6  3.0 firefox
2765  2540  1.9  0.0 nautilus
3849     1  1.7  1.0 ktorrent
2882     1  1.6  0.0 tomboy
2810     1  1.6  0.0 /usr/bin/sealer

[root@localhost blog]# sh sys_monitor2.sh -m
Usage: sys_monitor2.sh [OPTIONS]
OPTIONS:
      -d      for display today's date
      -u      for Logged in users list
      -f ARG  for Disk and Memory Statistics
             (ARG=D for disk statistics; ARG=M for memory statistics)
      -c ARG  for Top CPU consuming process
              (ARG=10 means top 10 process)
      -m ARG  for Top Memory consuming process
              (ARG=10 means top 10 process)
      Note: Only one option at a time and -f,-c and -m require argument

Sample System Monitor Shell Script -Menu Based

2009-09-22T21:31:00.000-07:00


#!/bin/bash
# sys_monitor.sh
# Sample system monitor script using menu
# Tested under Fedora 9
#
# Create the following menu and clear the screen each time it appears
#

clear
echo -e "\033[1m `uname -or` Monitor script\033[0m"
items="       1.Date
       2.Current Users
       3.Disk Statistics
       4.Memory Statistics
       5.Top 10 Memory consuming process
       6.Top 10 CPU consuming process
       7.Exit"

exit_function()
{
   clear
   exit
}

#function enter is used to go  back to menu and clear screen

enter()
{
   ans=
   echo ""
   echo -e  "Do you want to continue(y/n):\c"
   stty -icanon min 0 time 0
# When -icanon is set then one character has been received.
# min 0 means that read should read 0 characters.
# time 0 ensures that read is terminated the moment one character is hit.

while [ -z "$ans" ]
do
   read ans
done
#The while loop ensures that so long as at least one character is not received
# "read" continue to get executed

if [ "$ans" = "y" -o "$ans" = "Y" ]
then
   stty sane          # Restoring terminal settings
   clear
else
   stty sane
   exit_function
fi
}

choice=
h10="head -10"
while true
do
   echo -e "\n\t    PROGRAM MENU \n"
   echo -e "$items \n"
   echo -n "Enter your choice :"
read choice
case $choice in
   1) clear; echo -e "\n\n\t\t Today's Date \n"
   date +"       %d-%h-%Y        Time %T"; enter;;
   2) clear; echo -e "\n\n\t\t Currently Logged In Users\n"
   who; enter;;
   3) clear; echo -e "\n\n\t\t Disk Statistics\n"
   df -h | grep "%"
   enter;;
   4) clear; echo -e "\n\n\t\t Memory Statistics\n "
   free -m | awk 'BEGIN{printf "\t\tTotal\tUsed\tFree\n\n"; OFS="\t" }\
/Mem/||/Swap/{printf "\t"; print $1,$2,$3,$4}'
  enter;;
   5) clear
   k3sort="sort -nr -k 3"
   echo -e "\033[1m PID   PPID  MEM  CPU COMMAND \033[0m "
   ps -Ao pid= -o ppid= -o pmem= -o pcpu= -o comm=|$k3sort|$h10
   enter;;
   6) clear
   k4sort="sort -nr -k 4"
   echo -e "\033[1m PID   PPID  MEM  CPU COMMAND \033[0m"
   ps -Ao pid= -o ppid= -o pmem= -o pcpu= -o comm=|$k4sort|$h10
   enter;;
   7)exit_function  ;;
   *)echo -e "You entered wrong option \n Please enter 1,2,3,4,5,6 or 7\n"
   echo " Press enter to continue"
   read
   clear
esac
done

Output:

2.6.25-14.fc9.i686 GNU/Linux Monitor script
           PROGRAM MENU

      1.Date
      2.Current Users
      3.Disk Statistics
      4.Memory Statistics  
      5.Top 10 memory cosuming process
      6.Top 10 CPU consuming process
      7.Exit

Enter your choice :5
PID   PPID  MEM  CPU COMMAND 
3122  3102  9.2  2.6 firefox
2765  2540  1.9  0.0 nautilus
3849     1  1.7  1.0 ktorrent
2882     1  1.6  0.0 tomboy
2810     1  1.6  0.0 /usr/bin/sealer
4041     1  1.4  0.1 gnome-terminal
2394  2393  1.4  1.8 Xorg
2759  2540  1.2  0.0 gnome-panel
2876     1  0.9  0.0 clock-applet
2870     1  0.9  0.0 mixer_applet2

Do you want to continue(y/n):

Bash Script to check after every one minute whether a user has logged in or not

2009-09-19T10:33:00.000-07:00


#!/bin/bash
# isuserloggedin.sh
# Usage: isuserloggedin.sh username
# Shell script which checks after every one minute whether a user has logged in
# or not
# You can also run script in background using & then foreground it to view result

if [ $# -ne 1 ]
then
   echo "You supplied wrong arguments"
   echo "usage : `basename $0` username"
exit 1
fi

isuserexist()
{
grep -w "$1" /etc/passwd > /dev/null

if [ $? -eq 1 ]
then
   echo "$1 is not a valid user"
exit 1
fi
}

isuserexist $1
time=0
while true
do
#  you can replace following two statements with
#   if `who|grep $1 > /dev/null`
who|grep $1 > /dev/null
if [ $? -eq 0 ]
then
  echo "User $1 is logged in "
  if [ $time -gt 60 ]
  then
     hours=$((time/60))
     minutes=$((time%60))
     echo "He is logged in $hours hour(s) $minutes minute(s) late"
  else
     echo "He is logged in $time minute(s) late"
  fi
exit 0

else
let time++

# You can use following formats also
#   time=`expr $time + 1 `
#  time=$((time+1))

sleep 60
fi
done

Output:
[root@localhost shell]# sh isuserloggedin.sh
you have suplied wrong arguments
usage : isuserloggedin.sh username
[root@localhost shell]# sh isuserloggedin.sh root
User root is logged in
He is logged in 0 minute(s) late
[root@localhost shell]# sh isuserloggedin.sh roott
roott is not a valid user
Run script in background
[root@localhost shell]# sh isuserloggedin.sh venu &
[1] 15917
[root@localhost shell]# User venu is logged in
He is logged in 3 minute(s) late

[1]+ Done sh isuserloggedin.sh venu
Run script in background then foreground it
[root@localhost shell]# sh isuserloggedin.sh venu &
[1] 16223
[root@localhost shell]# fg
sh isuserloggedin.sh venu
User venu is logged in
He is logged in 1 minute(s) late
[root@localhost shell]#

Bash Script to Check whether a user has an account in your system

2009-09-19T10:11:00.000-07:00

#!/bin/bash
# validuser.sh
# Usage: validuser.sh username
# Script to check whether suplied user has an account in your system

if [ $# -ne 1 ]
then
   echo "You supplied wrong arguments"
   echo "Usage : `basename $0` user_name"
exit 1
fi

#grep -w "$1" /etc/passwd > /dev/null
grep -w "^$1" /etc/passwd > /dev/null
if [ $? -eq 1 ]
then
   echo "$1 is not a valid user"
else
   echo "$1 is a valid user"
fi

# Using greps -q option you can simplify and faster your script
# if `grep -qw "^$1" /etc/passwd`
# greps -q option prints nothing just returns exit status 0 or 1

Out Put:
[root@localhost shell]# sh validuser.sh
You supplied wrong arguments
usage : validuser.sh user_name
[root@localhost shell]# sh validuser.sh venu
venu is a valid user
[root@localhost shell]# sh validuser.sh venuk
venuk is not a valid user
[root@localhost shell]# sh validuser.sh root
root is a valid user
[root@localhost shell]# sh validuser.sh roott
roott is not a valid user
[root@localhost shell]#

How to prompt user to enter input within the time limit in a shell script

2009-09-02T13:25:00.000-07:00

There are various ways to read input within the time limit in shell script. I am posting 4 methods here.First three are direct methods. Final one implemented with some logic, just for practice only.

Method 1:

#!/bin/bash
# timedinput1.sh: prompts times out at five seconds.
# Using read command

timelimit=5
echo -e " You have $timelimit seconds\n Enter your name quickly: \c"
name=""
read -t $timelimit name
#read -t $timelimit name <&1
# for bash versions bellow 3.x
if [ ! -z "$name" ]
then
echo -e "\n Your name is $name"
else
echo -e "\n TIME OUT\n You failed to enter your name"
fi
Output:
[root@localhost shell]# sh timedinput1.sh
You have 5 seconds
Enter your name quickly: king

Your name is king
[root@localhost shell]# sh timedinput1.sh
You have 5 seconds
Enter your name quickly:
TIME OUT
You failed to enter your name

Method 2:

#!/bin/bash
# timedinput2.sh
# Using stty command

timelimit=5
# Time limit to enter input
echo -e " You have only $timelimit seconds\n Enter your name quickly: \c"
name=""
stty -icanon min 0 time ${timelimit}0

# "min N" with -icanon, set N characters minimum for a completed read
# "time N" with -icanon, set read timeout of N tenths of a second (i.e. 50 means 5
seconds )

read name
if [ ! -z "$name" ]
then
echo " Your name is $name"
else
echo -e "\n TIME OUT\n You failed to enter your name"
fi
stty sane
#restore terminal settings
Output:
[root@localhost shell]# sh timedinput2.sh
You have only 5 seconds
Enter your name quickly: Sachin Ramesh Tendulkar
Your name is "Sachin Ramesh Tendulkar"
[root@localhost shell]# sh timedinput2.sh
You have only 5 seconds
Enter your name quickly:
TIME OUT
You failed to enter your name
Observation:
There is difference between method1 and method2.In method1 you should to enter input within 5 seconds.But in method 2 you have 5 seconds after a character has been hit.This is because time n means wait till n seconds after a character has been hit.So in method2 you can give any length of input.

Method3:

#!/bin/bash
# timedinput3.sh
# using TMOUT environment variable

TMOUT=5
# TMOUT is an Internal Variable
# If the $TMOUT environment variable is set to a non zero value time, then the shell prompt will time out after $time seconds.This will cause a logout.
# If you run this script in current shell after 5 seconds you will be logout

echo -e " You only have $TMOUT seconds\n Enter your name quickly: \c"
name=""
read name
if [ ! -z "$name" ]
then
echo " Your name is $name"
else
echo -e "\n TIME OUT\n You failed to enter your name"
fi
Output:
[root@localhost shell]# sh timedinput3.sh
You only have 5 seconds
Enter your name quickly: Ricky ponting
Your name is "Ricky ponting"
[root@localhost shell]# sh timedinput3.sh
You only have 5 seconds
Enter your name quickly:
TIME OUT
You failed to enter your name

Method4:

#!/bin/bash
# timedinput4.sh
# Using sleep command

timelimit=5
#set another value if you require

trap 'echo -e "\n TIMEOUT"; exit 14' 14
# Trapping signal 14

echo -e " You only have $timelimit seconds \n What is your name:\c"

sleep $timelimit && kill -s 14 $$ &

# Waits 5 seconds, then sends sigalarm to script($$ environment variable gives pid of current script).
read name
echo " Your name is \"$name\""
kill $!
#kills back ground job (i.e. sleep command)
exit
Output:
[root@localhost shell]# sh timedinput4.sh
You only have 5 seconds
What is your name:Ganguly
Your name is "Ganguly"
[root@localhost shell]# sh timedinput4.sh
You only have 5 seconds
What is your name:Kapil Dev
Your name is "Kapil Dev"
timedinput4.sh: line 16: 3814 Terminated sleep $timelimit && kill -s 14 $$
[root@localhost shell]# sh timedinput4.sh
You only have 5 seconds
What is your name:
TIMEOUT

What is the difference between Hard Link and Soft Link in Linux

2009-08-23T07:10:00.000-07:00

Hard link: Hard link refers to "The specific location of physical data".

Hard Link is a mirror copy of the original file.
Hard links share the same inode.
Any changes made to the original or Hard linked file will reflect the other.
Even if you delete any one of the files, nothing will happen to the other hard links.
But soft link which points to deleted hard link become a dangling soft link.
You can't link a directory even within the same file system.
Hard links can't cross file systems.

Soft link( also called symbolic link): Soft link refers to "A symbolic path indicating the abstract location of another file".

Soft Link is a symbolic link to the original file.(more like windows shortcuts)
Soft Links will have a different Inode value.
Any changes made to the soft link will reflect the original file and its hard links.
A soft link points to the original file. If you delete the original file, the soft link fails. It would become dangling symbolic link.
If you delete the soft link, nothing will happen.
You can link a directory using soft link on same file system and also on other file system.
Soft links can cross file systems

Lets learn the difference with an example:

First create a file named with "mainfile.txt"

Now create a hard link named with "hardlink.txt"

From the above output you can find inode number of both files are equal.

Now create a soft link named with "softlink.txt"

Now you find that inode value is different for the soft link and main file.

But equal for the hard link and main file.

Contents of all files before editing

Now lets try to edit main file "mainfile.txt"

From the above output it clarifies that, changes of main file reflects its soft and hard links.

Note: Permission changes of original file reflects only on hard links. Its soft links permission remains unchanged.

Now lets remove main file "mainfile.txt"

So removing the original file will affect the Soft link. The Soft link fails.Now it become a dangling symbolic link(or broken link).Hard link is unaffected.

Now create main file "mainfile.txt" again and make its links as it is before it is

deleted.

let now try to remove soft link "softlink.txt".

It clarifies that deletion of soft link will not affect the main file and its hard links.

Now lets try to edit hard link "hardlink.tst".Before that create soft link "softlink.txt" again.

From the above output its clear that changing the contents of the hard link will reflects on main file and also reflect on soft link of main file.

Now lets try to edit the soft link "softlink.txt".

From the above output its clear that changing the contents of soft link will reflects on main file and also on all links of main file.

Now lets try to remove main file then edit its soft link.

Some strange result.

Soft link creates its main file.But it will not retain main file contents. It merely creates main file "mainfile.txt" with data what you inserted in "softlink.txt".

Now hard link "hardlink.txt" will not have any relation with main file "mainfile.txt".Both files now have unique inode value.

Now lets give a look on directories. How soft links and hard links behaves with directories:

Now create a directory named with temp and create some files in that directory.

Now try to create hard link and soft link for directory temp.

Above example clarifies that it's not possible to create hard link on directory but it is possible to create soft link.

Note:

Like other files, a symbolic link has a separate directory entry with its own inode number. This means that rm can remove a symbolic link even if its points to a directory(or even a device).

So lets try to remove symbolic link of a directory.In our above example "softtemp" is a symbolic link for directory temp.

So it clears that we can remove directory symbolic link with rm command just like a file. But don't add "/" at the end of link(If you use tab to complete file name at command prompt it automatically adds / at the end of link if it points to a directory).

Observations:

You can link multiple files (i.e., create a link for each), but then the destination filename must be a directory.

Ex: ln chap?? project project is a directory

When you create hard link, The link count of file increases one. So based on link count you can find how many instances of a file exist in your system.
So a file is considered to be completely removed from the system when its link count drops to zero
Many UNIX/Linux commands are linked.

Ex:

[root@localhost ~]# ls -li /usr/bin/gzip
499116 lrwxrwxrwx 1 root root 14 2008-11-11 03:10 /usr/bin/gzip ->../../bin/gzip

If you want to create symbolic link of a file in other directory your source file path must be absolute.
You can identify symbolic links by the character "l" seen in the permission field.
Observe that the size of the symbolic link is equal to length of the path name it contains.
To view the permissions of the file or directory that the symbolic link references, use L option with ls -l (i.e. ls -lL )

Ex: [root@localhost scripts]# ls -l /usr/bin/gzip
lrwxrwxrwx 1 root root 14 2008-11-11 03:10 /usr/bin/gzip -> ../../bin/gzip
[root@localhost scripts]# ls -lL /usr/bin/gzip
-rwxr-xr-x 1 root root 64524 2008-02-22 02:55 /usr/bin/gzip

GCD of more than two numbers

2009-08-14T23:43:00.000-07:00

#!/bin/bash
#**********************************************************************************************
# gcd.sh: greatest common divisor uses Eclidean algorithm
# Usage : gcd.sh num1 num2 num3 .... (any number of arguments)
# The algorithm used to calculate the GCD two integers is known as the Euclidean algorithm.
# Based on Euclidean algorithm this script is written(Recursive method).
# For checking supplied arguments are integers or not check GCD of two numbers code
#***********************************************************************************************

# Argument check
# Minimum 2 arguments you should to supply
ARGS=2
BADARGS=65

if [ $# -lt "$ARGS" ]
then
echo
echo "Invalid Arguments"
echo "Usage: $0 first-number second-number"
echo
exit $BADARGS
fi
# Preserve command line argument for future use
cmdargs=$*

function Euclidean()
{
if [ $2 -eq 0 ]
then
return $1
else
Euclidean $2 $(($1%$2)) # calling function recursively
fi
}
Euclidean $1 $2
return=$?
# $? returns the exit status of script. This is one method to capture return value of a function

shift
# Shifts command line arguments one step.Now $1 holds second argument

while true
do
shift
# shift is used to pick up next command line argument to continue iteration
# $# holds total number of arguments.At every shift operation its value decreases one

if [ $# -eq 0 ]
then
break 2
fi
Euclidean $return $1
return=$?
done
echo "GCD of $cmdargs is $return"
exit 0

GCD of two nubers

2009-08-13T10:35:00.000-07:00

I written three different methods to calculate GCD of two numbers

Method 1:

#!/bin/bash
#*******************************************************************************************
# gcd.sh: greatest common divisor uses Eclidean algorithm
# Usage : gcd.sh number1 number2
# The algorithm used to calculate the GCD between two integers is known as the Euclidean
# algorithm(Recursive method).
#*******************************************************************************************

#----------------------------------------------------------------------
# Argument check
ARGS=2
BADARGS=65

if [ $# -ne "$ARGS" ]
then
echo ; echo "Invalid Arguments"
echo "Usage: $0 first-number second-number" ; echo
exit $BADARGS
fi

# Check supplied arguments are integers are not

isnumber()
{
if [ $1 -eq $1 2> /dev/null ]
then
:
# : is a null command.This is the shell equivalent of a "NOP"(do nothing)
else
echo -e "\nYou supplied one bad argument \"$1\" is not a number"
echo -e "Usage: $0 first-number second-number\n"
exit $BADARGS
fi
}
isnumber $1
isnumber $2

# ---------------------------------------------------------------------

function Euclidean()
{
if [ $2 -eq 0 ]
then

return $1

else

Euclidean $2 $(($1%$2))
# calling function recursively
fi
}

Euclidean $1 $2

echo "gcd of $1 and $2 is $?"

# $? returns the exit status of script. This is one method to capture return value of a function

exit 0

Method 2:

#!/bin/bash
# gcd2.sh
# Usage: gcd2.sh number1 number2
# For argument check see method 1

gcd ()
{
dividend=$1
divisor=$2
# Arbitrary assignment.
#! It doesn't matter which of the two is larger.

remainder=1

# If uninitialized variable used in loop,it results in an error message
# on the first pass through loop.

if [ $divisor -eq 0 ]
then
echo "GCD of $dividend and $divisor = $dividend"
exit 0
fi

until [ "$remainder" -eq 0 ]
do
let "remainder = $dividend % $divisor"

# Now repeat with 2 smallest numbers

dividend=$divisor .
divisor=$remainder
done
}
# Last $dividend is the gcd.

gcd $1 $2

echo; echo "GCD of $1 and $2 = $dividend"; echo
exit 0

Method 3:

#!/bin/bash
# gcd3.sh
# Usage: gcd3.sh
# This script doesn't use command line arguments.You should to enter two numbers when asking

echo enter two numbers
read n1 n2
remainder=1
# Preserve numbers for future use
t1=$n1
t2=$n2
if [ $n2 -eq 0 ]
then
echo "GCD of $n1 and $n2 = $n1"
exit 0
fi
while [ $remainder -ne 0 ]
do
remainder=`expr $n1 % $n2`
# or use
#remainder=$((n1%n2))
n1=$n2
n2=$remainder
done
echo "GCD of $t1 , $t2 is $n1"

Terminal Lock Program

2009-08-10T08:57:00.000-07:00

#************************************************************************************
#Locking a terminal using a shell script.
#This script locks your terminal until you enter correct password (open2world)
#It also traps signals and interrupts
#You can't terminate the script by Ctrl+c or Ctrl+\ or Ctrl+z and Ctrl+d
#************************************************************************************

clear
trap "" 1 2 3 20
lines=`tput lines`
b=`expr $lines / 2 - 4 `

## center function

center()
{
columns=`tput cols`
until [ -z "$1" ]
do
for ((i=1;i<$(((columns-${#1})/2));i++)) do echo -n " " done echo -e "\033[1m \033[5m \033[42m $1 \033[0m " shift done } ## End of center function while true do clear tput cup $b 0
center " TERMINAL LOCKED "
center "Press any key to unlock"
read key
echo -n "enter password : "
read -s password
while true
do
if [ $password = "open2world" ]
then
clear
break 2
# breaks second outer loop
else
echo -e "\n You are an illegal user "
echo -e "\n Enter any key"
read
break
fi
done
done

Analysis :

The trap command allows you to execute a command when a signal is received by your script. It works like this:

trap arg signals

"signals" is a list of signals to interrupt and "arg" is a command to execute when one of the signals is received. If "arg" is not supplied script doesn't do any thing after receiving signal.

Note: Two signals "SIGKILL" "SIGSTOP" are unable to trap

Ex: trap "echo signal received" 1 2 3 15
(or use SIGHUP SIGINT SIGQUIT SIGTERM instead of 1 2 3 15 )

What is signal:

A signal is a message which can be sent to a running process. Some times called
software interrupts.

Some of signals and its value:

       Signal             Value     Action   Comment
     -------------------------------------------------------------------------
     SIGHUP                    1         Term    Hangup detected on controlling terminal
                                                 or death of controlling process
     SIGINT (Ctrl+c)           2         Term    Interrupt from keyboard
     SIGQUIT (Ctrl+\)          3         Core    Quit from keyboard
     SIGTERM                   15        Term    Termination signal
     SIGTSTP (Ctrl+z)          20        Stop    Stop typed at tty

Note: There are different standards(POSIX,SUSv) to determine signals and its values.
I tested Above signals in Fedora 9, Other systems may support them or not depending on system standard(I think almost all standards supports above signals and values).

More stuff:

I used "tput cols" and "tput lines" commands to collect number of columns and lines.
You can also directly use bash variables $LINES ,$COLUMNS to get columns and lines.But
you should to run your script in current shell only. If you run your script in sub shell
current shell will not export $LINES and $COLUMNS variable values.

Bash variables scope

2008-06-21T00:44:00.000-07:00

Bash variables are defaults to global

What makes a variable local?

A variable declared as local is one that is visible only within the block of code in which it appears. It has local "scope." In a function, a local variable has meaning only within that function block.
Ex:
local variable name

func ()
{
local loc_var=23
# Declared as local variable.
# Uses the 'local' builtin.
echo "\"loc_var\" in function = $loc_var"
global_var=999

# Not declared as local.
# Defaults to global.
echo "\"global_var\" in function = $global_var"
}

func
# Now, to see if local variable "loc_var" exists outside function.

echo "\"loc_var\" outside function = $loc_var"

# $loc_var outside function =
# No, $loc_var not visible globally.

echo "\"global_var\" outside function = $global_var"

# $global_var outside function = 999
# $global_var is visible globally.
exit 0

Before a function is called, all variables declared within the function are invisible outside the body of the function, not just those explicitly declared as local

func ()
{
global_var=37

# Visible only within the function block
# before the function has been called.
} # END OF FUNCTION

echo "global_var = $global_var"
# global_var =
# Function "func" has not yet been called,
# so $global_var is not visible here.

func

echo "global_var = $global_var"
# global_var = 37 Has been set by function call.

Using the declare builtin restricts the scope of a variable

foo ()
{
FOO="bar"
}

bar ()
{
foo
echo $FOO
}

bar
# Prints bar

However . . .

foo (){
declare FOO="bar"
}
bar ()
{
foo
echo $FOO
}
bar
# Prints nothing.

Bash variables type

2008-06-21T00:24:00.000-07:00

Unlike many other programming languages, Bash does not separate its variables by "type". Essentially, Bash variables are character strings, but, depending on context, Bash permits integer operations and comparisons on variables. The determining factor is whether the value of a variable contains only digits.
Integer or string?
a=2334
# Integer.
let "a += 1"
echo "a = $a "
# a = 2335
# Integer, still.

b=${a/23/BB}
# Substitute "BB" for "23".
# This transforms $b into a string.
echo "b = $b"
# b = BB35
declare -i b
# Declaring it an integer doesn't help.
echo "b = $b"
# b = BB35

let "b += 1"
# BB35 + 1 =
echo "b = $b"
# b = 1
c=BB34
echo "c = $c"
# c = BB34
d=${c/BB/23}
# Substitute "23" for "BB".
# This makes $d an integer.
echo "d = $d"
# d = 2334
let "d += 1"
# 2334 + 1 =
echo "d = $d"
# d = 2335
# What about null variables?
e=""
echo "e = $e"
# e =
let "e += 1"
# Arithmetic operations allowed on a null variable?
echo "e = $e"
# e = 1
# Null variable transformed into an integer.

# What about undeclared variables?
echo "f = $f"
# f =
let "f += 1"
# Arithmetic operations allowed?
echo "f = $f"
# f = 1
# Undeclared variable transformed into an integer.

The burden is on the programmer to keep track of what type the script variables are.
Bash will not do it for you.
But “declare” or “typeset “built-ins permit restring the properties of variables.
This is very weak form of the typing available in certain programming languages.

Ex:1
declare –i number
# The script will treat subsequent occurrences of “number” as an integer
number=3
echo “Number = $number”
# Number = 3
number=three
echo “Number = $number”
#Number = 0
#Tries to evaluate the string “three” as an integer

Backup files to tarred and zip file

2008-06-06T07:56:00.000-07:00

#!bin/bash

# backs up all files in current directory modified within last 24 hours
# in a tarred and zipped file
# Replace 1 with how many day's you want to back up files

BACKUPFILE=backup-`date +"%m-%d-%Y"`
# Embeds date in backup filename

archive=${1:-$BACKUPFILE}
#If no filename specified default to backup-MM-DD-YYYY

find . -mtime -1 -type f -print0 xargs -0 tar rvf "$archive.tar"

#check bellow command
# tar cvf - $(find . -mtime -1 -type f -print) > $archive.tar
# It works But will fail to backup file names contain space
# if there is no files containing spaces it is good

# ALSO USE bellow code but it is slow and not portable
# find . -mtime -1 -type f -exec tar rvf "$archive.tar" {} \;
# use rvf option instead of cvf otherwise only one file will be archived

gzip $archive.tar && echo "Directory $pwd backed up in \"$archive.tar.gz\" File"

Traversing directory using depth first search

2008-06-04T06:11:00.000-07:00

#!/bin/bash
# Traverse a directory using depth first traversal technique
# Usage $0 directorypath
# otherwise it takes current working directory as directory path

depth()
{
#Do a small depth checking how deep into the tree we are
k=0
while [ $k -lt $1 ]
do
echo -n " "
let k++
#or use k=`expr $k + 1`
done
}

traverse()
{
# Traverse a directory

ls "$1"while read i
do
depth $2
if [ -d "$1/$i" ]
then
echo Directory: $1/$i

traverse "$1/$i" `expr $2 + 1`
# Calling this as a subshell means that when the called
# function changes directory, it will not affect our
# current working directory
# If you call this in current shell it gives the error
# bash: traverse: No such file or directory after changing
# the current directory
else

echo File: $1/$i
fi
done
}

# $1 is directory path

if [ -z "$1" ]
then
# Here we are giving '0' is the current depth of direcory
traverse . 0
else
traverse $1 0
fi

Displaying chess board on the screen

2008-04-25T22:02:00.000-07:00


Small Chess Board


#!/bin/bash
# SCRIPT  : smallchessboard.sh
# PURPOSE : Prints small chess board on the screen.

clear
for (( i=1 ; i<=8 ; i++ ))
do

  for (( j=1 ; j<=8 ; j++ ))
  do

    if [ `expr $(($i+$j)) % 2` -eq 0 ]
    then
        echo -e -n "\033[47m  "         # White background
    else
        echo -e -n "\033[40m  "         # Black background
    fi

  done
  echo                                  # move to next line

done

echo -e "\033[0m"                       # Restores color settings.


OUTPUT:


Big Chess Board


#!/bin/bash
# SCRIPT  : bigchessboard.sh
# PURPOSE : Prints big chess board on the screen.

clear
a=4

for (( i=1 ; i<=8; i++ ))
do

   for (( j=1 ;j<=2; j++ ))            # prints same line twice
   do
      tput cup $a 15                   # moves cursor to LINE COLUMN

     for (( k=1 ; k<=8; k++ ))
     do

        c=`expr $((i+k)) %  2`

        if [ $c -eq 0 ]
        then
             echo -e -n "\033[40m    "   # Black background
        else
             echo -e -n "\033[47m    "   # White background
        fi

      done
      let a=a+1

    done

done

echo -e "\033[0m"                         # Restores color settings
read key                                  # Waits for enter


OUTPUT:

How can get nth line from a file

2008-04-01T22:51:00.000-07:00

time head -5 emp.lst tail -1
It has taken time for execution is
real 0m0.004s
user 0m0.001s
sys 0m0.001s
or
awk 'NR==5' emp.lst
It has taken time for execution is
real 0m0.003s
user 0m0.000s
sys 0m0.002s
or
sed -n '5p' emp.lst
It has taken time for execution is
real 0m0.001s
user 0m0.000s
sys 0m0.001s
or
using some cute trick we can get this with cut command
cut -d “
“ -f 5 emp.lst
# after -d press enter ,it means delimiter is newline
It has taken time for execution is
real 0m0.001s
user 0m0.000s
sys 0m0.001s

Analysis: comparing above commands 'head' command taken maximum time
because it pipes the output to tail command. piping consumes some
time.
Next “awk” command has taken greater time ,because 'awk' not only
a command, it is a programing language too.

When not to use shell scripts

2008-04-01T01:50:00.000-07:00

· Resource-intensive tasks, especially where speed is a factor (sorting, hashing,
etc.)Procedures involving heavy-duty math operations, especially floating
point arithmetic, arbitraryprecision calculations, or complex numbers
(use C++ or FORTRAN instead)

· Cross-platform portability required (use C or Java instead) Complex applications, where structured programming is a necessity (need type-checking of variables, function prototypes, etc.)

· Project consists of subcomponents with interlocking dependencies Extensive file operations required (Bash is limited to serial file access, and that only in a particularly clumsy and inefficient line-by-line fashion)

· Need native support for multi-dimensional arrays
· Need data structures, such as linked lists or trees
· Need to generate or manipulate graphics or GUIs
· Need direct access to system hardware
· Need port or socket I/O
· Need to use libraries or interface with legacy code

Why shell(bash) programming

2008-03-31T22:57:00.000-07:00

No programming language is perfect. There is not even a single best language; there areOnly languages well suited or perhaps poorly suited for particular purposes.
--
UNIX is simple. But It just needs a genius to understand its simplicity.
--Dennis Ritchie
We will be using Bash, an acronym for "Bourne--Again shell" developed by Brian Fox and Chet Ramey. Bash has become a de facto standard for shell scripting on all flavors of UNIX. Bash is the standard GNU shell, intuitive and flexible. Probably most advisable for beginning users while being at the same time a powerful tool for the advanced and professional user. On Linux, bash is the standard shell for common users. This shell is a so-called superset of the Bourne shell, a set of add-ons and plug-ins. This means that the Bourne Again shell is compatible with the Bourne shell. commands that work in sh, also work in bash. However, the reverse is not always the case. Bash is the POSIX compliant.

Shell is a command language interpreter that executes commands read from the standardInput device(key board) or from a file. Shell is not part of system kernel, but uses the system kernel to execute programs, create files etc. Normally shells are interactive. An interactive shell generally reads from, and writes to, a user's terminal: input and output are connected to a terminal.

The UNIX shell program interprets user commands, which are either directly entered by the user, or which can be read from a file called the shell script or shell program. Shell scripts are interpreted, not compiled.Writing shell script is not hard to learn. The syntax is simple and straightforward, similar to that of invoking and chaining together utilities at the command line, and there are only a few rules to learn. Most short scripts work right the first time, and debugging even the longer ones is straightforward. Shell script is just like batch file in MS-DOS but have more power than the MS-DOS batch file. Shell scripts useful to create our own commands that can save our lots of time and to automate some task of day today life. Using shell scripts we can automate system administrative tasks it saves lot of time

1	2	3	4	5	6	7	8	9	10
File	User Permissions			Group Permissions			Other Permissions
Type	Read	Write	Execute	Read	Write	Execute	Read	Write	Execute
d	r	w	e	r	w	e	r	w	e

r	Read access is allowed
w	Write access is allowed
x	Execute access is allowed
-	No permissions

UNIX/Linux Bash Shell Scripting

How to format Flash/Pen Drive in Linux

Finding device:

Method 1: Using ls /dev/sd* command

Method 2: Using df command

Method 3: dmesg | tail

Method 4: mount -l

Method 5: fdisk -l

Formatting pen drive:

1.Once you have Identified your pen drive, unmount it.

2.Format pen drive now.

For Ms-Dos or Windows file system:

For Linux File system:

How to Remove RPM GPG Public Key

If there are duplicates exist:

How to solve this:

How to Import RPM GPG Key

Why to check signature of an rpm:

Checking a package's Signature:

How to import public keys:

Shell Script to Find Prime Factors of a Number

Menu Driven Shell Script - Using Dialog Utility

Main Menu:

Users:

Disk Stats:

Delete File:

Quicksort Shell Script

Binarysearch Shell Script

Linear Search Shell Script

Happy New Year Shell Script

Wish You a Happy New Year To All My Friends

Math in Shell Scripts

expr command:

With double parentheses: $(()) and (())

let command:

bc: THE CALCULATOR

$[] construct:

Shell Script to Generate Fibonacci Series

Iterative Method:

Recursive Method:

Shell Script to Find Armstrong Numbers Between a Given Range

Shell Script to Check Armstrong Number

Decimal to Binary Conversion Shell Script

Binary to Decimal Conversion Shell Script

How to Validate Integer Input using Shell script

Method 1:

Method 2 :

Method 3:

Shell Script to Check Whether a String is Palindrome or not

Method 1:

Method 2:

Method 3:

Method 4:

Insertion Sort Shell Script

Selection Sort Shell Script

Bubble Sort Shell Script

Method2: Without Using Arrays

How to Read a File Line by Line in a Shell Script

Method 1: PIPED while-read loop

Method 2: Redirected "while-read" loop

Method 3:while read LINE Using File Descriptors

Method 4: Process file line by line using awk

Method 5: Little tricky with head and tail commands

Time Comparison for the Five Methods

Shell Script to Display Time and Date in the Top Right Corner of the Screen.

Using tput command:

Using ANSI escape sequences:

How to Handle Cursor Movement in a Shell Script

Using ANSI escape sequences :

Using tput command:

tput Cursor Movement Capabilities:

tput Colour Capabilities :

tput Text Mode Capabilities:

tput Clear and Insert Capabilities :

Creating a User Group and Shared Directory

Can You Inherit File Permissions?

UNIX/Linux Advanced File Permissions - SUID,SGID and Sticky Bit

Set-User_Id (SUID): Power for a Moment:

What is effective user-id:

How to assign SUID permission:

Method 5: Little tricky with head and tail
commands

Difference in access permissions for files and
directories: