20. producer-consumer scenario using FIFOs

//consumer

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#define FIFO1 "/tmp/fifo1"
#define FIFO2 "/tmp/fifo2"
#define BUFFER_SIZE 128
int main()
{
    int write_fd, read_fd;
    char buffer[BUFFER_SIZE];
    // Open FIFO1 for writing
    write_fd = open(FIFO1, O_WRONLY);
    if (write_fd == -1)
    {
        perror("open FIFO1");
        exit(EXIT_FAILURE);
    }
    // Open FIFO2 for reading
    read_fd = open(FIFO2, O_RDONLY);
    if (read_fd == -1)
    {
        perror("open FIFO2");
        close(write_fd);
        exit(EXIT_FAILURE);
    }
    // Send a message to FIFO1
    const char *message = "Hello from the client!";
    if (write(write_fd, message, strlen(message)) == -1)
    {
        perror("write");
        close(write_fd);
        close(read_fd);
        exit(EXIT_FAILURE);
    }
    // Read the response from FIFO2
    ssize_t count = read(read_fd, buffer, BUFFER_SIZE);
    if (count == -1)
    {
        perror("read");
        close(write_fd);
        close(read_fd);
        exit(EXIT_FAILURE);
    }
    buffer[count] = '\0';
    printf("Client received: %s\n", buffer);
    close(write_fd);
    close(read_fd);
    return 0;
}

//producer

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#define FIFO1 "/tmp/fifo1"
#define FIFO2 "/tmp/fifo2"
#define BUFFER_SIZE 128
int main()
{    
    int ret = mkfifo(FIFO1,0666);
    if(ret==-1)
        {
                perror("mkfifo");
                exit(EXIT_FAILURE);
        }

    int ret1 = mkfifo(FIFO2,0666);
    if(ret1==-1)
        {
                perror("mkfifo");
                exit(EXIT_FAILURE);
        }

    int read_fd, write_fd;
    char buffer[BUFFER_SIZE];
    // Open FIFO1 for reading
    read_fd = open(FIFO1, O_RDONLY);
    if (read_fd == -1)
    {
        perror("open FIFO1");
        exit(EXIT_FAILURE);
    }
    // Open FIFO2 for writing
    write_fd = open(FIFO2, O_WRONLY);
    if (write_fd == -1)
    {
        perror("open FIFO2");
        close(read_fd);
        exit(EXIT_FAILURE);
    }
    // Read a message from FIFO1
    ssize_t count = read(read_fd, buffer, BUFFER_SIZE);
    if (count == -1)
    {
        perror("read");
        close(read_fd);
        close(write_fd);
        exit(EXIT_FAILURE);
    }
    buffer[count] = '\0';
    printf("Server received: %s\n", buffer);
    // Send a response to FIFO2
    const char *response = "Hello from the server!";
    if (write(write_fd, response, strlen(response)) == -1)
    {
        perror("write");
        close(read_fd);
        close(write_fd);
        exit(EXIT_FAILURE);
    }
    close(read_fd);
    close(write_fd);
    return 0;
}

Here we are doing a full duplex bidirectional communication using 2 FIFOs i.e. fifo1 and fifo2, one for each direction of communication. Both consumer and producer can do both read and write here.