UNIX PROGRAMMING

Lab Manual
BCA 5th SEM
I. SHELL commands in UNIX

File and Directory Management Commands

1. List Files and Directories

sh
ls # Basic list of files in the current directory
ls -l # Detailed list, including permissions, size, and modification time
ls -a # Show hidden files (files starting with .)

Output

2. Change Directory

sh
cd Documents # Change to the "Documents" directory
cd .. # Go up one directory level
cd ~ # Go to the user's home directory

Output

3. Print Working Directory

sh
pwd # Shows the full path of the current directory

Output

4. Make a New Directory

sh

mkdir new_folder # Create a directory named "new_folder" in the current directory

Output
5. Remove an Empty Directory

sh

rmdir old_folder # Remove an empty directory named "old_folder"

Output

6. Create a New File or Update Timestamp

sh

touch example.txt # Creates an empty file named "example.txt" or updates the timestamp if it exists

Output

7. Copy Files and Directories

sh
cp file1.txt file2.txt # Copy "file1.txt" to a new file named "file2.txt"
cp -r folder1 folder2 # Copy "folder1" and its contents to "folder2"

Output

8. Move or Rename Files and Directories

sh

mv file1.txt newfile.txt # Rename "file1.txt" to "newfile.txt"

mv old_folder new_folder # Rename "old_folder" to "new_folder"

Output

9. Delete a File or Directory

sh
rm unwanted_file.txt # Delete "unwanted_file.txt"
rm -r unwanted_folder # Delete "unwanted_folder" and all its contents recursively

Output
Viewing File Contents

1. Display File Contents

sh
cat file.txt # Show the contents of "file.txt"

Output

2. View File One Screen at a Time

sh
more file.txt # View "file.txt" one screen at a time
less file.txt # View "file.txt" with navigation options

Output

3. Show Beginning and End of File

sh
head file.txt # Display the first 10 lines of "file.txt"
head -n 5 file.txt # Show the first 5 lines of "file.txt"
tail file.txt # Display the last 10 lines of "file.txt"
tail -n 5 file.txt # Show the last 5 lines of "file.txt"

Output

System Information

1. Show Current User

sh
whoami # Display the current user's name

Output

2. System Information

sh
uname -a # Detailed information about the system

Output
 3. Disk Space

sh
df # Show available disk space on file systems
df -h # Disk space in human-readable format (KB, MB, etc.)

Output

4. Running Processes and System Usage

sh
top # Display running processes and system usage in real-time

Output

5. List Processes

sh
ps # List processes running in the current shell
ps aux # Show all running processes with details

Output

Permissions and Ownership

1. Change File Permissions

sh
chmod 755 script.sh # Set permissions to read/write/execute for the owner, read/execute for others

Output

2. Change File Owner and Group

sh
chown user:group file.txt # Change owner and group of "file.txt" to "user" and "group"

Output
Text Print and Manipulation Commands

1. echo – Print simple text or variables to the terminal.

sh
echo "Hello, Unix!" # Print "Hello, Unix!" to the terminal
echo "User: $USER" # Print the value of the environment variable $USER

Output

2. printf – Similar to echo, but allows formatted text (like C’s printf).

sh
printf "Name: %s, Age: %d\n" John 25 # Print formatted output: "Name: John, Age: 25"

Output

3. cat – Concatenate and display files or standard input.

sh
cat file.txt # Print the contents of "file.txt"
cat file1.txt file2.txt # Concatenate and display contents of both files

Output

4. tac – Print file contents in reverse order (last line first).

sh
tac file.txt # Display "file.txt" contents in reverse order

Output

5. nl – Print a file with line numbers.

sh
nl file.txt # Display "file.txt" with line numbers

Output
6. head – Display the first few lines of a file.

sh
head -n 5 file.txt # Print the first 5 lines of "file.txt"

Output

7. tail – Display the last few lines of a file.

sh
tail -n 5 file.txt # Print the last 5 lines of "file.txt"

Output

