C Program to Demonstrate fork() and pipe()

In the following tutorial, we will understand the implementation of fork() and pipe() in C Programming language.

So, let's get started.

fork()

The fork() function is used to start a new process. This kid process is an exact replica of the parent process. On Unix-like operating systems, it is the main technique for creating new processes.
A new process known as a "child process" is created with the fork system function and runs simultaneously with the process that invoked fork() (parent process). Both processes will carry out the next instruction after the fork() system call once a new child process has been started. The same CPU registers, program counter, and open files that the parent process utilizes are used by the child process.
It returns an integer value and requires no arguments. Various values returned by fork are listed below ().

pipe()

A pipe can be used so that one process writes to it and another process reads from it. This is known as one-way communication. It begins by opening a pipe, a portion of main memory that functions as a "virtual file."
The producing process, along with all of its offspring, may read from and write on the pipe. This "virtual file" or pipe can be written to by one process, and read from by another process that is connected to it.
A process is halted until anything is written to the pipe if it tries to read before anything has been written.
The read and write endpoints of the pipe are given the first two open places that the pipe system call discovers in the process' open file table.

C Program to Demonstrate fork() and pipe():

Create two processes, P1 and P2, using a C program. P1 hands a string to P2 after receiving it. Without utilizing a string function, P2 joins the received string to another string and sends the result back to P1 for printing.

Example:

Other string is: javatpoint.com
Input  : www.Javat
Output : www.javatpoint.com
Input :  www.tutorialandexamples.com
Output : tutorialandexamples.javatpoint.com

// C program to demonstrate use of fork() and pipe()
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int main()
{
    // We use two pipes
    // First pipe to send input string from parent
    // Second pipe to send concatenated string from child

    int fd1[2]; // Used to store two ends of first pipe
    int fd2[2]; // Used to store two ends of second pipe

    char fixed_str[] = "forgeeks.org";
    char input_str[100];
    pid_t p;

    if (pipe(fd1) == -1)
    {
        fprintf(stderr, "Pipe Failed");
        return 1;
    }
    if (pipe(fd2) == -1)
    {
        fprintf(stderr, "Pipe Failed");
        return 1;
    }

    scanf("%s", input_str);
    p = fork();

    if (p < 0)
    {
        fprintf(stderr, "fork Failed");
        return 1;
    }

    // Parent process
    else if (p > 0)
    {
        char concat_str[100];

        close(fd1[0]); // Close reading end of first pipe

        // Write input string and close writing end of first
        // pipe.
        write(fd1[1], input_str, strlen(input_str) + 1);
        close(fd1[1]);

        // Wait for child to send a string
        wait(NULL);

        close(fd2[1]); // Close writing end of second pipe

        // Read string from child, print it and close
        // reading end.
        read(fd2[0], concat_str, 100);
        printf("Concatenated string %s\n", concat_str);
        close(fd2[0]);
    }

    // child process
    else
    {
        close(fd1[1]); // Close writing end of first pipe

        // Read a string using first pipe
        char concat_str[100];
        read(fd1[0], concat_str, 100);

        // Concatenate a fixed string with it
        int k = strlen(concat_str);
        int i;
        for (i = 0; i < strlen(fixed_str); i++)
            concat_str[k++] = fixed_str[i];

        concat_str[k] = '\0'; // string ends with '\0'

        // Close both reading ends
        close(fd1[0]);
        close(fd2[0]);

        // Write concatenated string and close writing end
        write(fd2[1], concat_str, strlen(concat_str) + 1);
        close(fd2[1]);

        exit(0);
    }
}

Explanation:

We utilize a fork to generate a child process (). Fork () returns the following information: 0 fail to create child (new) process =0 for child process >0, i.e. the process ID of the child process to the parent process. Parent process will run when >0.

Information may be sent from one process to another using the pipe() function. Since pipe() is unidirectional, two pipes-one for each direction-can be set up to provide two-way communication between processes.

Inside Parent Process: We first close the first pipe's reading end (fd1[0]), then we write the string via the pipe's writing end (fd1[1]). Parent will now wait till the child's process is complete. After the child process, the parent will shut the second pipe's writing end (fd2[1]), and read the string through the pipe's reading end (fd2[0]).

Within the child process, the child reads the first string that the parent process delivered by shutting the writing end of the pipe (fd1[1]), concatenates the two strings after reading them, and then sends the string to the parent process via the fd2 pipe before exiting.

Next TopicDeadlock Prevention using Banker's Algorithm in C

← prev next →