Roll No: 160122733028 Exp.

No: 06 Date: 14-10-24

Lab Task – 6
Linux offers several Inter-Process Communication (IPC) mechanisms,
including pipes, message queues, shared memory, semaphores, and sockets.
Below are example programs for some common IPC mechanisms in Linux.

1. Unnamed Pipe
Aim: To Write a program and to demonstrate named and unnamed pipes for IPC.

Description: An unnamed pipe is used for communication between processes that

share a common ancestry (parent-child).
Code:
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h> // For wait()

int main() {
int pipefds[2];
char write_msg[100];
char read_msg[100];

// Create pipe
if (pipe(pipefds) == -1) {
perror("pipe");
return 1;
}

pid_t pid = fork();

if (pid == -1) {
perror("fork");
return 1;
}

if (pid == 0) {
// Child process: Reads from the pipe
close(pipefds[1]); // Close unused write end
read(pipefds[0], read_msg, sizeof(read_msg)); // Read from pipe
printf("Child received: %s\n", read_msg); // Print received message
close(pipefds[0]); // Close read end
} else {
// Parent process: Gets input from the user and writes to the pipe
close(pipefds[0]); // Close unused read end
printf("Enter a message: ");

Page No. ………50……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

fgets(write_msg, sizeof(write_msg), stdin); // Get input from user

write(pipefds[1], write_msg, strlen(write_msg) + 1); // Write to pipe
close(pipefds[1]); // Close write end

wait(NULL); // Wait for child to finish

}

return 0;
}

OUTPUT:

1.Named Pipe

Aim: To Write a program and to demonstrate named and named pipes for IPC.
Description: Named pipes (also called FIFOs) allow unrelated processes to
communicate. First, create the FIFO file using mkfifo command:
bash
mkfifo /tmp/myfifo
Then, two separate programs can communicate through the FIFO.

Code:
Writer.c
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
int fd;
char write_msg[100];

// Open the FIFO for writing

fd = open("myfifo", O_WRONLY);
if (fd == -1) {
perror("open");
return 1;
}

Page No. ………51……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

// Get user input

printf("Enter a message: ");
fgets(write_msg, sizeof(write_msg), stdin);

// Write to the FIFO

write(fd, write_msg, sizeof(write_msg));

// Close the FIFO

close(fd);

return 0;
}

Reader.c

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

int main() {
int fd;
char read_msg[100];

// Open the FIFO for reading

fd = open("myfifo", O_RDONLY);
if (fd == -1) {
perror("open");
return 1;
}

// Read from the FIFO

read(fd, read_msg, sizeof(read_msg));

// Print the received message

printf("Received: %s\n", read_msg);

// Close the FIFO

close(fd);

return 0;
}

Output:

Page No. ………52……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

3. Aim: To Write a program to demonstrate IPC using shared memory.

Description: Implement shared memory for communication between processes

by attaching, reading, and writing data..
Code:

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

int main() {
// Generate a unique key for shared memory
key_t key = ftok("shmfile", 65);

// Create a shared memory segment with a size of 1024 bytes

int shmid = shmget(key, 1024, 0666|IPC_CREAT);

// Attach the shared memory segment to this process's address space

char *str = (char*) shmat(shmid, (void*)0, 0);

// Write data to shared memory

printf("Enter a message to write to shared memory: ");
fgets(str, 1024, stdin); // Write user input to shared memory

printf("Data written to shared memory: %s\n", str);

// Detach from the shared memory segment

shmdt(str);

return 0;
}

Reader.c

Page No. ………53……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

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

int main() {
// Generate the same unique key
key_t key = ftok("shmfile", 65);

// Access the shared memory segment created by the writer

int shmid = shmget(key, 1024, 0666);

// Attach the shared memory segment to this process's address space

char *str = (char*) shmat(shmid, (void*)0, 0);

// Read and print the data from shared memory

printf("Data read from shared memory: %s\n", str);

// Detach from the shared memory segment

shmdt(str);

// Destroy the shared memory segment after reading

shmctl(shmid, IPC_RMID, NULL);

return 0;
}

Output:

4. Aim: Write a program to demonstrate IPC using message queues.