8. more – View file contents one screen at a time.

sh
more file.txt # Display "file.txt" with pagination

Output

9. less – Similar to more but allows backward navigation.

sh
less file.txt # View "file.txt" with more navigation options

Output

10. awk – A powerful text processing command, often used for parsing and printing specific parts of a file.

sh
awk '{print $1}' file.txt # Print the first field of each line in "file.txt"

Output

11. sed – Stream editor for filtering and transforming text.

sh
sed 's/old/new/g' file.txt # Replace "old" with "new" in "file.txt"

Output
 12. grep – Search for patterns in text and print matching lines.

sh
grep "pattern" file.txt # Print lines in "file.txt" that match "pattern"

Output

13. echo -e – Allows escape sequences for formatted text.

sh
echo -e "Line1\nLine2\nLine3" # Print multiple lines

Output

14. Combine commands to create complex output:

sh
echo "Today is $(date)" # Use command substitution to include date output

Output

15. Use pipes (|) to combine commands:

sh
cat file.txt | grep "error" # Display lines with "error" from "file.txt"

Output

16. Print Text to Terminal

sh
echo "Hello, World!" # Print "Hello, World!" to the terminal

Output
II. Programs using Inter Process Communication (IPC)

To execute C programs that use IPC mechanisms in UNIX, you need to follow these steps:

1. Write the Code in a File: Save each program in a separate .c file, e.g., pipe_example.c,
message_queue_example.c, etc.

2. Compile the Program Using GCC: Use the GNU Compiler Collection (gcc) to compile the C
programs. You can run each program using the following command in your terminal:

bash
gcc -o program_name file_name.c

 -o program_name specifies the output executable file name.

 file_name.c is the name of your C source file.

3. Run the Executable: After successful compilation, run the program by typing:

bash
./program_name
1. Pipes

 Pipes provide a one-way communication channel between processes.

 Anonymous Pipes are commonly used for parent-child process communication.
 Named Pipes (FIFO) can be used between unrelated processes.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>

int main() {
int pipefds[2];
char buffer[5];

pipe(pipefds); // create pipe

if (fork() == 0) {
close(pipefds[0]); // close reading end
write(pipefds[1], "Hello", 5);
close(pipefds[1]); // close writing end
} else {
close(pipefds[1]); // close writing end
read(pipefds[0], buffer, 5);
printf("Received: %s\n", buffer);
close(pipefds[0]); // close reading end
}
return 0;
}
Compile the Program

Command to compile pipe_example.c: gcc -o pipe_example pipe_example.c

Run the Program

Execute the compiled program: ./pipe_example

2. Message Queues

 Message queues allow processes to exchange messages in a structured way.

 Each message has a type and content, allowing selective retrieval of messages.
 Operations are based on the msgget, msgsnd, and msgrcv system calls.
 Create the Sender Program – Save the file as msg_sender.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>

struct msgbuf
{
long mtype;
char mtext[100];
};
int main()
{
int msgid;
struct msgbuf message;

// create a message queue

msgid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
if (msgid < 0)

{
perror("msgget");
exit(1);

// prepare message
message.mtype = 1;

// Message type

strcpy(message.mtext, "Hello from sender!");

// Send the message

if (msgsnd(msgid, &message, sizeof(message.mtext), 0) < 0)
{
perror("msgsnd");
exit(1);
}

printf("Message sent: %s\n", message.mtext);

// Clean up
msgctl(msgid, IPC_RMID, NULL); // Remove the message queue
return 0;
}
 Create Receiver Program - Save the file as msg_receiver.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>

struct msgbuf
{
long mtype;
char mtext[100];
};

int main()
{
int msgid;
struct msgbuf message;

// Create or connect to the message queue (you can use the same key as in sender)

msgid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);

if (msgid < 0)
{
perror("msgget");
exit(1);
}
// Receive the message

if (msgrcv(msgid, &message, sizeof(message.mtext), 1, 0) < 0)

{
perror("msgrcv");
exit(1);
}

printf("Received message: %s\n", message.mtext);

// Clean up

msgctl(msgid, IPC_RMID, NULL); // Remove the message queue

return 0;
}

