OPERATING STSTEM LAB MANUAL (For 6th sem CSE & IT) Strictly According To BPUT Syllabus Prepared

By : Mr.Neelamani Samal

Prepared By |Mr. Neelamani Samal 1

CONTENT
Experiment No.
1

Name of The Experiment

Basic UNIX Commands.

Page NO.

3
22 39 45

UNIX Shell Programming.

Programs on process creation and synchronization, inter process communication. Programs on UNIX System calls.

Prepared By |Mr. Neelamani Samal 2

Laboratory Experiment 1 Objective :To learn some basic UNIX commands to do system level programming.

Software Required :UNIX Operating System

Commands:Folder/Directory Commands and Options

Action
Check current Print Working Directory Return to user's home folder

UNIX options & filespec pwd cd cd ~ cd .. mkdir proj1 rmdir /usr/sam rm -r

DOS filespec & options cd

cd /

Up one folder Make directory Remove empty directory

rmdir or rd rmdir /s (NT) deltree (Win 95)

Remove directory -recursively

Prepared By |Mr. Neelamani Samal 3

File Listing Commands and Options

Action
List directory tree -recursively List last access dates of files, with hidden files List files by reverse date

UNIX options & filespec ls -r ls -l -a ls -t -r *.* ls -l -s *.* ls -R *.* wc -l *.xtuml sed -n '$=' ls | grep x

DOS filespec & options tree

dir *.exe /o-d dir *.* /v /os dir *.* /s sed -n "$="

List files verbosely by size of file

List files recursively including contents of other directories List number of lines in folder

List files with x anywhere in the name

File Manipulation Commands and Options

Action
Create new (blank) file Copy old.file to new.file -p preserve file attributes (e.g. ownership and edit dates) -r copy recursively through directory structure -a archive, combines the flags -p R and -d Move old.file (-i interactive flag prompts before overwriting files)

UNIX options & filespec touch afilename cp old.file

new.file

DOS filespec & options

copy old.file
new.*

mv -i old.file
/tmp

Copy old.file
/tmp del old.file

Remove file (-intention) Compare two files and show differences

rm -i sam.txt
diff

del sam.txt comp fc

Prepared By |Mr. Neelamani Samal 4

File Utilities

Action
View a file Edit file Concatenate files Counts -lines, -words, and characters in a file Displays line-by-line differences between pairs of text files. calculator calendar for September, 1752 (when leap years began)

UNIX options & filespec

vi file.txt

DOS filespec & options

edit file.txt

pico myfile
cat file1 file2 to standard output.

edit myfile
copy file2 >>file1

wc -l
diff

bc

cal 9 1752

Pattern Matching

Pattern
Position Position
? stands for any single character * stands for any number of

Example
ls ?1 ls 2*

characters Specific characters Range of characters

[AB] stands for any number of

characters
[A-Z] stands for letters from A

ls [AB]1 would yield A1 and B1

thru Z

Prepared By |Mr. Neelamani Samal 5

Files

