1.

Displaying all lines between specified line numbers

Aim: Write a shell script that accepts a file name, starting and ending line numbers
as arguments and displays all the lines between the given line numbers.

Algorithm:
1. Start
2. Get file name as first argument

3. Get starting ending line numbers as second & third arguments

4. Display the lines from starting line number to ending line number in specified file
using sed command
5. Stop.

Input:

$cat >file.dat

This is first shell program

For displaying
The lines between
The given numbers

Shell script:

sed -n ''$2,$3'p' $1

Execution:

$sh f1.sh emp.lst 2 4

Output:

For displaying
The lines between
The given numbers

Conclusion: the shell script is successfully executed for displaying specified lines in
a file.

2. Deleting a word from list of files

Aim: Write a shell script that deletes all lines containing a specified word in one or
more files supplied as arguments to it.

Algorithm:
1. Start
2. Get the file names as command line arguments
3. Write Enter the word to search & delete:
4. Read word
5. for each argument repeat step6 to step8
6. if it is file then go to next step else display error in file
7. search the lines not contain specified word

8. Write the above result into same file

9. Stop.

Input:
$cat >a.txt
hi
hello
how are you
$cat >b.txt
hello
where are you
bye

Shell script:
$vi f2.sh
echo "Enter word to search and delete:"
read word
while [ $# -gt 0 ]
do
if [ -f $1 ]
then
grep -v $word $1|cat >$1
else
echo error in file $1
fi

shift 1
done
Execution:
$sh f2.sh a.txt b.txt
Enter the word to search and delete: hello
output:
$cat a.txt
hi
how are you
$cat b.txt
where are you
bye

Conclusion: the awk script is successfully executed for is deleting specified word in a
list of files.

3. Displaying read,write and executable files

Aim: Write a shell script that displays a list of all the files in the current directory to
which the user has read, write and execute permissions.

Algorithm:
1. Start
2. For each file in current directory repeat step.3 to steps.5
3. Check it is readable
4. Check it is writeable
5. Check it is executable

6. If it satisfies the steps 3,4,5 then display file name else skip the file.
7. Stop.

Input:
$ls l
-rwxrwxrwx 1 root root 0 Nov 17 17:38 a.txt
-rwxrwx--- 1 root root 0 Nov 17 17:39 b.txt
-r-------- 1 root root 0 Nov 17 17:40 c.txt
drwx------ 1 root root 0 Nov 18 17:46 sub

Shell script:
echo "the read,write,execution files are:"
for file in *
do
if [ -r $file ]
then
if [ -w $file ]
then
if [ -x $file ]
then
echo "$file"
fi
fi
fi

done

Execution:
$sh f3.sh

output:

the read, write, execution files are:

a.txt
b.txt
sub

Conclusion: the shell script is successfully executed for is displaying

read,write,executionfiles in a directory.

4.

Finding file or directory

Aim: Write a shell script that receives any number of file names as arguments
checks if every argument supplied is a file or a directory and reports accordingly.
Whenever the argument is a file, the number of lines on it is also reported.

Algorithm:
1. Start
2. Read file names as command line arguments
3. For each argument do step.5 to step.7

4. If given argument is a directory name then display it is directory.

5. if given argument is a ordinary file name then display it is file
6. if given argument is ordinary file then count number of lines in file
7. Display the count in the screen.
8. Stop.

Input:
$touch l.txt
$cat >m.txt
This
Linux
Shell program.
$mkdir sub

shell script:

$vi f4.sh

while [ $# -gt 0 ]
do
if [ -f $1 ]
then
echo "$1 is file,contains `cat $1|wc l` lines."
elif [ -d $list ]
then

echo "$1 is directory."

fi
shift 1
done

Execution:
$sh f4.sh l.txt m.txt sub

output:
l.txt is a file contains 0 lines.
m.txt is a file contains 3 lines.
Sub is a directory.

Conclusion: the shell script is successfully executed for displaying file or directory in
list of arguments

5.number of occurrences of each word in list of files

Aim: Write a shell script that accepts a list of file names as its arguments, counts
and reports the occurrence of each word that is present in the first argument file on
other argument files.

Algorithm:
1. Start
2. Get list of file names from command arguments
3. Get a word from first file

4. If the word is end of file then goto step.8

else go to next step.
5. count the occurrences of word in each file.
6. Display the count for each file
7. Go to step.3
8. Stop.

Input:
$cat >list1
mango
banana
pineapple
$cat >list2
mango
banana
$cat >list3
mango
mango
pineapple
Shell script:
$vi f5.sh
file1=$1
shift 1
exec<$file1
while read li
do

echo "$li:"
grep -c "$li" $@
done

Execution:
$sh f5.sh list1 list2 list3
output:
mango:
list2:1
list3:2
banana:
list2:1
list3:0
pineapple:
list2:0
list3:1

Conclusion: the shell script is successfully executed for displaying count of each
word in specified files.

6.Listing directories

Aim: Write a shell script to list all of the directory files in a directory.

Algorithm:
1. Start

2. Write the directories files in current directory are:

3. For each file in current directory do the step.4
4. Check it is directory or not ,if it is directory then print file name
5. Stop.

Input:
$touch a.txt b.txt
$mkdir sub1 sub2
$ls
a.txt b.txt sub1 sub2

Shell script:
Vi f6.sh

echo "the directorys are:"

for file in *
do
if [ -d $file ]
then
echo "$file"
fi
done

Execution:
$sh f6.sh

output:
the directorys are:
sub1 sub2

Conclusion: the shell script is successfully executed for displaying directories in

directory

7. Factorial of a number

Aim: Write a shell script to find factorial of a given integer.

Algorithm:
1. Start
2. Write enter the number:
3. Read n
4. Fact 1
5. i 1
6. if i is less then or equals to n go to next step else go to step.9
7. f f * i
8. Go to step.6 by incrementing i by 1.
9. write the factorial of n is :
10. Displayfact value
11. Stop.

Shell script:
$vi f7.sh

echo "enter the number:"

read num
fact=1
while [ $num -gt 1 ]
do
f=`expr $fact \* $num`;
num=$((num - 1));
done
echo "the factorial of $num is:$fact"

Execution:

$sh f7.sh
output:
enter the number:
5
The factorial of 5 is:120
Conclusion: the shell script is successfully executed for finding factorial of a given
number.

8. Number of lines without vowels

Aim: Write an awk script to count the number of lines in a file that do not contain
vowels.

Algorithm:

1. Start
2. Get the source file name
3. Write the number of lines not contain vowels are :
4. k 0
5. For each row in the source file repeat the step.5 to step.7 until end of the file
6. Check the row contain a or e or i or o or u
7. If the row not contain above characters then increment the c value by 1.
8. Print the k value
9. Stop.

Input:
$cat >list.txt
Cat bat rat
Fly
sky
round the world

Awk script:
$vi f8.awk

BEGIN{
printf "the no of lines not contain vowels are:"
}!/[aA]|[eE]|[Ii]|[Oo]|[Uu]/{
k++
}
END{

printf "%d",k
}

Execution:
$awk f f8.awk list.txt

Output:
The no of lines not contain vowels are:2

Conclusion: the awk script is successfully executed for displaying lines not
containing vowels.

9. counting characters,words,lines

Aim: Write an awk script to find the number of characters, words and lines in a file.

Algorithm:
1. Start
2. Get the source file name
3. Set field separator as (space)
4. Declare c0 ,w0,l0
5. For each row in source file repeat the step.5 to step.7 until end of file.
6. c c + length of row
7. w w + number of fields in row
8. increment the l by 1

9. print characters:, c value

10 .print word:, w value
11.Print lines:, l value
12.Stop.

Input:

cat>list2.txt
Hi how
Are
You
What are you
Doing bye

Awk script:

$vi f9.awk

BEGIN{
FS= " "
}{
c=c+length()
w=w+NF
l++
}
END{

Printf"characters:%d\nwords:%d\nlines%d:",c,w,l}

Execution:

$awk -f f9.awk list2.txt

Output:
Characters:29
Words:9
Line:5

Conclusion: the awk script is successfully executed for counting lines,words,and

characters in a file.

10.Copying file using system calls And standard I/O

Aim: Write a c program that makes a copy of a file using standard I/O and system
calls.
Algorithm:
1. Start
2. Declare src[10],dest[10],ch[2] as strings
3. display enter the src file name:
4. Read src
5. display enter the destination file name:
6. Read dest
7. Open src file in read mode

8. Open dest file in write or create dest file.

9. display src contains:
10.Get the character from src file and store it in ch
11.If it is end of file go to step.14 else go to next step
12.Write ch into dest file
13.Display the ch in the screen.
14.Display file is copied
15.Stop.

using standard I/O:

C source code:
$vi f10.c
#include<stdio.h>
#include<stdlib.h>
int main()
{
char src[10],dest[10],ch;
FILE *fp1,*fp2;
printf("enter the source file name:");
scanf("%s",src);
if((fp1=fopen(src,"r"))==0)
{
printf("error in opening src file");
exit(0);
}
printf("enter the destination file name:");

scanf("%s",dest);
if((fp2=fopen(dest,"w"))==0)
{
printf("error in destination file");
exit(1);
}
printf("%s contains:\n",src);
while((ch=getc(fp1))!=EOF)
{
fputc(ch,fp2);
printf("%c",ch);
}
printf("file is copied.");
fclose(fp1);
fclose(fp2);
return 1;
}

Input:

$cat >abc.txt

Java is a simple, object oriented

And multithreaded.

Execution:

$gcc f10.c o f10

$./f10

Output:
enter the source file name:abc.txt
enter the destination file name:abccpy.txt
abc.txt contains:

Java is a simple, object oriented

And multithreaded.

file is copied.

Verification:
$cat abccpy.txt
Java is a simple, object oriented
And multithreaded.
$

using system call:

C source code:
$vi f10b.c

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>

#include<unistd.h>
int main()
{
char src[10],dest[10],ch[2];
int fd1,fd2,c;
printf("enter the source file name:");
scanf("%s",src);
if((fd1=open(src,O_RDONLY))==-1)
{
printf("error in opening src file");
exit(0);
}
printf("enter the destination file:");
scanf("%s",dest);
if((fd2=open(dest,O_CREAT|O_WRONLY,0700))==-1)
{
printf("error in destination file");
exit(0);
}
printf("%s contains:\n",src);
while(read(fd1,ch,1)==1)
{
write(1,ch,1);
write(fd2,ch,1);
}
printf("file is copied");

close(fd1);
close(fd2);
return 1;
}

Input:

$cat >def.txt
cpp is a object oriented
language.

Execution:
$gcc f10b.c o f10b
$./f10b

Output:
enter the source file name:def.txt
enter the destination file name:defcpy.txt
def.txt contains:

cpp is a object oriented

language.

file is copied.

Verification:
$cat defcpy.txt

cpp is a object oriented

language.
Conclusion: a c program is successfully executed for copying file using system calls
and standard I/O.

11.

Implement in C the following Unix commands using System calls

a)cat
#include<sys/types.h>
#include<sys/stat.h>
#include<stdio.h>
#include<fcntl.h>
main( int argc,char *argv[3] )
{
int fd,i;
char buf[2];
fd=open(argv[1],O_RDONLY,0777);
if(fd==-argc)
{
printf("file open error");
}
else
{
while(i=read(fd,buf,1)>0)
{

printf("%c",buf[0]);
}
close(fd);
}
}
b) mv
#include<sys/types.h>
#include<sys/stat.h>
#include<stdio.h>
#include<fcntl.h>
main( int argc,char *argv[] )
{
int i,fd1,fd2;
char *file1,*file2,buf[2];
file1=argv[1];
file2=argv[2];
printf("file1=%s file2=%s",file1,file2);
fd1=open(file1,O_RDONLY,0777);
fd2=creat(file2,0777);
while(i=read(fd1,buf,1)>0)
write(fd2,buf,1);
remove(file1);
close(fd1);
close(fd2);
}