Compile the Programs

gcc -o msg_sender msg_sender.c

gcc -o msg_receiver msg_receiver.c

Execute the Programs

1. First, run the receiver in one terminal window: ./msg_receiver

2. In another terminal window, run the sender: ./msg_sender

3. Shared Memory
 Shared memory provides a region of memory accessible by multiple processes.
 It's the fastest IPC method as it allows direct memory access.
 Operations are based on shmget, shmat, shmdt, and shmctl.

 Create the Writer Program Save the file as shm_writer.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

#define SHM_SIZE 1024 // Define the size of the shared memory

int main()
{
int shmid;
char *data;

// Create shared memory segment

shmid = shmget(IPC_PRIVATE, SHM_SIZE, 0666 | IPC_CREAT);

if (shmid < 0)
{
perror("shmget");
exit(1);
}
// Attach the shared memory segment

data = (char *)shmat(shmid, NULL, 0);

if (data == (char *)(-1)) {
perror("shmat");
exit(1);
}
// Write to the shared memory

strcpy(data, "Hello from writer!");

printf("Writer: Data written to shared memory: %s\n", data);
// Detach from shared memory

shmdt(data);
return 0;
}
Create the Reader Program - Save the file as shm_reader.c.
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

#define SHM_SIZE 1024 // Same size as the writer

int main()
{
int shmid;
char *data;
// Create or connect to the shared memory segment (use the same key as in writer)
shmid = shmget(IPC_PRIVATE, SHM_SIZE, 0666 | IPC_CREAT);
if (shmid < 0) {
perror("shmget");
exit(1);
}
// Attach the shared memory segment
data = (char *)shmat(shmid, NULL, 0);
if (data == (char *)(-1))
{
perror("shmat");
exit(1);
}
// Read from the shared memory
printf("Reader: Data read from shared memory: %s\n", data);
// Detach from shared memory
shmdt(data);
// Remove the shared memory segment
shmctl(shmid, IPC_RMID, NULL);
return 0;
}

Compile the Programs: compile both programs: gcc -o shm_writer shm_writer.c

gcc -o shm_reader shm_reader.c
Execute the Programs

1. First, run the writer in one terminal window: ./shm_writer

2. In another terminal window, run the reader: ./shm_reader
4. Semaphores

 Semaphores are used for controlling access to shared resources.

 They help synchronize processes by preventing race conditions.
 Operations use semget, semop, and semctl
 Create the Producer Program - Save the file as producer.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <string.h>

#define SHM_SIZE 1024 // Size of the shared memory

#define SEM_KEY 1234 // Semaphore key
void P(int semid)
{ // Wait (decrement)
struct sembuf sb = {0, -1, 0};
semop(semid, &sb, 1);
}

void V(int semid)

{
// Signal (increment)
struct sembuf sb = {0, 1, 0};
semop(semid, &sb, 1);
}

int main()
{
int shmid, semid;
char *data;

// create shared memory

shmid = shmget(IPC_PRIVATE, SHM_SIZE, 0666 | IPC_CREAT);
if (shmid < 0) {
perror("shmget");
exit(1);
}

// Create semaphore
semid = semget(SEM_KEY, 1, 0666 | IPC_CREAT);
if (semid < 0) {
perror("semget");
 exit(1);
}

// Initialize semaphore to 1 (binary semaphore)

semctl(semid, 0, SETVAL, 1);
// Attach the shared memory
data = (char *)shmat(shmid, NULL, 0);
if (data == (char *)(-1)) {
perror("shmat");
exit(1);
}
// Produce data
P(semid); // Wait
strcpy(data, "Produced Data");
printf("Producer: %s\n", data);
V(semid); // Signal
// Detach and clean up
shmdt(data);
shmctl(shmid, IPC_RMID, NULL);
semctl(semid, 0, IPC_RMID);
return 0;
}