ls --lists your files ls -l --lists your files in 'long format', which contains lots of useful information, e.g. the exact size of the file, who owns the file and who has the right to look at it, and when it was last modified. ls -a --lists all files, including the ones whose filenames begin in a dot, which you do not always want to see. There are many more options, for example to list files by size, by date, recursively etc. more filename --shows the first part of a file, just as much as will fit on one screen. Just hit the space bar to see more or q to quit. You can use /pattern to search for a pattern. mv fname1 fname2 --- moves a file (i.e. gives it a different name, or moves it into a different directory (see below) cp fname1 fname2 --copies a file rm filename --removes a file. It is wise to use the option rm i, which will ask you for confirmation before actually deleting anything. You can make this your default by making an alias in your .cshrc file. diff fname1 fname2 --- compares files, and shows where they differ wc fname --tells you how many lines, words, and characters there are in a file chmod opt fname --- lets you change the read, write, and execute permissions on your files. The default is that only you can look at them and change them, but you may sometimes want to change these permissions. For example, chmod o+r filename will make the file readable for everyone, and chmod o-rfilename will make it unreadable for others again. Note that for someone to be able to actually look at the file the directories it is in need to be at least executable.

Prepared By |Mr. Neelamani Samal 6

Directories
Directories, like folders on a Macintosh, are used to group files together in a hierarchical structure.

mkdir dirname --make a new directory cd dirname --change directory. You basically 'go' to another directory, and you will see the files in that directory when you do 'ls'. You always start out in your 'home directory', and you can get back there by typing 'cd' without arguments. 'cd ..' will get you one level up from your current position. You don't have to walk along step by step - you can make big leaps or avoid walking around by specifying pathnames. pwd --tells you where you currently are.

Finding things

ff --find files anywhere on the system. This can be extremely useful if you've forgotten in which directory you put a file, but do remember the name. In fact, if you use ff -p you don't even need the full name, just the beginning. This can also be useful for finding other things on the system, e.g. documentation. grep string fname(s) --- looks for the string in the files. This can be useful a lot of purposes, e.g. finding the right file among many, figuring out which is the right version of something, and even doing serious corpus work. grep comes in several varieties (grep, egrep, and fgrep) and has a lot of very flexible options. Check out the man pages if this sounds good to you.

Prepared By |Mr. Neelamani Samal 7

About other people

w --Tells you who's logged in, and what they're doing. Especially useful: the 'idle' part. This allows you to see whether they're actually sitting there typing away at their keyboards right at the moment. who --Tells you who's logged on, and where they're coming from. Useful if you're looking for someone who's actually physically in the same building as you, or in some other particular location. finger username --- gives you lots of information about that user, e.g. when they last read their mail and whether they're logged in. Often people put other practical information, such as phone numbers and addresses, in a file called .plan. This information is also displayed by 'finger'. last -1 username --tells you when the user last logged on and off and from where. Without any options, last will give you a list of everyone's logins. talk username --lets you have a (typed) conversation with another user write username --lets you exchange one-line messages with another user
elm --- lets you send e-mail messages to people around the world (and, of course, read them). It's not the only mailer you can use, but the one we recommend. About your (electronic) self

whoami --returns your username. Sounds useless, but isn't. You may need to find out who it is who forgot to log out somewhere, and make sure *you* have logged out. passwd --lets you change your password, which you should do regularly. ps -u yourusername --- lists your processes. Contains lots of information about them, including the process ID, this list will contain the processes you need to kill. kill PID --kills (ends) the processes with the ID you gave. This works only for your own processes, of course. Get the ID by using ps. If the process doesn't 'die' properly, use the option -9. But attempt without that option first, because it doesn't give the process a chance to finish possibly important business before dying. You may need to kill processes for example if your modem connection was interrupted and you didn't get logged out properly, which sometimes happens.

Prepared By |Mr. Neelamani Samal 8

quota -v --show what your disk quota is (i.e. how much space you have to store files), how much you're actually using, and in case you've exceeded your quota (which you'll be given an automatic warning about by the system) how much time you have left to sort them out (by deleting ) du filename --shows the disk usage of the files and directories in filename (without argument the current directory is used). du -s gives only a total.
last yourusername --lists your last logins.

Login and authentication

login logout passwd

access computer; start interactive session disconnect terminal session change local login password; you must set a strong password that is not easily guessed

Information date history man w, who whoami show date and time list of previously executed commands show online documentation by program name who is on the system and what they are doing who is logged onto this terminal

File management

Prepared By |Mr. Neelamani Samal 9

cat cp ls mv rm ln chmod

combine files copy files list files in a directory and their attributes change file name or directory location remove files create another link (name) to a file set file permissions

Display contents of files cat more head tail vi pico grep lpr diff cmp comm wc copy files to display device show text file on display terminal with paging control show first few lines of a file(s) show last few lines of a file; or reverse line order full-featured screen editor for modifying text files simple screen editor for modifying text files display lines that match a pattern send file to printer compare two files and show differences compare two binary files and report if different compare two files; show common or unique lines count characters, words, and lines in a file
Prepared By |Mr. Neelamani Samal 10

Directories

cd mkdir rmdir mv pwd Disks df du

change to new directory create new directory remove empty directory (you must remove files first) change name of directory show current directory

summarize free space on disk filesystems show disk space used by files or directories

Controlling program execution for C-shell & ^c ^z fg bg ; () ! jobs run job in background kill job in foreground suspend job in foreground restart suspended job in foreground run suspended job in background delimit commands on same line group commands on same line re-run earlier commands from history list list current jobs
Prepared By |Mr. Neelamani Samal 11

ps kill nice at crontab limit alias sh, csh

show process information kill background job or previous process run program at lower priority run program at a later time run program at specified intervals see or set resource limits for programs create alias name for program (normally used in .login file) execute command file

Controlling program input/output for C-shell | > < >> tee script pipe output to input redirect output to a storage file redirect input from a storage file append redirected output to a storage file copy input to both file and next program in pipe make file record of all terminal activity

Editors and formatting utilities sed vi pico programmable text editor for data streams full-featured editor for character terminals very simple text editor

Prepared By |Mr. Neelamani Samal 12

Printing (BSD based) lpr lpq lprm enscript send file to print queue examine status of files in print queue remove a file from print queue convert text files to PostScript format for printing

Starting and Ending

login: `Logging in' ssh: Connect to another machine logout: `Logging out'

File Management
emacs: `Using the emacs text editor' mkdir: `Creating a directory' cd: `Changing your current working directory' ls: `Finding out what files you have' cp: `Making a copy of a file' mv: `Changing the name of a file' rm: `Getting rid of unwanted files' chmod: `Controlling access to your files' cmp: Comparing two files wc: Word, line, and character count compress: Compress a file

Communication
e-mail: `Sending and receiving electronic mail' talk: Talk to another user
Prepared By |Mr. Neelamani Samal 13

write: Write messages to another user sftp: Secure file transfer protocol

Information
man: Manual pages quota -v: Finding out your available disk space quota ical: `Using the Ical personal organizer' finger: Getting information about a user passwd: Changing your password who: Finding out who's logged on

Printing
lpr: `Printing' lprm: Removing a print job lpq: Checking the print queues

Job control
ps: `Finding your processes' kill: `Killing a process' nohup: Continuing a job after logout nice: Changing the priority of a job &: `What is a background process?' Cntrl-z: Suspending a process fg: `Resuming a suspended process'

Banner command.
banner prints characters in a sort of ascii art poster, for example to print wait in big letters. I will type banner wait at unix command line or in my script. This is how it will look.

Prepared By |Mr. Neelamani Samal 14

# # # # # # # ## # ## ## # #

## # # # # ###### # # # #

# # # # # #

##### # # # # #

Cal command
cal command will print the calander on current month by default. If you want to print calander of august of 1965. That's eightht month of 1965. cal 8 1965 will print following results.
August 1965 S M Tu W Th F S 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

Clear command
clear command clears the screen and puts cursor at beginning of first line.

Calendar command
calendar command reads your calendar file and displays only lines with current day.

File Management commands.

cat,cd, cp, file,head,tail, ln,ls,mkdir ,more,mv, pwd, rcp,rm, rmdir, wc.

Pwd command.
pwd command will print your home directory on screen, pwd means print working directory.
/u0/ssb/sandeep

is output for the command when I use pwd in /u0/ssb/sandeep directory.

Prepared By |Mr. Neelamani Samal 15

Ls command
ls command is most widely used command and it displays the contents of directory. options

ls will list all the files in your home directory, this command has many options. ls -l will list all the file names, permissions, group, etc in long format. ls -a will list all the files including hidden files that start with . . ls -lt will list all files names based on the time of creation, newer files bring first. ls -Fxwill list files and directory names will be followed by slash. ls -Rwill lists all the files and files in the all the directories, recursively. ls -R | more will list all the files and files in all the directories, one page at a time.

Mkdir command.
mkdir sandeep will create new directory, i.e. here sandeep directory is created.

Cd command.
cd sandeep will change directory from current directory to sandeep directory. Use pwd to check your current directory and ls to see if sandeep directory is there or not. You can then use cd sandeep to change the directory to this new directory. will restore all files whose name contain "save" find . -depth -print | cpio -padm /mydir will move a directory tree.

Chmod command.
chmod command is used to change permissions on a file.
Prepared By |Mr. Neelamani Samal 16

for example if I have a text file with calender in it called cal.txt. initially when this file will be created the permissions for this file depends upon umask set in your profile files. As you can see this file has 666 or -rw-rw-rw attributes. ls -la cal.txt
-rw-rw-rw1 ssb dxidev 135 Dec 3 16:14 cal.txt

In this line above I have -rw-rw-rw- meaning respectively that owner can read and write file, member of the owner's group can read and write this file and anyone else connected to this system can read and write this file., next ssb is owner of this file dxidev is the group of this file, there are 135 bytes in this file, this file was created on December 3 at time16:14 and at the end there is name of this file. Learn to read these permissions in binary, like this for example Decimal 644 which is 110 100 100 in binary meand rw-r--r-- or user can read,write this file, group can read only, everyone else can read only. Similarly, if permissions are 755 or 111 101 101 that means rwxr-xr-x or user can read, write and execute, group can read and execute, everyone else can read and execute. All directories have d in front of permissions. So if you don't want anyone to see your files or to do anything with it use chmod command and make permissions so that only you can read and write to that file, i.e. chmod 600 filename.

Date command.
Date displays todays date, to use it type date at prompt.
Sun Dec 7 14:23:08 EST 1997

is similar to what you should see on screen.

Df command.
df command displays information about mounted filesystems. It reports the number of free disk blocks. Typically a Disk block is 512 bytes (or 1/2 Kilobyte). syntax is

Prepared By |Mr. Neelamani Samal 17

df options name Options

-b will print only the number of free blocks. -e will print only the number of free files. -f will report free blocks but not free inodes. -F type will report on an umounted file system specified by type. -k will print allocation in kilobytes. -l will report only on local file systems. -n will print only the file system name type, with no arguments it lists type of all filesystems

Du command.
du command displays disk usage.

Env command.
env command displays all the variables.

Finger command.
finger command.

PS command
ps command is probably the most useful command for systems administrators. It reports information on active processes. ps options options.

-a Lists all processes in system except processes not attached to terminals. -e Lists all processes in system. -f Lists a full listing. -j print process group ID and session ID.
Prepared By |Mr. Neelamani Samal 18

Shutdown command.
Shutdown command can only be executed by root. To gracefully bring down a system, shutdown command is used. options.

-gn use a grace-period of n seconds (default is 60). -ik tell the init command to place system in a state k. o s single-user state (default) o 0 shutdown for power-off. o 1 like s, but mount multi-user file systems. o 5 stop system, go to firmware mode. o 6 stop system then reboot. -y suppress the default prompt for confirmation.

Who command
who command displays information about the current status of system. who options file Who as default prints login names of users currently logged in.

Options

-a use all options. -b Report information about last reboot. -d report expired processes. -H print headings. -p report previously spawned processes. -u report terminal usage.

date kill

to display the current date and time to kill (or destroy) the process with a given pid (process identification Prepared By |Mr. Neelamani Samal 19

number) as argument
logout

to log out from the Unix system to get information on a Unix command; to look up the page in the online manual for that command shows the pages of the Unix manual referring man CC to the C++ compiler (CC) on the screen. to find the address of a given machine returns the name and address of the nslookup yourmach machine yourmach, along with the name and address of its server. to change your current password to show the current environment setting to list your current processes by their pid (process identification number) to change an environment setting tells the Xserver that the Xterminal setenv DISPLAY yourmach:0 named yourmach is where any windows created are to be displayed. makes xxx be the default printer for setenv PRINTER xxx any lpr or enscript commands. to reexecute a source shell script file re-executes your .login file (normally executed when you log in); source .login useful after making changes to the .login file (removing the need to exit and re-login); to time the execution of a given command executes anyunixcommand and returns the time anyunixcommand user, system, and total time taken for the execution to list the users currently logged in to given machine; to find out who is logged in Prepared By |Mr. Neelamani Samal 20

man

nslookup

passwd printenv ps setenv

source

time

Who

Whoami

to display login of user currently logged onto given terminal; to answer the question: "Who am I?"

Other Language Commands:

These commands help you to compile and debug programs in other programming languages.
cc

to compile a C program compiles with optimization (-O) the C program named acprog.c into the executable file cc -O acprog.c -o acprog -lm named acprog, allowing the compilation to access the math library (-lm).

CC

to compile a C++ program compiles with optimization (-O) the C++ program named acprog.C into the executable CC -O acprog.C -o acprog -lm file named acprog, allowing the compilation to access the math library (-lm).

dbx

to debug a program
dbx aprog

runs the executable program named aprog that was compiled with a -g option in a debugging environment.

lint f77

to check the syntax of a C program to compile a Fortran program compiles, without generating an executable file (-c), the Fortran program named fprog.f with f77 -c fprog.f ftn1.f ftn2.f the additional Fortran modules, ftn1.f and ftn2.f. compiles the Fortran program called anfprog.f with a symbol table (-g) so f77 -g -o debug anfprog.f that the executable file named debug can be used with the dbx command.

Conclusion :Prepared By |Mr. Neelamani Samal 21

Laboratory Experiment : 2

Objective :To learn the basic shell program and gain knowledge about the scripting language.

Theory :-

Shell scripting
Loops
Most languages have the concept of loops: If we want to repeat a task twenty times, we don't want to have to type in the code twenty times, with maybe a slight change each time. As a result, we have for and while loops in the Bourne shell. This is somewhat fewer features than other languages, but nobody claimed that shell programming has the power of C.

For Loops
for loops iterate through a set of values until the list is exhausted:

for.sh #!/bin/sh for i in 1 2 3 4 5 do echo "Looping ... number $i" done

Try this code and see what it does. Note that the values can be anything at all:

for2.sh #!/bin/sh for i in hello 1 * 2 goodbye do echo "Looping ... i is set to $i" done

Prepared By |Mr. Neelamani Samal 22

is well worth trying. Make sure that you understand what is happening here. Try it without the * and grasp the idea, then re-read the Wildcards section and try it again with the * in place. Try it also in different directories, and with the *surrounded by double quotes, and try it preceded by a backslash (\*) In case you don't have access to a shell at the moment (it is very useful to have a shell to hand whilst reading this tutorial), the results of the above two scripts are: Looping Looping Looping Looping Looping .... .... .... .... .... number number number number number 1 2 3 4 5

and, for the second example: Looping Looping Looping ... Looping Looping Looping ... ... ... etc ... ... ... i is i is i is ... i is i is i is set to hello set to 1 set to (name of first file in current directory) set to (name of last file in current directory) set to 2 set to goodbye

So, as you can see, for simply loops through whatever input it is given, until it runs out of input.

While Loops
while loops can be much more fun! (depending on your idea of fun, and how often you get out of the house... )

while.sh #!/bin/sh INPUT_STRING=hello while [ "$INPUT_STRING" != "bye" ] do echo "Please type something in (bye to quit)" read INPUT_STRING echo "You typed: $INPUT_STRING" done

Prepared By |Mr. Neelamani Samal 23

Test
Test is used by virtually every shell script written. It may not seem that way, because test is not often called directly.test is more frequently called as [. [ is a symbolic link to test, just to make shell programs more readable. If is also normally a shell builtin (which means that the shell itself will interpret [ as meaning test, even if your Unix environment is set up differently): $ type [ [ is a shell builtin $ which [ /usr/bin/[ $ ls -l /usr/bin/[ lrwxrwxrwx 1 root root 4 Mar 27 2000 /usr/bin/[ -> test This means that '[' is actually a program, just like ls and other programs, so it must be surrounded by spaces: if [$foo == "bar" ] will not work; it is interpreted as if test$foo == "bar" ], which is a ']' without a beginning '['. Put spaces around all your operators I've highlighted the mandatory spaces with the word 'SPACE' - replace 'SPACE' with an actual space; if there isn't a space there, it won't work: if SPACE [ SPACE "$foo" SPACE == SPACE "bar" SPACE ] Test is a simple but powerful comparison utility. For full details, run man test on your system, but here are some usages and typical examples. Test is most often invoked indirectly via the if and while statements. It is also the reason you will come into difficulties if you create a program called test and try to run it, as this shell builtin will be called instead of your program! The syntax for if...then...else... is: if [ ... ] then # if-code else # else-code fi Note that fi is if backwards! This is used again later with case and esac. Also, be aware of the syntax - the "if [ ... ]" and the "then" commands must be on different lines. Alternatively, the semicolon ";" can separate them:

Prepared By |Mr. Neelamani Samal 24

if [ ... ]; then # do something fi You can also use the elif, like this: if [ something ]; then echo "Something" elif [ something_else ]; then echo "Something else" else echo "None of the above" fi This will echo "Something" if the [ something ] test succeeds, otherwise it will test [ something_else ], and echo "Something else" if that succeeds. If all else fails, it will echo "None of the above". Try the following code snippet, before running it set the variable X to various values (try -1, 0, 1, hello, bye, etc). You can do this as follows $ X=5 $ export X $ ./test.sh ... output of test.sh ... $ X=hello $ ./test.sh ... output of test.sh ... $ X=test.sh $ ./test.sh ... output of test.sh ... Then try it again, with $X as the name of an existing file, such as /etc/hosts.

test.sh #!/bin/sh if [ "$X" then echo "X fi if [ "$X" echo "X fi -lt "0" ] is less than zero" -gt "0" ]; then is more than zero"

Prepared By |Mr. Neelamani Samal 25

[ "$X" -le "0" ] && \ echo "X is less than or equal to zero" [ "$X" -ge "0" ] && \ echo "X is more than or equal to zero" [ "$X" = "0" ] && \ echo "X is the string or number \"0\"" [ "$X" = "hello" ] && \ echo "X matches the string \"hello\"" [ "$X" != "hello" ] && \ echo "X is not the string \"hello\"" [ -n "$X" ] && \ echo "X is of nonzero length" [ -f "$X" ] && \ echo "X is the path of a real file" || \ echo "No such file: $X" [ -x "$X" ] && \ echo "X is the path of an executable file" [ "$X" -nt "/etc/passwd" ] && \ echo "X is a file which is newer than /etc/passwd"

Note that we can use the semicolon (;) to join two lines together. This is often done to save a bit of space in simple ifstatements. The backslash simply tells the shell that this is not the end of the line, but the two (or more) lines should be treated as one. This is useful for readability. It is customary to indent the following line. As we see from these examples, test can perform many tests on numbers, strings, and filenames. Thanks to Aaron for pointing out that -a, -e (both meaning "file exists"), -S (file is a Socket), nt (file is newer than), -ot(file is older than), -ef (paths refer to the same file) and -O (file is owned my user), are not available in the traditional Bourne shell (eg, /bin/sh on Solaris, AIX, HPUX, etc). There is a simpler way of writing if statements: The && and || commands give code to run if the result is true. #!/bin/sh [ $X -ne 0 ] [ -f $X ] && [ -n $X ] && echo "X

&& echo "X echo "X is echo "X is is of zero

isn't zero" || echo "X is zero" a file" || echo "X is not a file" of non-zero length" || \ length"

Prepared By |Mr. Neelamani Samal 26

This syntax is possible because there is a file (or shell-builtin) called [ which is linked to test. Be careful using this construct, though, as overuse can lead to very hard-to-read code. The if...then...else... structure is much more readable. Use of the [...] construct is recommended for while loops and trivial sanity checks with which you do not want to overly distract the reader. Note that when you set X to a non-numeric value, the first few comparisons result in the message: test.sh: test.sh: test.sh: test.sh: [: [: [: [: integer integer integer integer expression expression expression expression expected expected expected expected before before before before -lt -gt -le -ge

This is because the -lt, -gt, -le, -ge, comparisons are only designed for integers, and do not work on strings. The string comparisons, such as != will happily treat "5" as a string, but there is no sensible way of treating "Hello" as an integer, so the integer comparisons complain. If you want your shell script to behave more gracefully, you will have to check the contents of the variable before you test it - maybe something like this: echo -en "Please guess the magic number: " read X echo $X | grep "[^0-9]" > /dev/null 2>&1 if [ "$?" -eq "0" ]; then # If the grep found something other than 0-9 # then it's not an integer. echo "Sorry, wanted a number" else # The grep found only 0-9, so it's an integer. # We can safely do a test on it. if [ "$X" == "7" ]; then echo "You entered the magic number!" fi fi In this way you can echo a more meaningful message to the user, and exit gracefully. The $? variable is explained inVariables - Part II, and grep is a complicated beast, so here goes: grep [0-9] finds lines of text which contain digits (0-9) and possibly other characters, so the caret (^) in grep [^0-9] finds only those lines which don't consist only of numbers. We can then take the opposite (by acting on failure, not success). Okay? The >/dev/null 2>&1 directs any output or errors to the special "null" device, instead of going to the user's screen. Many thanks to Paul Schermerhorn for correcting me - this page used to claim that grep -v [0-9] would work, but this is clearly far too simplistic. We can use test in while loops as follows:

Prepared By |Mr. Neelamani Samal 27

test2.sh #!/bin/sh X=0 while [ -n "$X" ] do echo "Enter some text (RETURN to quit)" read X echo "You said: $X" done

This code will keep asking for input until you hit RETURN (X is zero length). Thanks to Justin Heath for pointing out that the script didn't work - I'd missed out the quotes around $X in the while [ -n "$X" ]. Without those quotes, there is nothing to test when $X is empty. Alexander Weber has pointed out that running this script will end untidily: $ ./test2.sh Enter some text (RETURN to quit) fred You said: fred Enter some text (RETURN to quit) wilma You said: wilma Enter some text (RETURN to quit) You said: $ This can be tidied up with another test within the loop: #!/bin/sh X=0 while [ -n "$X" ] do echo "Enter some text (RETURN to quit)" read X if [ -n "$X" ]; then echo "You said: $X" fi done Note also that I've used two different syntaxes for if statements on this page. These are:

Prepared By |Mr. Neelamani Samal 28

if [ "$X" -lt "0" ] then echo "X is less than zero" fi .......... and ........

if [ ! -n "$X" ]; then echo "You said: $X" fi You must have a break between the if statement and the then construct. This can be a semicolon or a newline, it doesn't matter which, but there must be one or the other between the if and the then. It would be nice to just say: if [ ! -n "$X" ] echo "You said: $X"

Case
The case statement saves going through a whole set of if .. then .. else statements. Its syntax is really quite simple: talk.sh #!/bin/sh echo "Please talk to me ..." while : do read INPUT_STRING case $INPUT_STRING in hello) echo "Hello yourself!" ;; bye) echo "See you again!" break ;; *) echo "Sorry, I don't understand" ;; esac done echo echo "That's all folks!"

Prepared By |Mr. Neelamani Samal 29

Okay, so it's not the best conversationalist in the world; it's only an example! Try running it and check how it works... $ ./talk.sh Please talk to me ... hello Hello yourself! What do you think of politics? Sorry, I don't understand bye See you again! That's all folks! $ The syntax is quite simple: The case line itself is always of the same format, and it means that we are testing the value of the variable INPUT_STRING. The options we understand are then listed and followed by a right bracket, as hello) and bye). This means that if INPUT_STRING matches hello then that section of code is executed, up to the double semicolon. If INPUT_STRING matches bye then the goodbye message is printed and the loop exits. Note that if we wanted to exit the script completely then we would use the command exit instead of break. The third option here, the *), is the default catch-all condition; it is not required, but is often useful for debugging purposes even if we think we know what values the test variable will have. The whole case statement is ended with esac (case backwards!) then we end the while loop with a done. That's about as complicated as case conditions get, but they can be a very useful and powerful tool. They are often used to parse the parameters passed to a shell script, amongst other uses.

foo=sun echo $fooshine echo ${foo}shine

# $fooshine is undefined # displays the word "sunshine"

That's not all, though - these fancy brackets have a another, much more powerful use. We can deal with issues of variables being undefined or null (in the shell, there's not much difference between undefined and null).

Prepared By |Mr. Neelamani Samal 30

Using Default Values

Consider the following code snippet which prompts the user for input, but accepts defaults: #!/bin/sh echo -en "What is your name [ `whoami` ] " read myname if [ -z "$myname" ]; then myname=`whoami` fi echo "Your name is : $myname" The "-en" to echo tells it not to add a linebreak. On some systems, you use a "\c" at the end of the line, instead. This script runs like this: steve$ ./name.sh What is your name [ steve ] Your name is : steve ... or, with user input: steve$ ./name.sh What is your name [ steve ] foo Your name is : foo This could be done better using a shell variable feature. By using curly braces and the special ":-" usage, you can specify a default value to use if the variable is unset: echo -en "What is your name [ `whoami` ] " read myname echo "Your name is : ${myname:-`whoami`}" This could be considered a special case - we're using the output of the whoami command, which prints your login name (UID). The more canonical example is to use fixed text, like this: echo "Your name is : ${myname:-John Doe}" As with other use of the backticks, `whoami` runs in a subshell, so any cd commands, or setting any other variables, within the backticks, will not affect the currently-running shell.

Using and Setting Default Values

There is another syntax, ":=", which sets the variable to the default if it is undefined: echo "Your name is : ${myname:=John Doe}" This technique means that any subsequent access to the $myname variable will always get a value, either entered by the user, or "John Doe" otherwise.

Prepared By |Mr. Neelamani Samal 31

Functions
One often-overlooked feature of Bourne shell script programming is that you can easily write functions for use within your script. This is generally done in one of two ways; with a simple script, the function is simply declared in the same file as it is called. However, when writing a suite of scripts, it is often easier to write a "library" of useful functions, and source that file at the start of the other scripts which use the functions. This will be shown later. The method is the same however it is done; we will primarily be using the first way here. The second (library) method is basically the same, except that the command . ./library.sh goes at the start of the script. There could be some confusion about whether to call shell functions procedures or functions; the definition of a function is traditionally that is returns a single value, and does not output anything. A procedure, on the other hand, does not return a value, but may produce output. A shell function may do neither, either or both. It is generally accepted that in shell scripts they are called functions. A function may return a value in one of four different ways: Change the state of a variable or variables Use the exit command to end the shell script Use the return command to end the function, and return the supplied value to the calling section of the shell script echo output to stdout, which will be caught by the caller just as c=`expr $a + $b` is caught

This is rather like C, in that exit stops the program, and return returns control to the caller. The difference is that a shell function cannot change its parameters, though it can change global parameters. A simple script using a function would look like this:

function.sh
#!/bin/sh # A simple script with a function... add_a_user() { USER=$1 PASSWORD=$2 shift; shift; # Having shifted twice, the rest is now comments ... COMMENTS=$@

Prepared By |Mr. Neelamani Samal 32

echo echo echo echo }

"Adding user $USER ..." useradd -c "$COMMENTS" $USER passwd $USER $PASSWORD "Added user $USER ($COMMENTS) with pass $PASSWORD"

### # Main body of script starts here ### echo "Start of script..." add_a_user bob letmein Bob Holness the presenter add_a_user fred badpassword Fred Durst the singer add_a_user bilko worsepassword Sgt. Bilko the role model echo "End of script..."

Line 4 identifies itself as a function declaration by ending in (). This is followed by {, and everything following to the matching } is taken to be the code of that function. This code is not executed until the function is called. Functions are read in, but basically ignored until they are actually called. Note that for this example the useradd and passwd commands have been prefixed with echo this is a useful debugging technique to check that the right commands would be executed. It also means that you can run the script without being root or adding dodgy user accounts to your system! We have been used to the idea that a shell script is executed sequentially. This is not so with functions. In this case, the function add_a_user is read in and checked for syntax, but not executed until it is explicitly called. Execution starts with the echo statement "Start of script...". The next line, add_a_user bob letmein Bob Holness is recognised as a function call so the add_a_user function is entered and starts executing with certain additions to the environment: $1=bob $2=letmein $3=Bob $4=Holness $5=the $6=presenter So within that function, $1 is set to bob, regardless of what $1 may be set to outside of the function. So if we want to refer to the "original" $1 inside the function, we have to assign a name to it -

Prepared By |Mr. Neelamani Samal 33

such as: A=$1 before we call the function. Then, within the function, we can refer to $A. We use the shift command again to get the $3 and onwards parameters into $@. The function then adds the user and sets their password. It echoes a comment to that effect, and returns control to the next line of the main code.

Scope of Variables
Programmers used to other languages may be surprised at the scope rules for shell functions. Basically, there is no scoping, other than the parameters ($1, $2, $@, etc). Taking the following simple code segment:

#!/bin/sh myfunc() { echo "I was called as : $@" x=2 } ### Main script starts here echo "Script was called with $@" x=1 echo "x is $x" myfunc 1 2 3 echo "x is $x"

The script, when called as scope.sh a b c, gives the following output: Script was called with a b c x is 1 I was called as : 1 2 3 x is 2

The $@ parameters are changed within the function to reflect how the function was called. The variable x, however, is effectively a global variable - myfunc changed it, and that change is still effective when control returns to the main script.

Prepared By |Mr. Neelamani Samal 34

A function will be called in a sub-shell if its output is piped somewhere else - that is, "myfunc 1 2 3 | tee out.log" will still say "x is 1" the second time around. This is because a new shell process is called to pipe myfunc(). This can make debugging very frustrating; Astrid had a script which suddenly failed when the "| tee" was added, and it is not immediately obvious why this must be. The tee has to be started up before the function to the left of the pipe; with the simple example of "ls | grep foo", then grep has to be started first, with its stdin then tied to the stdout of ls once lsstarts. In the shell script, the shell has already been started before we even knew we were going to pipe through tee, so the operating system has to start tee, then start a new shell to call myfunc(). This is frustrating, but well worth being aware of. Functions cannot change the values they have been called with, either - this must be done by changing the variables themselves, not the parameters as passed to the script. An example shows this more clearly:

#!/bin/sh myfunc() { echo "\$1 is $1" echo "\$2 is $2" # cannot change $1 - we'd have to say: # 1="Goodbye Cruel" # which is not a valid syntax. However, we can # change $a: a="Goodbye Cruel" } ### Main script starts here a=Hello b=World myfunc $a $b echo "a is $a" echo "b is $b"

This rather cynical function changes $a, so the message "Hello World" becomes "Goodbye Cruel World".

Recursion
Functions can be recursive - here's a simple example of a factorial function:

Prepared By |Mr. Neelamani Samal 35

factorial.sh
#!/bin/sh factorial() { if [ "$1" -gt "1" ]; then i=`expr $1 - 1` j=`factorial $i` k=`expr $1 \* $j` echo $k else echo 1 fi }

while : do echo "Enter a number:" read x factorial $x done

common.lib
# common.lib # Note no #!/bin/sh as this should not spawn # an extra shell. It's not the end of the world # to have one, but clearer not to. # STD_MSG="About to rename some files..." rename() { # expects to be called as: rename .txt .bak FROM=$1 TO=$2 for i in *$FROM do j=`basename $i $FROM` mv $i ${j}$TO

Prepared By |Mr. Neelamani Samal 36

done }

function2.sh
#!/bin/sh # function2.sh . ./common.lib echo $STD_MSG rename txt bak

function3.sh
#!/bin/sh # function3.sh . ./common.lib echo $STD_MSG rename html html-bak

Here we see two user shell scripts, function2.sh and function3.sh, each sourceing the common library file common.lib, and using variables and functions declared in that file. This is nothing too earth-shattering, just an example of how code reuse can be done in shell programming.

Displaying and Printing Files:

These commands allow you to see the contents of a file.

Cat

to display a text file or to concatenate files displays contents of file1 on the screen (or cat file1 window) without any screen breaks. displays contents of file1 followed by file2 on cat file1 file2 the screen (or window) without any screen breaks. creates file3 containing file1 followed cat file1 file2 > file3 by file2. to show the differences between two files displays any lines in ABC or DEF that differ from diff ABC DEF each other. to print a file with filename, date, and page number enscript -Pxxx -2rG ABC prints out the contents of file ABC on the printer Prepared By |Mr. Neelamani Samal 37

Diff

enscript

named xxx with two columns per page (-2), rotated 90 degrees (-r) so that it appears in a landscape format, with a gaudy heading (-G) as a shaded bar across the top that provides the filename (ABC), the creation date of that file, and the page number.
Lpr

to print a file
lpr -Pxxx ABC DEF

prints out the contents of the file ABC followed by the contents of the file DEF on printer xxx.

more

to display a file, screen by screen; to list the contents of a file to the terminal screen (or window) displays the two files ABC and DEF sequentially more ABC DEF on the screen. Hitting the space bar moves down one screen; the return key moves down one line. to paginate a file before printing it (to pretty it) breaks the contents of the files ABC and DEF into pages, puts a heading on the top of each file with pr ABC DEF the name of the file, the date and time, and a page number. The two files are numbered independently. The result goes to the screen. paginates the file ABC and sends the resultant file to be printed on xxx. This is an example of a Unix command that uses a pipe) (`|'); that is, the pr ABC | lpr Pxxx standard output of the first part of the command (before the pipe `|') is piped to (is treated as the standard input for) the second part. to perform a spelling check on a file; to list words found in the file that are not in the Unix spelling dictionary; Note: often lists words that are hyphenated (split across two lines)

pr

spell

Conclusion :-

Prepared By |Mr. Neelamani Samal 38

Laboratory Experiment No 3 :Objective :Learn the vi Editor and Programs on process creation.

Theory:The UNIX full screen editor `vi' is a tightly designed editing system in which almost every letter has a function and the function is stronger for upper than lower case. However, a letter and its actual function are usually closely related. It is important to remember that the `(Esc)' escape key ends most functions and a `(Esc), (Esc)' double application certainly ends the function with the ring of a bell. The subcommand `u' undoes the last function (presumably an error). Use `:q! (CR)' to end with out saving, especially in hopeless situations. Use `:wq (CR)' to resave and end {`ZZ' also resaves and ends, but will not resave if the file has been saved in another file and no further changes have been made}, or `:w (CR)' to only resave. The character `:' prompts the UNIX line editor `ex' which you can think of as being embedded in `vi'. Some of the above critical `vi' subcommands are repeated below with others. Most `vi' subcommands are not displayed when used and do not take a carriage return `(CR)'. The fact that most keys have a meaning both as single characters and as concatenations of several characters has many benefits, but has disadvantages in that mistakes can turn out to be catastrophic. {Remember that `(Esc), (Esc), u' key sequence!} {WARNING: `VI' is disabled during an IBM Telnet session.} (Esc) : End a command; especially used with insert `i', append `a' or replace 'R'. (Esc), (Esc) : Ensured end of a command with bell; press the Escape-key twice; use it. u : Undoes last command; usually used after `(Esc)' or `(Esc), (Esc)'; if undoing is worse then repeat `u' again to undo the undoing. :set all (CR) : Display all vi options. Use this ex command when your initial vi session is poor. Customized options are placed in the `.exrc' ex resource configuration profile. :w (CR) : Save or resave the default file being edited, but do not end.
Prepared By |Mr. Neelamani Samal 39

:w [file] (CR) : Save into a new file [file], but do not end. :w! [file] (CR) : Save or resave into an existing file [file], but do not end. :q (CR) : Quit vi without saving, provided no changes have been made since the last save. :q! (CR) : Quit vi without saving, living the file as it was in the last save. :wq (CR) : Save the default file being edited, and quit. ZZ : Save the edited file, provided not changes have been made since the last save of the edited file to any file, and quit `vi'. {Warning: if you just saved the edited file into any other file, the file will NOT be resaved. `:wq (CR) is much safer to use.} h or j or k or l : The arrow keys, such that
k = up ^ | h = left <-- --> right = l | v j = down

each take a number prefix that moves the cursor that many times. (CR) : moves cursor a line forward; `+' also does. -- : Moves cursor a line backward. [N] (CR) : Moves cursor [N] lines forwards. [N]-- : Moves cursor [N] lines backwards. Ctrl-f : Moves cursor a page forward. Ctrl-b : Moves cursor a page backward. Ctrl-d : Moves cursor a half page down. Ctrl-u : Moves cursor a half page up. [L]G : Go to line [L]. `1G' moves the cursor to the beginning of the file (BOF).
Prepared By |Mr. Neelamani Samal 40

G : Go to the last line just before the end of file (EOF) mark. `$G' does the same thing. 0 : Go to beginning of the line (BOL). ^ : Go to beginning of the nonblank part of the line (BOL). ~ : Got to first nonblank character on a line. $ : Go to end of the line (EOL). [N]| : Go to column [N] of the current line. % : Find the matching parenthesis. /[string] (CR) : Find the next occurrence of `[string]' forwards. Use `n' to repeat, or `N' to search backwards. ?[string] (CR) : Find the next occurrence of` [string]' backwards. n : Repeat last `/[string] (CR)' or `?[string] (CR)'; think of the file as being wrapped around from end to beginning, so that when you return to the start you know that you have found all occurrences. N : Repeat last `/[string] (CR)' or `?[string] (CR)', but in reverse. . : Repeat last change. This is best used along with the repeat search `n' or `N'. i[string](Esc) : Insert a string `[string]' before current character at the cursor; the subcommand `i' itself and other subcommands are not displayed; a `(CR)' in the string during the insert is used to continue input on additional lines; end with the escape key `(Esc)' or `(Esc), (Esc)'. o[string](Esc) : Opens a new line below the current line for insertion of string `[string]'; end with `(Esc)' or `(Esc), (Esc)'; use for POWER TYPING input for an old or new file; `O[string](Esc)' opens a new line above the current line for insertion. I[string](Esc) : Insert a string at the beginning of the current line (BOL), else is like insert `i';a `(CR)' in the string during the insert is used to continue input on additional lines; end with `(Esc)' or `(Esc), (Esc)'.
Prepared By |Mr. Neelamani Samal 41

J : Joins next line to current line. a[string](Esc) : Appends a string `[string]' following the current character at the cursor, else it works like insert `i'; use `(CR)' in the string to continue input onto new lines; end with `(Esc)'; also use for POWER TYPING. A[string](Esc) : Appends a string `[string]' at the end of a line (EOL), works like `i' or `a'; use `(CR)' in the string to continue input onto new lines; end with `(Esc)'; also use for POWER TYPING. r[C](SPACE) : Replace a single character over the cursor by the single character [C]; finalize with the Space-bar. R[string](Esc) : Replace a string of characters by `[string]' in until `(Esc)' is typed to end. s[string](Esc) : Substitutes the string `[string]' for the single character at the cursor. The multiple form `[N]s[string](Esc)' substitutes `[string]' for the `[N]' characters starting at the cursor. x : Delete the current character at the cursor. d(SPACE) : Deletes a single character. `[N]d(SPACE)' deletes `[N]' characters. dd : Deletes the current line. `[N]dd' deletes `[N]' lines. D : Deletes from the cursor to the end of line (EOL). dw : Deletes the current word; `[N]dw' deletes `[N]' words. w : Move cursor to the beginning of the next word. `[N]w' moves the cursor `[N]' words forward. `[N]b' moves it `[N]' words backward. `[N]e' moves it to the end of the word. [N]y(SPACE) : Yanks `[N]' characters starting at the cursor and puts them into the default buffer. `[N]yy' yanks `[N]' lines. p : Puts the current contents of the default buffer after the cursor if characters or after the current line if lines. Helpful to use right after a character yank `y' or a character delete `d' or a line yank `yy' or a line delete `dd', along with a search `/[string](CR)' or repeat search `n'. and a
Prepared By |Mr. Neelamani Samal 42

repeat change `.'. `P' puts the contents of the default buffer before the current line. "b[N]Y : Yank [N] lines starting with the current line to the buffer labeled b; the double quote {"} is used to avoid an id conflict with subcommand names; any letter other than `x' can be used to name the buffer; safer than the line yank `yy' because it is very easy to accidentally change the default buffer. "b[N]dd : Deletes [N] lines starting with the current line to the buffer labeled `b'. "bp : Put back lines from the buffer labeled `b' after or below the cursor; use after a yank or delete to a labeled buffer to move groups of lines from one location to another.

Directory Manipulation
Pwd cd dir.1 mkdir dir.1 rmdir dir.1 rm -r dir.1 cp -r dir.1 dir.2 mv file.1 dir.1 show the directory that you are in (present working directory) change directory to dir.1 make new directory dir.1

remove EMPTY directory dir.1 remove directory dir.2 AND its contents copy dir.1 (and its contents) to dir.2 move file.1 to dir.1 show contents of current directory. Variations: ls dir.1 shows contents of dir.1 Ls ls -d dir.1 shows PRESENCE of dir.1 show sum of size (in kilobytes) of dir.1 and its contents du -sk dir.1 tar -cvf dir.1.tar dir.1 store an image of dir.1 and it's contents in file file.1

Process Control
command1& ps -ef kill pid1 <control-c> <control-z> jobs execute command1 in background print expanded list of all processes remove process pid1 interrupt current process suspend current process display background and suspended processes Prepared By |Mr. Neelamani Samal 43

/* Program to illustrate Inter Process Communication */

#include <stdio.h> #include <types.h> #include <unistd.h> #include <stdlib.h> int main() { int pfd[2], i; pid_t mypid; if(pipe(pfd) < 0) perror(Pipe Error); if(!fork()) { char data; printf(Enter a Number\n); scanf(%d, &data); write(pfd[1], &data, 1); mypid = getpid(); printf(I am process %d\n, mypid); printf(My parent is process %d\n, getppid()); printf(Child Exiting\n); exit(0); } else { char data1; read(pfd[0], &data1, 1); printf(Received %d from child \n, data1); printf(The odd numbers are \n); for(i=1; i<=data1; i+=2) { printf(%5d, i); sleep(2); } printf(\n Parent Exiting\n); exit(0); } return(0); }

Conclusion :-

Prepared By |Mr. Neelamani Samal 44

Laboratory Experiment 4 :Objective :

Learn how to link C Language in UNIX and Programs on UNIX System calls

cc -o run [file].c : Compiles source [file].c, using the standard C compiler and producing an executable named run. cc -c [file].c : Compiles source [file].c, using the standard C compiler `scc2.0' and producing an object file named [file].o.

UNIX System Calls:A system call is just what its name implies -- a request for the operating system to do something on behalf of the user's program. The system calls are functions used in the kernel itself. To the programmer, the system call appears as a normal C function call. However since a system call executes code in the kernel, there must be a mechanism to change the mode of a process from user mode to kernel mode. The C compiler uses a predefined library of functions (the C library)that have the names of the system calls. The library functions typically invoke an instruction that changes the process execution mode to kernel mode and causes the kernel to start executing code for system calls. The instruction that causes the mode change is often referred to as an "operating system trap" which is a software generated interrupt .The library routines execute in user mode, but the system call interface is a special case of an interrupt handler. The library functions pass the kernel a unique number per system call in a machine dependent way --either as a parameter to the operating system trap, in a particular register, or on the stack -- and the kernel thus determines the specific system call the user is invoking. In handling the operating system trap, the kernel looks up the system call number in a table to find the address of the appropriate kernel routine that is the entry point for the system call and to find the number of parameters the system call expects. The kernel calculates the (user) address of the first parameter to the system call by adding (or subtracting, depending on the direction of stack growth) an offset to the user stack pointer, corresponding to the number of the parameters to the system call. Finally, it copies the user parameters to the "u area" and call the appropriate system call routine. After executing the code for the system call, the kernel determines whether there was an error. If so ,it adjusts register locations in the saved user register context ,typically setting the "carry" bit for the PS (processor status) register and copying the error number into register 0 location. If there were no errors in the execution of the system call, the kernel clears the "carry" bit in the PS register and copies the appropriate return values from the system call into the locations for registers 0 and 1 in the saved user register context. When the kernel returns from the operating system trap to user mode, it returns to the library instruction afterthe trap instruction. The library interprets the return values from the kernel and returns a value to the user program. UNIX system calls are used to manage the file system, control processes, and to provide inter process communication. The UNIX system interface

Prepared By |Mr. Neelamani Samal 45

consists of about 80 system calls (as UNIX evolves this number willincrease).The following table lists about 40 of the more important system call:

GENERAL CLASS File Structure Related Calls

SPECIFIC CLASS Creating a Channel

SYSTEM CALL

creat() open() close() Input/Output read() write() Random Access lseek() Channel Duplication dup() Aliasing and Removing link() Files unlink() File Status stat() fstat() Access Control access() chmod() chown() umask() Device Control ioctl() --------------------------------------------------------------------Process Related Process Creation and exec() Calls Termination fork() wait() exit() Process Owner and Group getuid() geteuid() getgid() getegid() Process Identity getppid() signal() kill() alarm() Change Working Directory chdir() ---------------------------------------------------------------------Interprocess Pipelines pipe() Communication Messages msgget() msgsnd() msgrcv() msgctl() Semaphores semget() semop() Shared Memory shmget() shmat() shmdt() Process Control getpid()

Prepared By |Mr. Neelamani Samal 46

/* errmsg1.c print all system error messages using "perror()" */ #include <stdio.h> int main() { int i; extern int errno, sys_nerr; for (i = 0; i < sys_nerr; ++i) { fprintf(stderr, "%3d",i); errno = i; perror(" "); } exit (0); }

/* errmsg2.c print all system error messages using the global error message table. */ #include <stdio.h> int main() { int i; extern int sys_nerr; extern char *sys_errlist[]; fprintf(stderr,"Here are the current %d error messages:\n\n",sys_nerr); for (i = 0; i < sys_nerr; ++i) fprintf(stderr,"%3d: %s\n", i, sys_errlist[i]); }

Conclusion :-

Prepared By |Mr. Neelamani Samal 47