11(A).IMPLEMENTING CAT COMMAND

Aim: To implement a c program to cat unix command using system call.

Algorithm:
1.start
2.read the file name as first argument.
3.read the character form the given file.
4.display the character in the screen.
5.read the next character from file
6.if it is not end of file the goto step 4 else goto next step
7.stop.

Source code:

#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
int main(int argc,char **argv)
{
char ch[2];
int fd;
fd=open(argv[1],O_RDONLY);

while((read(fd,ch,1))==1)
{
write(1,ch,1);
}
close(fd);
return 1;
}

Execution:
$gcc display.c -o display
$ ./display a.txt
Eno Ename job

salary dob

101 john

sales 10000 12/10/89

103 pavan

sales

2000

15/11/89

Conclusion: a c program is successfully executed for cat unix command using

system call.

11(B).IMPLEMETING LS COMMAND
Aim: To implement a c program to ls unix command using system call.
Algorithm:
1.start
2.declare directory pointer dp;
3.declare an instance of structure dirent as dirp
4.declare p as string variable.
5.if number of arguments==1 then p,<- .else
6.open directory p

p<-second argument

7.read the file name

8.display the file name
9.read next file name
10.if is not null then goto step 7 else goto next step.
11.stop
Source code:
#include<stdio.h>
#include<string.h>
#include<dirent.h>
#include<stdlib.h>
#include<sys/types.h>
int main(int argc ,char **argv)
{
DIR *dp;
struct dirent *dirp;
char p[8];
if(argc==1)
strcpy(p,".");
else
{
strcpy(p,argv[1]);
}
if((dp=opendir(p))==NULL)
{
printf("can't open directoey");
exit(0);

}
while((dirp=readdir(dp))!=NULL)
{
printf("%s\n",dirp->d_name);
}
closedir(dp);
return 1;
}
Execution:
$gcc dirlist.c o dirlist
$./dirlist
.
a.txt
b.txt
sub
..
Conclusion: the ls command is successfully implemented in c.