Description: Use message queues to send and receive messages between two or more
processes.

Code:
Sender.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

Page No. ………54……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

// Define the structure of the message

struct msg_buffer {
long msg_type;
char msg_text[100];
} message;

int main() {
key_t key;
int msgid;

// Generate a unique key for the message queue

key = ftok("progfile", 65);

// Create a message queue and return its ID

msgid = msgget(key, 0666 | IPC_CREAT);
message.msg_type = 1; // Message type, must be positive

// Get input from the user

printf("Enter a message: ");
fgets(message.msg_text, sizeof(message.msg_text), stdin);

// Send the message to the queue

msgsnd(msgid, &message, sizeof(message), 0);

printf("Message sent: %s", message.msg_text);

return 0;
}
Receiver.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>

// Define the structure of the message

struct msg_buffer {
long msg_type;
char msg_text[100];

Page No. ………55……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

} message;

int main() {
key_t key;
int msgid;

// Generate the same unique key as the sender

key = ftok("progfile", 65);

// Access the message queue using the key

msgid = msgget(key, 0666 | IPC_CREAT);

// Receive the message from the queue

msgrcv(msgid, &message, sizeof(message), 1, 0);

// Print the received message

printf("Message received: %s", message.msg_text);

// Destroy the message queue after receiving the message

msgctl(msgid, IPC_RMID, NULL);

return 0;
}
Output:

5. Aim:To Write a program to demonstrate IPC using semaphores

Description: Implement semaphores for process synchronization, ensuring
mutual exclusion.

Code:
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/wait.h> // For wait()

Page No. ………56……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

#include <unistd.h>

// Define union semun for semaphore control operations

union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
};

// Function to perform the "wait" (P) operation on the semaphore

void semaphore_wait(int semid) {
struct sembuf sem_op;
sem_op.sem_num = 0; // Semaphore index in the semaphore set
sem_op.sem_op = -1; // Decrement the semaphore (P operation)
sem_op.sem_flg = 0; // No special options
semop(semid, &sem_op, 1); // Perform the semaphore operation
}

// Function to perform the "signal" (V) operation on the semaphore

void semaphore_signal(int semid) {
struct sembuf sem_op;
sem_op.sem_num = 0; // Semaphore index in the semaphore set
sem_op.sem_op = 1; // Increment the semaphore (V operation)
sem_op.sem_flg = 0; // No special options
semop(semid, &sem_op, 1); // Perform the semaphore operation
}

int main() {
key_t key = ftok("semfile", 65); // Generate a unique key
int semid = semget(key, 1, 0666 | IPC_CREAT); // Create a semaphore set with
one semaphore

// Initialize the semaphore value to 1 (critical section available)

union semun sem_union;
sem_union.val = 1;
semctl(semid, 0, SETVAL, sem_union);

if (fork() == 0) {
// Child process
semaphore_wait(semid); // Enter critical section

Page No. ………57……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

printf("Child process is in critical section\n");

sleep(2); // Simulate work in the critical section
semaphore_signal(semid); // Leave critical section
printf("Child process is leaving critical section\n");
} else {
// Parent process
semaphore_wait(semid); // Enter critical section
printf("Parent process is in critical section\n");
sleep(2); // Simulate work in the critical section
semaphore_signal(semid); // Leave critical section
printf("Parent process is leaving critical section\n");

wait(NULL); // Wait for child to finish

// Remove the semaphore set after the processes have completed

semctl(semid, 0, IPC_RMID);
}

return 0;
}
Output:

6. Aim: Write a program to demonstrate signal generation and

handling. Description: Handle and generate signals like SIGINT to
manage interprocess communication.
Code:
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

// Signal handler for SIGINT

Page No. ………58……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

void handle_sigint(int sig) {

printf("Caught signal %d (SIGINT). Exiting gracefully...\n", sig);
// Perform any cleanup if necessary
_exit(0); // Exit the program
}

int main() {
// Register signal handler for SIGINT
signal(SIGINT, handle_sigint);

printf("Press Ctrl+C to generate SIGINT signal...\n");

// Infinite loop to keep the program running

while (1) {
printf("Program is running... Press Ctrl+C to send SIGINT\n");
sleep(1); // Sleep for a while to prevent spamming output
}

return 0;
}
Output:

7. Aim: A program to demonstrate the use of socket – IPC

Description: A socket is a bi-directional data transfer mechanism.
They are used to transfer data between two processes. The two
processes can be running on the same system as Unix-domain or
loopback sockets, or on different systems as network sockets.

Code:
Socket:
#include <stdio.h>
#include <netdb.h>
#include <netinet/in.h>

Page No. ………59……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#define MAX 80
#define PORT 8080
#define SA struct sockaddr

// Function designed for chat between client and server.

void func(int connfd) {
char buff[MAX];
int n;

// Infinite loop for chat

for (;;) {
bzero(buff, MAX);

// Read the message from client and copy it in buffer

read(connfd, buff, sizeof(buff));

// Print buffer which contains the client contents

printf("From client: %s\t To client: ", buff);
bzero(buff, MAX);
n = 0;

// Copy server message in the buffer

while ((buff[n++] = getchar()) != '\n')
;

// Send that buffer to client

write(connfd, buff, sizeof(buff));

// If msg contains "exit" then server exit and chat ended.

if (strncmp("exit", buff, 4) == 0) {
printf("Server Exit...\n");
break;
}
}
}

// Driver function

Page No. ………60……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

int main() {
int sockfd, connfd, len;
struct sockaddr_in servaddr, cli;

// Socket create and verification

sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
printf("Socket creation failed...\n");
exit(0);
} else {
printf("Socket successfully created..\n");
}

bzero(&servaddr, sizeof(servaddr));

// Assign IP, PORT

servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);

// Binding newly created socket to given IP and verification

if ((bind(sockfd, (SA*)&servaddr, sizeof(servaddr))) != 0) {
printf("Socket bind failed...\n");
exit(0);
} else {
printf("Socket successfully binded..\n");
}

// Now server is ready to listen and verification

if ((listen(sockfd, 5)) != 0) {
printf("Listen failed...\n");
exit(0);
} else {
printf("Server listening..\n");
}

len = sizeof(cli);

// Accept the data packet from client and verification

connfd = accept(sockfd, (SA*)&cli, &len);
if (connfd < 0) {
printf("Server accept failed...\n");
exit(0);

Page No. ………61……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

} else {
printf("Server accepted the client...\n");
}

// Function for chatting between client and server

func(connfd);

// After chatting, close the socket

close(sockfd);
}

Client:
#include <arpa/inet.h> // inet_addr()
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h> // bzero()
#include <sys/socket.h>
#include <unistd.h> // read(), write(), close()

#define MAX 80
#define PORT 8080
#define SA struct sockaddr

void func(int sockfd) {

char buff[MAX];
int n;

for (;;) {
bzero(buff, sizeof(buff));
printf("Enter the string: ");
n = 0;

while ((buff[n++] = getchar()) != '\n')

;

write(sockfd, buff, sizeof(buff));

bzero(buff, sizeof(buff));
read(sockfd, buff, sizeof(buff));
printf("From Server: %s", buff);

if ((strncmp(buff, "exit", 4)) == 0) {

printf("Client Exit...\n");

Page No. ………62……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

break;
}
}
}

int main() {
int sockfd;
struct sockaddr_in servaddr;

// Socket create and verification

sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
printf("Socket creation failed...\n");
exit(0);
} else {
printf("Socket successfully created..\n");
}

bzero(&servaddr, sizeof(servaddr));

// Assign IP, PORT

servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
servaddr.sin_port = htons(PORT);

// Connect the client socket to server socket

if (connect(sockfd, (SA*)&servaddr, sizeof(servaddr)) != 0) {
printf("Connection with the server failed...\n");
exit(0);
} else {
printf("Connected to the server..\n");
}

// Function for chat

func(sockfd);

// Close the socket

close(sockfd);
}

Output:

Page No. ………63……….. Signature of the Faculty………………………...

Roll No: 160122733028 Exp. No: 06 Date: 14-10-24

Page No. ………64……….. Signature of the Faculty………………………...