1.
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.
#!/bin/bash
# check if correct number of arguments were passed
if [ $# -ne 3 ]; then
echo "Usage: $0 filename start_line end_line"
exit 1
fi
filename=$1
start_line=$2
end_line=$3
# check if the given file exists
if [ ! -f $filename ]; then
echo "File '$filename' does not exist"
exit 1
fi
# check if the start line number is less than the end line number
if [ $start_line -gt $end_line ]; then
echo "Starting line number should be less than the ending line number"
exit 1
fi
# print the lines between the given line numbers
sed -n "${start_line},${end_line}p" $filename
OUTPUT:
chmod +x display_lines.sh
./display_lines.sh filename.txt 5 10
2.Write a shell script that deletes all lines containing a specified word in one or more files
supplied as arguments to it.
#!/bin/bash
# check if the word to be deleted is provided as argument
if [ $# -eq 0 ]; then
echo "Usage: $0 word_to_delete file1 file2 ..."
exit 1
fi
word_to_delete=$1
shift
# iterate over all the files provided as arguments
for file in "$@"
do
# check if the file exists
if [ ! -f $file ]; then
echo "File '$file' does not exist"
continue
fi
# delete all lines containing the word to be deleted from the file
sed -i "/$word_to_delete/d" $file
done
OUTPUT:
chmod +x delete_lines.sh
./delete_lines.sh word_to_delete file1.txt file2.txt
3. 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.
#!/bin/bash
echo "Files with read, write, and execute permissions:"
echo "-----------------------------------------------"
# iterate over all the files in the current directory
for file in *
do
# check if the file has read, write, and execute permissions for the user
if [ -r $file ] && [ -w $file ] && [ -x $file ]; then
echo $file
fi
done
OUTPUT:
chmod +x permissions.sh
./permissions.sh
4.Write a shell script that receives any number of files names as arguments check if every
argument is a file, the number of lines on it is also reported.
#!/bin/bash
# iterate over all the arguments
for file in "$@"
do
# check if the argument is a file
if [ -f "$file" ]; then
# count the number of lines in the file
num_lines=$(wc -l < "$file")
echo "File: $file has $num_lines lines"
else
echo "$file is not a file"
fi
done
OUTPUT:
chmod +x count_lines.sh
./count_lines.sh file1.txt file2.txt file3.txt
5. Write a shell script to list all of the directory files in a directory.
#!/bin/bash
# check if a directory is provided as argument
if [ $# -eq 0 ]; then
echo "Usage: $0 directory_name"
exit 1
fi
directory_name=$1
# check if the provided directory exists
if [ ! -d $directory_name ]; then
echo "Directory '$directory_name' does not exist"
exit 1
fi
# list all the files (including directories) in the directory
ls -al $directory_name
OUTPUT:
chmod +x list_files.sh
./list_files.sh directory_name
6.Write an awk script to count the number of lines in a file that do not contain vowels
#!/usr/bin/awk -f
BEGIN {
# initialize the line count to zero
count = 0
}
# check each line in the file
{
# check if the line does not contain vowels
if (tolower($0) !~ /[aeiou]/) {
# if the line does not contain vowels, increment the count
count++
}
}
END {
# print the final count
print "Number of lines without vowels: " count
}
OUTPUT:
chmod +x count_lines_without_vowels.awk
cat file.txt | ./count_lines_without_vowels.awk
7. Write a shell script that accepts a list of files names as its arguments,, counts and reports
the occurrence of each word that is present in the first arguments file on other arguments
files.
#!/bin/bash
# check if at least two arguments are provided
if [ $# -lt 2 ]; then
echo "Usage: $0 file1.txt file2.txt file3.txt ..."
exit 1
fi
# extract the first argument file
first_file=$1
# check if the first argument file exists
if [ ! -f $first_file ]; then
echo "File '$first_file' does not exist"
exit 1
fi
# initialize an associative array to store the word counts
declare -A word_counts
# iterate over the remaining argument files
for file in "${@:2}"
do
# check if the argument file exists
if [ ! -f $file ]; then
echo "File '$file' does not exist"
continue
fi
# iterate over each word in the first argument file
while read -r word; do
# count the number of occurrences of the word in the current file
count=$(grep -o "\<$word\>" "$file" | wc -l)
# add the count to the word_counts array
if [ -n "${word_counts[$word]}" ]; then
word_counts[$word]=$((word_counts[$word] + count))
else
word_counts[$word]=$count
fi
done < "$first_file"
done
# print the word counts
for word in "${!word_counts[@]}"
do
echo "$word: ${word_counts[$word]}"
done
OUTPUT:
./count_words.sh file1.txt file2.txt file3.txt
8. Write a program that takes one or more files/directory names as command line input and
reports the following information on the files.file type,Number of links and read,write and
execute permissions
#!/bin/bash
# iterate over each argument
for arg in "$@"
do
# check if the argument is a file or directory
if [ -f "$arg" ]; then
echo "File: $arg"
# display file type
file "$arg"
# display number of links
echo "Number of links: $(stat -c '%h' "$arg")"
# display read, write and execute permissions
echo "Permissions: $(stat -c '%a' "$arg")"
elif [ -d "$arg" ]; then
echo "Directory: $arg"
# display number of links
echo "Number of links: $(stat -c '%h' "$arg")"
# display read, write and execute permissions
echo "Permissions: $(stat -c '%a' "$arg")"
else
echo "$arg is not a file or directory"
fi
done
OUTPUT:
chmod +x file_info.sh
./file_info.sh file1.txt dir1 file2.txt
9. Write a C program to list for every files in a directory, its inode number and files name.
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <sys/stat.h>
int main(int argc, char *argv[]) {
DIR *dir;
struct dirent *entry;
struct stat file_stat;
if (argc != 2) {
fprintf(stderr, "Usage: %s directory_name\n", argv[0]);
exit(EXIT_FAILURE);
}
if ((dir = opendir(argv[1])) == NULL) {
perror("opendir");
exit(EXIT_FAILURE);
}
while ((entry = readdir(dir)) != NULL) {
char filename[1024];
snprintf(filename, 1024, "%s/%s", argv[1], entry->d_name);
if (stat(filename, &file_stat) == -1) {
perror("stat");
continue;
}
printf("%ld %s\n", file_stat.st_ino, entry->d_name);
}
closedir(dir);
return 0;
}
10.Implement in C the following Unix command using System calls cat,ls,mv
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
int main(int argc, char *argv[]) {
int fd1[2], fd2[2];
pid_t pid;
if (pipe(fd1) == -1) {
perror("pipe");
exit(EXIT_FAILURE);
}
pid = fork();
if (pid == -1) {
perror("fork");
exit(EXIT_FAILURE);
}
if (pid == 0) {
// child process
close(fd1[0]);
dup2(fd1[1], STDOUT_FILENO);
execlp("cat", "cat", "file1.txt", NULL);
perror("execlp");
exit(EXIT_FAILURE);
}
if (pipe(fd2) == -1) {
perror("pipe");
exit(EXIT_FAILURE);
}
pid = fork();
if (pid == -1) {
perror("fork");
exit(EXIT_FAILURE);
}
if (pid == 0) {
// child process
close(fd1[1]);
dup2(fd1[0], STDIN_FILENO);
close(fd2[0]);
dup2(fd2[1], STDOUT_FILENO);
execlp("ls", "ls", "-l", NULL);
perror("execlp");
exit(EXIT_FAILURE);
}
close(fd1[0]);
close(fd1[1]);
pid = fork();
if (pid == -1) {
perror("fork");
exit(EXIT_FAILURE);
}
if (pid == 0) {
// child process
close(fd2[1]);
dup2(fd2[0], STDIN_FILENO);
int fd_out = open("output.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
dup2(fd_out, STDOUT_FILENO);
execlp("mv", "mv", "-", NULL);
perror("execlp");
exit(EXIT_FAILURE);
}
close(fd2[0]);
close(fd2[1]);
// wait for all child processes to finish
wait(NULL);
wait(NULL);
wait(NULL);
return 0;
}
11.Write a C program to create a Zombie process.d
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
pid_t pid = fork();
if (pid == -1) {
perror("fork");
exit(EXIT_FAILURE);
}
if (pid == 0) {
// child process
printf("Child process (PID %d) is running.\n", getpid());
exit(EXIT_SUCCESS);
} else {
// parent process
printf("Parent process (PID %d) is exiting without waiting for child (PID %d).\n", getpid(),
pid);
exit(EXIT_SUCCESS);
}
return 0;
}
12.Write C program that illustrate communication between two unrelated processes using named
pipe.Write a C program (sender.c) to create a message queue with read and write permissions to
write 3 messages to it with different priority numbers
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#define FIFO_NAME "/tmp/myfifo"
#define BUFFER_SIZE 1024
int main() {
pid_t pid1, pid2;
int fd;
char buffer[BUFFER_SIZE];
// Create the named pipe
if (mkfifo(FIFO_NAME, 0666) == -1) {
perror("mkfifo");
exit(EXIT_FAILURE);
}
// Fork the first child process (writer)
pid1 = fork();
if (pid1 == -1) {
perror("fork");
exit(EXIT_FAILURE);
}
if (pid1 == 0) {
// Child process 1 (writer)
printf("Writer process (PID %d) is running.\n", getpid());
// Open the named pipe for writing
fd = open(FIFO_NAME, O_WRONLY);
if (fd == -1) {
perror("open");
exit(EXIT_FAILURE);
}
// Write a message to the named pipe
strcpy(buffer, "Hello, world!");
if (write(fd, buffer, strlen(buffer) + 1) == -1) {
perror("write");
exit(EXIT_FAILURE);
}
printf("Writer process (PID %d) wrote message: %s\n", getpid(), buffer);
// Close the named pipe
close(fd);
exit(EXIT_SUCCESS);
}
// Fork the second child process (reader)
pid2 = fork();
if (pid2 == -1) {
perror("fork");
exit(EXIT_FAILURE);
}
if (pid2 == 0) {
// Child process 2 (reader)
printf("Reader process (PID %d) is running.\n", getpid());
// Open the named pipe for reading
fd = open(FIFO_NAME, O_RDONLY);
if (fd == -1) {
perror("open");
exit(EXIT_FAILURE);
}
// Read a message from the named pipe
if (read(fd, buffer, BUFFER_SIZE) == -1) {
perror("read");
exit(EXIT_FAILURE);
}
printf("Reader process (PID %d) read message: %s\n", getpid(), buffer);
// Close the named pipe
close(fd);
exit(EXIT_SUCCESS);
}
// Wait for both child processes to complete
waitpid(pid1, NULL, 0);
waitpid(pid2, NULL, 0);
// Remove the named pipe
if (unlink(FIFO_NAME) == -1) {
perror("unlink");
exit(EXIT_FAILURE);
}
return 0;
}
13.Write a shell script to accept three numbers and display the largest
#!/bin/bash
echo "Enter the first number:"
read num1
echo "Enter the second number:"
read num2
echo "Enter the third number:"
read num3
if [ $num1 -gt $num2 ] && [ $num1 -gt $num3 ]
then
echo "$num1 is the largest number."
elif [ $num2 -gt $num1 ] && [ $num2 -gt $num3 ]
then
echo "$num2 is the largest number."
else
echo "$num3 is the largest number."
fi
OUTPUT:
14.Write a shell script to check if a particular user has logged in or not.
#!/bin/bash
echo "Enter the username you want to check:"
read username
if who | grep -wq $username
then
echo "$username has logged in."
else
echo "$username has not logged in."
fi
15.Write a shell script to check whether a file is existing or not
#!/bin/bash
echo "Enter the file name you want to check:"
read filename
if [ -e "$filename" ]
then
echo "$filename exists."
else
echo "$filename does not exist."
fi