13. Write a C program to emulate the UNIX ls l command.

ALGORITHM :
Step 1: Include necessary header files for manipulating directory.
Step 2: Declare and initialize required objects.
Step 3: Read the directory name form the user.

Step 4: Open the directory using opendir() system call and report error if the
directory is not
available.
Step 5: Read the entry available in the directory.
Step 6: Display the directory entry ie., name of the file or sub directory.
Step 7: Repeat the step 6 and 7 until all the entries were read.

/* 1. Simulation of ls command */
#include<fcntl.h>
#include<stdio.h>
#include<unistd.h>
#include<sys/stat.h>main()
{
char dirname[10];
DIR *p;
struct dirent *d;
printf("Enter directory name ");
scanf("%s",dirname);
p=opendir(dirname);
if(p==NULL)
{
perror("Cannot find dir.");
exit(-1);
}
while(d=readdir(p))
printf("%s\n",d->d_name);
}

SAMPLE OUTPUT:
enter directory name iii
...f2

14.Listing Inode,File Name

Aim:To write a c programe to list for every file in a directory,its inode number and
file name.

Algorithm:
1.start
2.declare directory pointer dp;
3.declare an instance of structure dirent as dirp
4.declare struct stat instance as buf;
5.write file_name,inode
6.open the directory
7.read the file name
8.extract file information into buf
9.display the file name and its inode number
Using buf varable
10.read next file name
11.if is not null then goto step 7 else goto next step.

