Jntu Mca Linux Lab Programs
Jntu Mca Linux Lab Programs
Jntu Mca Linux Lab Programs
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
Shell script:
sed -n ''$2,$3'p' $1
Execution:
Output:
For displaying
The lines between
The given numbers
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
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:
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.
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
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
Execution:
$sh f6.sh
output:
7. Factorial of a number
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. Display‘fact’ value
11. Stop.
Shell script:
$vi f7.sh
Execution:
$sh f7.sh
output:
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 c←0 ,w←0,l←0
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:
Output:
Characters:29
Words:9
Line:5
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.
#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
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:
file is copied.
Verification:
$cat abccpy.txt
#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:
file is copied.
Verification:
$cat defcpy.txt
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
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 S 0:00 ./zom
user_u:system_r:unconfined_t 3800 pts/1 Z 0:00 [zom] <defunct>
user_u:system_r:unconfined_t 3801 pts/1 R+ 0:00 ps Z
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:
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.
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 it’s 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
8781932 .