Creating a program that forks into multiple child processes, enables message passing from the

parent to child processes using pipes, allows the parent to enter a message, and displays the
message in child processes is a complex task. #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

#define MAX_CHILDREN 3
#define MESSAGE_SIZE 100

int pipes[MAX_CHILDREN][2]; // Array to hold pipe file descriptors

pid_t child_pids[MAX_CHILDREN];

void interruptHandler(int signal) {

printf("\nCtrl+C interrupt detected. Program terminated.\n");
for (int i = 0; i < MAX_CHILDREN; i++) {
if (child_pids[i] > 0) {
kill(child_pids[i], SIGTERM);
}
}
exit(0);
}

int main() {
signal(SIGINT, interruptHandler); // Register interrupt handler

for (int i = 0; i < MAX_CHILDREN; i++) {

if (pipe(pipes[i]) == -1) {
 perror("Pipe creation failed");
exit(1);
}

pid_t child_pid = fork();

if (child_pid == -1) {
perror("Fork failed");
exit(1);
} else if (child_pid == 0) {
// Child process
close(pipes[i][1]); // Close the write end of the pipe

char message[MESSAGE_SIZE];
int bytes_read = read(pipes[i][0], message, MESSAGE_SIZE);
if (bytes_read > 0) {
message[bytes_read] = '\0';
printf("Child %d received message: %s", i, message);
} else {
printf("Child %d received no message.\n", i);
}

close(pipes[i][0]); // Close the read end of the pipe

exit(0);
} else {
// Parent process
child_pids[i] = child_pid; // Store child process IDs
close(pipes[i][0]); // Close the read end of the pipe

char message[MESSAGE_SIZE];
printf("Enter a message for Child %d: ", i);
fgets(message, MESSAGE_SIZE, stdin);
write(pipes[i][1], message, strlen(message) + 1);

close(pipes[i][1]); // Close the write end of the pipe

}
}

// Parent waits for all child processes to finish

for (int i = 0; i < MAX_CHILDREN; i++) {
wait(NULL);
}

return 0;
}

This program creates multiple child processes, sets up pipes for inter-process communication,
allows the parent to enter a message for each child, and displays the messages in the child
processes. It also handles Ctrl+C interrupts gracefully. Note that the number of child processes
can be controlled by changing the `num_children` variable.

Codes Explanation

```c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
```

These are the necessary header files included in the code for standard input/output, memory
allocation, process management, and signal handling.

```c
#define MAX_CHILDREN 3
#define MESSAGE_SIZE 100
```

These are constant definitions used in the code. `MAX_CHILDREN` specifies the maximum
number of child processes, and `MESSAGE_SIZE` sets the maximum size for messages
passed between the parent and child processes.

```c
int pipes[MAX_CHILDREN][2]; // Array to hold pipe file descriptors
pid_t child_pids[MAX_CHILDREN];
```

Here, we declare an array to hold file descriptors for pipes, which are used for communication
between parent and child processes. `child_pids` is an array to store the process IDs of the
child processes.

```c
void interruptHandler(int signal) {
printf("\nCtrl+C interrupt detected. Program terminated.\n");
 for (int i = 0; i < MAX_CHILDREN; i++) {
if (child_pids[i] > 0) {
kill(child_pids[i], SIGTERM);
}
}
exit(0);
}
```

This function `interruptHandler` is a signal handler for the Ctrl+C (SIGINT) interrupt signal. It
prints a message and gracefully terminates the program, ensuring that child processes are also
terminated.

```c
int main() {
signal(SIGINT, interruptHandler); // Register interrupt handler
```

In the `main` function, we register the `interruptHandler` function to handle the Ctrl+C signal.

```c
for (int i = 0; i < MAX_CHILDREN; i++) {
if (pipe(pipes[i]) == -1) {
perror("Pipe creation failed");
exit(1);
}
```

This loop creates a set of pipes for inter-process communication. If pipe creation fails, an error
message is printed, and the program exits.

```c
pid_t child_pid = fork();

if (child_pid == -1) {
perror("Fork failed");
exit(1);
} else if (child_pid == 0) {
```

Here, we use `fork` to create child processes. If `fork` fails, an error message is printed, and the
program exits. If `fork` succeeds, the code inside the `if (child_pid == 0)` block runs, indicating
that this section is executed only by child processes.
```c
close(pipes[i][1]); // Close the write end of the pipe

char message[MESSAGE_SIZE];
int bytes_read = read(pipes[i][0], message, MESSAGE_SIZE);
if (bytes_read > 0) {
message[bytes_read] = '\0';
printf("Child %d received message: %s", i, message);
} else {
printf("Child %d received no message.\n", i);
}

close(pipes[i][0]); // Close the read end of the pipe

exit(0);
} else {
```

This code is executed by the child processes. It closes the write end of the pipe, reads a
message from the pipe, and prints the received message. It then closes the read end of the pipe
and exits.

```c
child_pids[i] = child_pid; // Store child process IDs
close(pipes[i][0]); // Close the read end of the pipe

char message[MESSAGE_SIZE];
printf("Enter a message for Child %d: ", i);
fgets(message, MESSAGE_SIZE, stdin);
write(pipes[i][1], message, strlen(message) + 1);

close(pipes[i][1]); // Close the write end of the pipe

}
```

This section is executed by the parent process. It stores the child process IDs, closes the read
end of the pipe, allows the user to enter a message, writes the message to the pipe, and closes
the write end of the pipe.

```c
for (int i = 0; i < MAX_CHILDREN; i++) {
wait(NULL);
}
```
Finally, the parent process waits for all child processes to finish before exiting.