12.stop

C source code:
#include<stdio.h>
#include<sys/stat.h>
#include<unistd.h>
#include<stdlib.h>
#include<dirent.h>
int main(int argc,char **argv)
{
DIR *dp;
struct stat buf;
ino_t ino;
struct dirent *dirp;
if(argc!=2)
{
printf("usage:dirname");
exit(1);
}
if((dp=opendir(argv[1]))==NULL)
perror("open:");
printf("\nfile_name inode");
printf("\n----------------");
while((dirp=readdir(dp))!=NULL)
{
stat(dirp->d_name,&buf);

ino=buf.st_ino;
printf("\n %ld %s",ino,dirp->d_name);
}
return 1;
}
Execution:
$gcc ilist.c o ilist
$./ilist sub1
file_name inode
---------------8781826 ..
8781821 sub3
8781827 sub2
8781823 d.tct
8781935 a.txt

15. Write a C program that demonstrates redirection of standard output to a file.

Ex: ls > f1.
Description:
An Inode number points to an Inode. An Inode is a data structure that stores the
following information about a file :

Size of file

Device ID

User ID of the file

Group ID of the file

The file mode information and access privileges for owner, group and others

File protection flags

The timestamps for file creation, modification etc

link counter to determine the number of hard links

Pointers to the blocks storing files contents

16.CREATING CHILD PROCESS

Aim: To write a c program create a child process and allow the parent to display
parent And child to display child.

Algorithm:
1. start
2. Declare pid as pid_t data type.
3.call fork() and pid<---return value of fork()
4. if pid <o then display child process creation error
5.if pid==0 then display child
6. if pid>0 then display parent
7. stop.

Source code:

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

int main()
{
pid_t pid;
pid=fork();
if(pid<0)
{
perror("error in fork:");
}
if(pid==0)
{
printf("\nchild process..");
}
if(pid>0)
{
printf("\nparent process..");
}
}
Execution:
$gcc child.c -o child
$./child
Child
parent
Conclusion:
A c program is successfully executed to display child process as child parent
process as parent.
17.Zombie Process