Create the Consumer Program - Save the file as consumer.c.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <string.h>
#define SHM_SIZE 1024 // Size of the shared memory
#define SEM_KEY 1234 // Semaphore key
void P(int semid)
{
// Wait (decrement)
struct sembuf sb = {0, -1, 0};
semop(semid, &sb, 1);
}
 void V(int semid)
{

// Signal (increment)
struct sembuf sb = {0, 1, 0};
semop(semid, &sb, 1);
}
int main()
{
int shmid, semid;
char *data;
// Create shared memory
shmid = shmget(IPC_PRIVATE, SHM_SIZE, 0666 | IPC_CREAT);
if (shmid < 0) {
perror("shmget");
exit(1);
}
// Get semaphore
semid = semget(SEM_KEY, 1, 0666);
if (semid < 0) {
perror("semget");
exit(1);
}
// Attach the shared memory
data = (char *)shmat(shmid, NULL, 0);
if (data == (char *)(-1)) {
perror("shmat");
exit(1);
}
// Consume data
P(semid); // Wait
printf("Consumer: %s\n", data);
V(semid); // Signal

// Detach and clean up

shmdt(data);
shmctl(shmid, IPC_RMID, NULL);
semctl(semid, 0, IPC_RMID);
return 0;
}
Compile the Programs
gcc -o producer producer.c
gcc -o consumer consumer.c
Execute the Programs
 1. First, run the producer in one terminal window: ./producer
2. In another terminal window, run the consumer: ./consumer
III. Socket programming is a way to enable communication between processes over a network. It allows for
the development of client-server applications where one process (the server) listens for incoming requests
and the other (the client) initiates the communication.

TCP Socket Programming in C - A server program and a client program.

Create the Server Program - Save the file as tcp_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080

int main()
{
int server_fd, new_socket;
struct sockaddr_in address;
int opt = 1;
int addrlen = sizeof(address);
char buffer[1024] = {0};
// Create socket file descriptor
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0)
{
perror("socket failed");
exit(EXIT_FAILURE);
}
// Forcefully attaching socket to the port
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)))
{
perror("setsockopt");
exit(EXIT_FAILURE);
}
// Define the address
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
 address.sin_port = htons(PORT);

// Bind the socket

if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0)
{
perror("bind failed");
exit(EXIT_FAILURE);
}

// Start listening for connections

if (listen(server_fd, 3) < 0)
{
perror("listen");
exit(EXIT_FAILURE);
}

printf("Server is listening on port %d\n", PORT);

// Accept a connection
if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0)
{
perror("accept");
exit(EXIT_FAILURE);
}
// Read data from the client
read(new_socket, buffer, 1024);
printf("Received: %s\n", buffer);

// Send a response to the client

char *response = "Hello from server";
send(new_socket, response, strlen(response), 0);
printf("Response sent to client\n");

// Close the sockets

close(new_socket);
close(server_fd);

return 0;
 }

Create the Client Program - Save the file as tcp_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 8080
int main()
{
int sock = 0;
struct sockaddr_in serv_addr;
char *message = "Hello from client";
char buffer[1024] = {0};
// Create socket
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("\n Socket creation error \n");
return -1;
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);

// Convert IPv4 and IPv6 addresses from text to binary form

if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0)
{
printf("\nInvalid address/ Address not supported \n");
return -1;
}
// Connect to the server
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
printf("\nConnection Failed \n");
return -1;
}
// Send message to the server
send(sock, message, strlen(message), 0);
printf("Message sent to server\n");
// Read response from the server
read(sock, buffer, 1024);
printf("Server response: %s\n", buffer);
/ Close the socket
close(sock);

return 0;
}
Compile the Programs: gcc -o tcp_server tcp_server.c gcc -o tcp_client tcp_client.c
Execute the Programs
1. First, run the server in one terminal window: ./tcp_server
2. In another terminal window, run the client: ./tcp_client