Aim: To write a c program to create a zombie process.

Algorithm:
1.start
2.delcare pid as pid_t data type.
3.call fork function and pid<-- return value of fork()
4.if pid >0 dispaly parent process.. display pid
5.sleep parent process
6. stop.

C source code:
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
if(fork()>0)
{
printf("parent with %d",getpid());
sleep(10);
}
}

Execution:
$gcc zombie.c o zombie
$./ zombie &
$ps Z
LABEL

PID TTY

STAT TIME COMMAND

user_u:system_r:unconfined_t

3769 pts/1

Ss

0:00 bash

user_u:system_r:unconfined_t

3799 pts/1

0:00 ./zom

user_u:system_r:unconfined_t

3800 pts/1

0:00 [zom] <defunct>

user_u:system_r:unconfined_t

3801 pts/1

R+

0:00 ps Z

$ parent with 3799

Conclusion:
A c programme is successfully executed to create zombie process.

18.Orphan Process

Aim: To write a c program to illustrates a orphan process.

Algorithm:
1. Start
2. Delcare pid as pid_t data type.
3. call fork() and pid<- -return value of fork()
4. if pid==0 then display child process..
5. display parent process id and child process id
6. call sleep() to delay the child process.
7. if pid==1 then display parent process

8. terminate parent the process.

9. terminate the child after the sleep function.
10. Stop.

Source code:
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
pid_t pid;
pid=fork();
if(pid==0)
{
printf("child process...");
printf("process id=%d,parentid=%d",getpid(),getppid());
sleep(15);
printf("termination of child");
}
if(pid>0)
{
printf("parent process:%d",getpid());
printf("termination of parent.");
}
}

Execution:
$gcc orphan.c o orphan
$./orphan
Parent process:3395
Termination of parent
Child process..
Child id:3396 parent id:3395
Termination of child...

Conclusion: the creation of orphan process is successfully executed.

19. Write a C program that illustrates how to execute two commands concurrently
with a
command pipe.
Ex: - ls l | sort
AIM: Implementing Pipes
DESCRIPTION:
A pipe is created by calling a pipe() function.
int pipe(int filedesc[2]);
It returns a pair of file descriptors filedesc[0] is open for reading and
filedesc[1] is
open for writing. This function returns a 0 if ok & -1 on error.

ALGORITHM:
The following is the simple algorithm for creating, writing to and reading from
a
pipe.

1)

Create a pipe through a pipe() function call.

2)

Use write() function to write the data into the pipe. The syntax is as follows

write(int [],ip_string,size);

int [] filedescriptor variable, in this case if int filedesc[2] is the variable, then use
the filedesc[1] as the first parameter.

ip_string The string to be written in the pipe.

Size buffer size for storing the input

3)

Use read() function to read the data that has been written to the pipe.

The syntax is as follows

read(int [], char,size);

PROGRAM:

#include<stdio.h>
#include<string.h>
main()
{
int pipe1[2],pipe2[2],childpid;
if(pipe(pipe1)<0 || pipe(pipe2) < 0)
printf("pipe creation error");
if (( childpid=fork())<0)

{
printf("cannot fork");
}
else
if(childpid >0)
{
close(pipe1[0]);
close(pipe2[1]);
client(pipe2[0],pipe1[1]);
while (wait((int *) 0 ) !=childpid);
close(pipe1[1]);
close(pipe2[0]);
exit(0);
}
else
{
close(pipe1[1]);
close(pipe2[0]);
server(pipe1[0],pipe2[1]);
close(pipe1[0]);
close(pipe2[1]);
exit(0);
}
}
client(int readfd,int writefd)
{

int n;
char buff[1024];
if(fgets(buff,1024,stdin)==NULL)
printf("file name read error");
n=strlen(buff);
if(buff[n-1]=='\n')
n--;
if(write(writefd,buff,n)!=n)
printf("file name write error");
while((n=read(readfd,buff,1024))>0)
if(write(1,buff,n)!=n)
printf("data write error");
if(n<0)
printf("data error");
}
server(int readfd,int writefd)
{
char buff[1024],errmsg[50];
int n,fd;
n=read(readfd,buff,1024);
buff[n]='\0';
if((fd=open(buff,0))<0)
{
sprintf(buff,"file does nit exist");
write(writefd,buff,1024);
}

else
{
while((n=read(fd,buff,1024))>0)
write(writefd,buff,n);
}
}