Lesson 09: Named Pipes & Message Queues

1

FIFO Reader

Reading from a named pipe created with mkfifo — blocks until a writer opens the other end.

02-mkfifo-example/fifo-reader.c79 lines

/*
 * fifo-reader.c — FIFO reader — reading from a named pipe
 *
 * Key concepts: mkfifo, open, read, named pipes persist in filesystem
 * Compile: gcc -o reader fifo-reader.c
 * Run:     ./prog
 */
// fifo_reader.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_RDONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For read and close
#include <string.h>
#include <errno.h>

const char *FIFO_NAME = "my_fifo";
const int BUFFER_SIZE = 1024;

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  FIFO Reader (Named Pipe)\n");
    printf("  Run this first, then writer in another terminal\n");
    printf("══════════════════════════════════════\n\n");
    int fd;
    char buffer[BUFFER_SIZE];

    // Create the FIFO (named pipe) if it does not exist
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        if (errno != EEXIST) { // It's okay if the FIFO already exists
            perror("mkfifo");
            exit(EXIT_FAILURE);
        }
    }

    printf("[Reader PID %d] FIFO '%s' created/exists.\n", getpid(), FIFO_NAME);

    // Open the FIFO for reading
    fd = open(FIFO_NAME, O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    printf("[Reader] Connected (fd=%d). Waiting for messages...\n\n", fd);

    while (1) {
        // Read from the FIFO
        ssize_t bytesRead = read(fd, buffer, BUFFER_SIZE);
        if (bytesRead == -1) {
            perror("read");
            break;
        } else if (bytesRead == 0) {
            // No more writers; exit
            printf("[Reader] read() returned 0 — writer closed the FIFO (EOF).\n");
            break;
        }

        printf("[Reader] Received %ld bytes: \"%s\"\n", (long)bytesRead, buffer);

        // Exit condition
        if (strcmp(buffer, "exit") == 0) {
            printf("Reader: Exit signal received. Exiting.\n");
            break;
        }
    }

    // Close the FIFO
    close(fd);
    //this will delete the FIFO file and its important to do it!!!
    // ONLY ONE PROCESS SHOULD DO THIS
    if(unlink(FIFO_NAME) == -1){
        perror("unlink");
        exit(EXIT_FAILURE);
    }
    return 0;
}

/*
 * fifo-reader.c — FIFO reader — reading from a named pipe
 *
 * Key concepts: mkfifo, open, read, named pipes persist in filesystem
 * Compile: gcc -o reader fifo-reader.c
 * Run:     ./prog
 */
// fifo_reader.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_RDONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For read and close
#include <string.h>
#include <errno.h>

const char *FIFO_NAME = "my_fifo";
const int BUFFER_SIZE = 1024;

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  FIFO Reader (Named Pipe)\n");
    printf("  Run this first, then writer in another terminal\n");
    printf("══════════════════════════════════════\n\n");
    int fd;
    char buffer[BUFFER_SIZE];

// Create the FIFO (named pipe) if it does not exist
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        if (errno != EEXIST) { // It's okay if the FIFO already exists
            perror("mkfifo");
            exit(EXIT_FAILURE);
        }
    }

printf("[Reader PID %d] FIFO '%s' created/exists.\n", getpid(), FIFO_NAME);

// Open the FIFO for reading
    fd = open(FIFO_NAME, O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

printf("[Reader] Connected (fd=%d). Waiting for messages...\n\n", fd);

while (1) {
        // Read from the FIFO
        ssize_t bytesRead = read(fd, buffer, BUFFER_SIZE);
        if (bytesRead == -1) {
            perror("read");
            break;
        } else if (bytesRead == 0) {
            // No more writers; exit
            printf("[Reader] read() returned 0 — writer closed the FIFO (EOF).\n");
            break;
        }

printf("[Reader] Received %ld bytes: \"%s\"\n", (long)bytesRead, buffer);

// Exit condition
        if (strcmp(buffer, "exit") == 0) {
            printf("Reader: Exit signal received. Exiting.\n");
            break;
        }
    }

// Close the FIFO
    close(fd);
    //this will delete the FIFO file and its important to do it!!!
    // ONLY ONE PROCESS SHOULD DO THIS
    if(unlink(FIFO_NAME) == -1){
        perror("unlink");
        exit(EXIT_FAILURE);
    }
    return 0;
}

Editing — changes are local only

2

FIFO Writer

Writing to a named pipe — demonstrates how data flows to the reader process.

02-mkfifo-example/fifo-writer.c95 lines

/*
 * fifo-writer.c — FIFO writer — writing to a named pipe
 *
 * Key concepts: open, write, named pipe blocks until reader connects
 * Compile: gcc -o writer fifo-writer.c
 * Run:     ./prog
 */
// fifo_writer.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_WRONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For write and close
#include <string.h>
#include <errno.h>


// we first run the Reader first.
// we will compile both program
// than run first the Reader
// than run the writer
// for example:
// terminal 1: ./fifo-reader
// terminal 2: ./fifo-writer

//WE use here WRITE AND READ, which yoram didnt showcase with mkfifo
//if we use them we dont need to use fflush,
// but next examples we will be using File* to use the mkfifo and than we will need to use fflush

const char *FIFO_NAME = "my_fifo";
const int BUFFER_SIZE = 1024;

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  FIFO Writer (Named Pipe)\n");
    printf("  Run reader in another terminal first\n");
    printf("══════════════════════════════════════\n\n");
    int fd;
    char buffer[BUFFER_SIZE];

    // Create the FIFO (named pipe) if it does not exist
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        if (errno != EEXIST) { // It's okay if the FIFO already exists
            perror("mkfifo");
            exit(EXIT_FAILURE);
        }
    }

    printf("[Writer PID %d] FIFO '%s' created/exists.\n", getpid(), FIFO_NAME);

    // Open the FIFO for writing
    fd = open(FIFO_NAME, O_WRONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    printf("[Writer] Connected (fd=%d). Type messages, 'exit' to quit.\n\n", fd);

    while (1) {
        printf("You: ");
        fflush(stdout);

        // Read input from the user
        if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) {
            perror("fgets");
            break;
        }

        // Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

        // Exit condition
        if (strcmp(buffer, "exit") == 0) {
            break;
        }

        // Write the message to the FIFO
        if (write(fd, buffer, strlen(buffer) + 1) == -1) { // +1 to include '\0'
            perror("write");
            break;
        }
    }

    // Close the FIFO
    close(fd);
    printf("[Writer] Closed FIFO. Exiting.\n");



 
    return 0;
}

/*
 * fifo-writer.c — FIFO writer — writing to a named pipe
 *
 * Key concepts: open, write, named pipe blocks until reader connects
 * Compile: gcc -o writer fifo-writer.c
 * Run:     ./prog
 */
// fifo_writer.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_WRONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For write and close
#include <string.h>
#include <errno.h>

// we first run the Reader first.
// we will compile both program
// than run first the Reader
// than run the writer
// for example:
// terminal 1: ./fifo-reader
// terminal 2: ./fifo-writer

//WE use here WRITE AND READ, which yoram didnt showcase with mkfifo
//if we use them we dont need to use fflush,
// but next examples we will be using File* to use the mkfifo and than we will need to use fflush

const char *FIFO_NAME = "my_fifo";
const int BUFFER_SIZE = 1024;

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  FIFO Writer (Named Pipe)\n");
    printf("  Run reader in another terminal first\n");
    printf("══════════════════════════════════════\n\n");
    int fd;
    char buffer[BUFFER_SIZE];

// Create the FIFO (named pipe) if it does not exist
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        if (errno != EEXIST) { // It's okay if the FIFO already exists
            perror("mkfifo");
            exit(EXIT_FAILURE);
        }
    }

printf("[Writer PID %d] FIFO '%s' created/exists.\n", getpid(), FIFO_NAME);

// Open the FIFO for writing
    fd = open(FIFO_NAME, O_WRONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

printf("[Writer] Connected (fd=%d). Type messages, 'exit' to quit.\n\n", fd);

while (1) {
        printf("You: ");
        fflush(stdout);

// Read input from the user
        if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) {
            perror("fgets");
            break;
        }

// Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

// Exit condition
        if (strcmp(buffer, "exit") == 0) {
            break;
        }

// Write the message to the FIFO
        if (write(fd, buffer, strlen(buffer) + 1) == -1) { // +1 to include '\0'
            perror("write");
            break;
        }
    }

// Close the FIFO
    close(fd);
    printf("[Writer] Closed FIFO. Exiting.\n");

return 0;
}

Editing — changes are local only

3

Multiple FIFO Writers

Multiple writer processes sending data to the same named pipe concurrently.

03-mk-fifo-multi-writers/multi-writer.c86 lines

/*
 * multi-writer.c — Multiple writers to a single FIFO
 *
 * Key concepts: Named pipe with multiple producers, atomic writes < PIPE_BUF
 * Compile: gcc -o mwriter multi-writer.c
 * Run:     ./prog
 */
// fifo_writer_multi.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_WRONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For close
#include <string.h>
#include <errno.h>

const char *FIFO_NAME = "multi_fifo";
const int BUFFER_SIZE = 1024;

int main(int argc, char *argv[]) {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Multi-Writer FIFO\n");
    printf("  Multiple writers → single reader\n");
    printf("══════════════════════════════════════\n\n");
    FILE *fp;
    char buffer[BUFFER_SIZE];
    pid_t pid = getpid();

    // Create the FIFO (named pipe) if it does not exist
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        if (errno != EEXIST) { // It's okay if the FIFO already exists
            perror("mkfifo");
            exit(EXIT_FAILURE);
        }
    }

    printf("Writer %d: FIFO '%s' created/opened for writing.\n", pid, FIFO_NAME);

    // Open the FIFO for writing using fopen
    fp = fopen(FIFO_NAME, "w");
    if (fp == NULL) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }

    printf("Writer %d: FIFO opened. Enter messages to send. Type 'exit' to quit.\n", pid);

    while (1) {
        printf("Writer %d: ", pid);
        fflush(stdout);

        // Read input from the user
        if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) {
            perror("fgets");
            break;
        }

        // Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

        // Exit condition
        if (strcmp(buffer, "exit") == 0) {
            // Optionally, send a special message or just exit
            //send to the reader that we are exiting
            fprintf(fp, "Writer %d: Exiting.\n", pid);
            break;
        }

        // Write the message to the FIFO using fprintf
        if (fprintf(fp, "%s\n", buffer) < 0) {
            perror("fprintf");
            break;
        }

        // Flush to ensure the message is sent immediately
        fflush(fp);
    }

    // Close the FIFO
    fclose(fp);
    printf("Writer %d: Exiting.\n", pid);

    return 0;
}

/*
 * multi-writer.c — Multiple writers to a single FIFO
 *
 * Key concepts: Named pipe with multiple producers, atomic writes < PIPE_BUF
 * Compile: gcc -o mwriter multi-writer.c
 * Run:     ./prog
 */
// fifo_writer_multi.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_WRONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For close
#include <string.h>
#include <errno.h>

const char *FIFO_NAME = "multi_fifo";
const int BUFFER_SIZE = 1024;

int main(int argc, char *argv[]) {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Multi-Writer FIFO\n");
    printf("  Multiple writers → single reader\n");
    printf("══════════════════════════════════════\n\n");
    FILE *fp;
    char buffer[BUFFER_SIZE];
    pid_t pid = getpid();

// Create the FIFO (named pipe) if it does not exist
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        if (errno != EEXIST) { // It's okay if the FIFO already exists
            perror("mkfifo");
            exit(EXIT_FAILURE);
        }
    }

printf("Writer %d: FIFO '%s' created/opened for writing.\n", pid, FIFO_NAME);

// Open the FIFO for writing using fopen
    fp = fopen(FIFO_NAME, "w");
    if (fp == NULL) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }

printf("Writer %d: FIFO opened. Enter messages to send. Type 'exit' to quit.\n", pid);

while (1) {
        printf("Writer %d: ", pid);
        fflush(stdout);

// Read input from the user
        if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) {
            perror("fgets");
            break;
        }

// Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

// Exit condition
        if (strcmp(buffer, "exit") == 0) {
            // Optionally, send a special message or just exit
            //send to the reader that we are exiting
            fprintf(fp, "Writer %d: Exiting.\n", pid);
            break;
        }

// Write the message to the FIFO using fprintf
        if (fprintf(fp, "%s\n", buffer) < 0) {
            perror("fprintf");
            break;
        }

// Flush to ensure the message is sent immediately
        fflush(fp);
    }

// Close the FIFO
    fclose(fp);
    printf("Writer %d: Exiting.\n", pid);

return 0;
}

Editing — changes are local only

4

Multi-Writer Reader

A reader that receives interleaved data from multiple writers on one FIFO.

03-mk-fifo-multi-writers/reader.c70 lines

/*
 * reader.c — Reader for multi-writer FIFO
 *
 * Key concepts: Reading from FIFO with multiple writers
 * Compile: gcc -o reader reader.c
 * Run:     ./prog
 */
// fifo_reader_single.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_RDONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For close
#include <string.h>
#include <errno.h>

const char *FIFO_NAME = "multi_fifo";
const int BUFFER_SIZE = 1024;

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Reader for multi-writer FIFO\n");
    printf("══════════════════════════════════════\n\n");
    FILE *fp;
    char buffer[BUFFER_SIZE];
    int writer_count = 0;

    // Create the FIFO (named pipe) if it does not exist
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        if (errno != EEXIST) { // It's okay if the FIFO already exists
            perror("mkfifo");
            exit(EXIT_FAILURE);
        }
    }

    printf("Reader: FIFO '%s' created/opened for reading.\n", FIFO_NAME);

    // Open the FIFO for reading using fopen
    fp = fopen(FIFO_NAME, "r");
    if (fp == NULL) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }

    printf("Reader: FIFO opened. Waiting for messages...\n");

    while (fgets(buffer, BUFFER_SIZE, fp) != NULL) {
        // Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

        printf("Reader: Received -> %s\n", buffer);

        // Optional: Exit condition if a specific message is received
        if (strcmp(buffer, "exit") == 0) {
            printf("Reader: Exit signal received. Exiting.\n");
            break;
        }
    }

    // Close the FIFO
    fclose(fp);



        //this will delete the FIFO file and its important to do it!!!
     unlink(FIFO_NAME);
    return 0;
}

/*
 * reader.c — Reader for multi-writer FIFO
 *
 * Key concepts: Reading from FIFO with multiple writers
 * Compile: gcc -o reader reader.c
 * Run:     ./prog
 */
// fifo_reader_single.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_RDONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For close
#include <string.h>
#include <errno.h>

const char *FIFO_NAME = "multi_fifo";
const int BUFFER_SIZE = 1024;

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Reader for multi-writer FIFO\n");
    printf("══════════════════════════════════════\n\n");
    FILE *fp;
    char buffer[BUFFER_SIZE];
    int writer_count = 0;

// Create the FIFO (named pipe) if it does not exist
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        if (errno != EEXIST) { // It's okay if the FIFO already exists
            perror("mkfifo");
            exit(EXIT_FAILURE);
        }
    }

printf("Reader: FIFO '%s' created/opened for reading.\n", FIFO_NAME);

// Open the FIFO for reading using fopen
    fp = fopen(FIFO_NAME, "r");
    if (fp == NULL) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }

printf("Reader: FIFO opened. Waiting for messages...\n");

while (fgets(buffer, BUFFER_SIZE, fp) != NULL) {
        // Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

printf("Reader: Received -> %s\n", buffer);

// Optional: Exit condition if a specific message is received
        if (strcmp(buffer, "exit") == 0) {
            printf("Reader: Exit signal received. Exiting.\n");
            break;
        }
    }

// Close the FIFO
    fclose(fp);

//this will delete the FIFO file and its important to do it!!!
     unlink(FIFO_NAME);
    return 0;
}

Editing — changes are local only

5

Two-Way FIFO: Process A

First half of bidirectional FIFO communication — sends on one pipe, receives on another.

04-mk-fifo-two-way/process_a.c111 lines

/*
 * process_a.c — Two-way FIFO — process A (writes then reads)
 *
 * Key concepts: Bidirectional IPC using two named pipes
 * Compile: gcc -o proc_a process_a.c
 * Run:     ./prog
 */
// process_a.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_WRONLY, O_RDONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For close
#include <string.h>
#include <errno.h>

const char *FIFO_A_TO_B = "fifo_a_to_b";
const char *FIFO_B_TO_A = "fifo_b_to_a";
const int BUFFER_SIZE = 1024;


int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Two-way FIFO — process A (writes t\n");
    printf("══════════════════════════════════════\n\n");
    FILE *fp_write, *fp_read;
    char buffer[BUFFER_SIZE];
    pid_t pid = getpid();

    // Create both FIFOs if they do not exist
    if (mkfifo(FIFO_A_TO_B, 0666) == -1) {
        if (errno != EEXIST) {
            perror("mkfifo fifo_a_to_b");
            exit(EXIT_FAILURE);
        }
    }

    if (mkfifo(FIFO_B_TO_A, 0666) == -1) {
        if (errno != EEXIST) {
            perror("mkfifo fifo_b_to_a");
            exit(EXIT_FAILURE);
        }
    }

    printf("Process A (%d): FIFOs '%s' and '%s' created/opened.\n", pid, FIFO_A_TO_B, FIFO_B_TO_A);

    // Open FIFO_A_TO_B for writing
    fp_write = fopen(FIFO_A_TO_B, "w");
    if (fp_write == NULL) {
        perror("fopen fifo_a_to_b for writing");
        exit(EXIT_FAILURE);
    }

    // Open FIFO_B_TO_A for reading
    fp_read = fopen(FIFO_B_TO_A, "r");
    if (fp_read == NULL) {
        perror("fopen fifo_b_to_a for reading");
        fclose(fp_write);
        exit(EXIT_FAILURE);
    }

    printf("Process A (%d): Communication established. Type 'exit' to quit.\n", pid);

    while (1) {
        printf("Process A: You: ");
        fflush(stdout);

        // Read input from the user
        if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) {
            perror("fgets");
            break;
        }

        // Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

        // Write the message to FIFO_A_TO_B
        if (fprintf(fp_write, "%s\n", buffer) < 0) {
            perror("fprintf to fifo_a_to_b");
            break;
        }

        // Flush to ensure the message is sent immediately
        fflush(fp_write);

        // Exit condition
        if (strcmp(buffer, "exit") == 0) {
            break;
        }

        // Read the response from FIFO_B_TO_A
        if (fgets(buffer, BUFFER_SIZE, fp_read) == NULL) {
            perror("fgets from fifo_b_to_a");
            break;
        }

        // Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

        printf("Process A: Received -> %s\n", buffer);
    }

    // Close the FIFOs
    fclose(fp_write);
    fclose(fp_read);

    printf("Process A (%d): Exiting.\n", pid);
    return 0;
}

/*
 * process_a.c — Two-way FIFO — process A (writes then reads)
 *
 * Key concepts: Bidirectional IPC using two named pipes
 * Compile: gcc -o proc_a process_a.c
 * Run:     ./prog
 */
// process_a.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_WRONLY, O_RDONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For close
#include <string.h>
#include <errno.h>

const char *FIFO_A_TO_B = "fifo_a_to_b";
const char *FIFO_B_TO_A = "fifo_b_to_a";
const int BUFFER_SIZE = 1024;

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Two-way FIFO — process A (writes t\n");
    printf("══════════════════════════════════════\n\n");
    FILE *fp_write, *fp_read;
    char buffer[BUFFER_SIZE];
    pid_t pid = getpid();

// Create both FIFOs if they do not exist
    if (mkfifo(FIFO_A_TO_B, 0666) == -1) {
        if (errno != EEXIST) {
            perror("mkfifo fifo_a_to_b");
            exit(EXIT_FAILURE);
        }
    }

if (mkfifo(FIFO_B_TO_A, 0666) == -1) {
        if (errno != EEXIST) {
            perror("mkfifo fifo_b_to_a");
            exit(EXIT_FAILURE);
        }
    }

printf("Process A (%d): FIFOs '%s' and '%s' created/opened.\n", pid, FIFO_A_TO_B, FIFO_B_TO_A);

// Open FIFO_A_TO_B for writing
    fp_write = fopen(FIFO_A_TO_B, "w");
    if (fp_write == NULL) {
        perror("fopen fifo_a_to_b for writing");
        exit(EXIT_FAILURE);
    }

// Open FIFO_B_TO_A for reading
    fp_read = fopen(FIFO_B_TO_A, "r");
    if (fp_read == NULL) {
        perror("fopen fifo_b_to_a for reading");
        fclose(fp_write);
        exit(EXIT_FAILURE);
    }

printf("Process A (%d): Communication established. Type 'exit' to quit.\n", pid);

while (1) {
        printf("Process A: You: ");
        fflush(stdout);

// Read input from the user
        if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) {
            perror("fgets");
            break;
        }

// Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

// Write the message to FIFO_A_TO_B
        if (fprintf(fp_write, "%s\n", buffer) < 0) {
            perror("fprintf to fifo_a_to_b");
            break;
        }

// Flush to ensure the message is sent immediately
        fflush(fp_write);

// Exit condition
        if (strcmp(buffer, "exit") == 0) {
            break;
        }

// Read the response from FIFO_B_TO_A
        if (fgets(buffer, BUFFER_SIZE, fp_read) == NULL) {
            perror("fgets from fifo_b_to_a");
            break;
        }

// Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

printf("Process A: Received -> %s\n", buffer);
    }

// Close the FIFOs
    fclose(fp_write);
    fclose(fp_read);

printf("Process A (%d): Exiting.\n", pid);
    return 0;
}

Editing — changes are local only

6

Two-Way FIFO: Process B

Second half — mirrors process A for full-duplex named-pipe communication.

04-mk-fifo-two-way/process_b.c104 lines

/*
 * process_b.c — Two-way FIFO — process B (reads then writes)
 *
 * Key concepts: Bidirectional IPC using two named pipes
 * Compile: gcc -o proc_b process_b.c
 * Run:     ./prog
 */
// process_b.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_WRONLY, O_RDONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For close
#include <string.h>
#include <errno.h>
const char *FIFO_A_TO_B = "fifo_a_to_b";
const char *FIFO_B_TO_A = "fifo_b_to_a";
const int BUFFER_SIZE = 1024;

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Two-way FIFO — process B (reads th\n");
    printf("══════════════════════════════════════\n\n");
    FILE *fp_read, *fp_write;
    char buffer[BUFFER_SIZE];
    pid_t pid = getpid();

    // Create both FIFOs if they do not exist
    if (mkfifo(FIFO_A_TO_B, 0666) == -1) {
        if (errno != EEXIST) {
            perror("mkfifo fifo_a_to_b");
            exit(EXIT_FAILURE);
        }
    }

    if (mkfifo(FIFO_B_TO_A, 0666) == -1) {
        if (errno != EEXIST) {
            perror("mkfifo fifo_b_to_a");
            exit(EXIT_FAILURE);
        }
    }

    printf("Process B (%d): FIFOs '%s' and '%s' created/opened.\n", pid, FIFO_A_TO_B, FIFO_B_TO_A);

    // Open FIFO_A_TO_B for reading
    fp_read = fopen(FIFO_A_TO_B, "r");
    if (fp_read == NULL) {
        perror("fopen fifo_a_to_b for reading");
        exit(EXIT_FAILURE);
    }

    // Open FIFO_B_TO_A for writing
    fp_write = fopen(FIFO_B_TO_A, "w");
    if (fp_write == NULL) {
        perror("fopen fifo_b_to_a for writing");
        fclose(fp_read);
        exit(EXIT_FAILURE);
    }

    printf("Process B (%d): Communication established.\n", pid);

    while (1) {
        // Read the message from FIFO_A_TO_B
        if (fgets(buffer, BUFFER_SIZE, fp_read) == NULL) {
            perror("fgets from fifo_a_to_b");
            break;
        }

        // Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

        printf("Process B (%d): Received -> %s\n", pid, buffer);

        // Exit condition
        if (strcmp(buffer, "exit") == 0) {
            printf("Process B (%d): Exit signal received. Exiting.\n", pid);
            break;
        }

        // Prepare a response
        char response[BUFFER_SIZE];
        snprintf(response, BUFFER_SIZE, "Acknowledged: '%s'", buffer);

        // Write the response to FIFO_B_TO_A
        if (fprintf(fp_write, "%s\n", response) < 0) {
            perror("fprintf to fifo_b_to_a");
            break;
        }

        // Flush to ensure the response is sent immediately
        fflush(fp_write);
    }

    // Close the FIFOs
    fclose(fp_read);
    fclose(fp_write);


        //this will delete the FIFO file and its important to do it!!!
     unlink(FIFO_NAME);
    return 0;
}

/*
 * process_b.c — Two-way FIFO — process B (reads then writes)
 *
 * Key concepts: Bidirectional IPC using two named pipes
 * Compile: gcc -o proc_b process_b.c
 * Run:     ./prog
 */
// process_b.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // For O_WRONLY, O_RDONLY
#include <sys/stat.h>   // For mkfifo
#include <unistd.h>     // For close
#include <string.h>
#include <errno.h>
const char *FIFO_A_TO_B = "fifo_a_to_b";
const char *FIFO_B_TO_A = "fifo_b_to_a";
const int BUFFER_SIZE = 1024;

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Two-way FIFO — process B (reads th\n");
    printf("══════════════════════════════════════\n\n");
    FILE *fp_read, *fp_write;
    char buffer[BUFFER_SIZE];
    pid_t pid = getpid();

// Create both FIFOs if they do not exist
    if (mkfifo(FIFO_A_TO_B, 0666) == -1) {
        if (errno != EEXIST) {
            perror("mkfifo fifo_a_to_b");
            exit(EXIT_FAILURE);
        }
    }

if (mkfifo(FIFO_B_TO_A, 0666) == -1) {
        if (errno != EEXIST) {
            perror("mkfifo fifo_b_to_a");
            exit(EXIT_FAILURE);
        }
    }

printf("Process B (%d): FIFOs '%s' and '%s' created/opened.\n", pid, FIFO_A_TO_B, FIFO_B_TO_A);

// Open FIFO_A_TO_B for reading
    fp_read = fopen(FIFO_A_TO_B, "r");
    if (fp_read == NULL) {
        perror("fopen fifo_a_to_b for reading");
        exit(EXIT_FAILURE);
    }

// Open FIFO_B_TO_A for writing
    fp_write = fopen(FIFO_B_TO_A, "w");
    if (fp_write == NULL) {
        perror("fopen fifo_b_to_a for writing");
        fclose(fp_read);
        exit(EXIT_FAILURE);
    }

printf("Process B (%d): Communication established.\n", pid);

while (1) {
        // Read the message from FIFO_A_TO_B
        if (fgets(buffer, BUFFER_SIZE, fp_read) == NULL) {
            perror("fgets from fifo_a_to_b");
            break;
        }

// Remove newline character
        buffer[strcspn(buffer, "\n")] = '\0';

printf("Process B (%d): Received -> %s\n", pid, buffer);

// Exit condition
        if (strcmp(buffer, "exit") == 0) {
            printf("Process B (%d): Exit signal received. Exiting.\n", pid);
            break;
        }

// Prepare a response
        char response[BUFFER_SIZE];
        snprintf(response, BUFFER_SIZE, "Acknowledged: '%s'", buffer);

// Write the response to FIFO_B_TO_A
        if (fprintf(fp_write, "%s\n", response) < 0) {
            perror("fprintf to fifo_b_to_a");
            break;
        }

// Flush to ensure the response is sent immediately
        fflush(fp_write);
    }

// Close the FIFOs
    fclose(fp_read);
    fclose(fp_write);

//this will delete the FIFO file and its important to do it!!!
     unlink(FIFO_NAME);
    return 0;
}

Editing — changes are local only

7

Basic Message Queue

Parent-child communication using System V message queues with msgget, msgsnd, and msgrcv.

05-msg-que-basic/aba_yeled.c103 lines

/*
 * aba_yeled.c — Basic message queue — parent-child communication
 *
 * Key concepts: msgget, msgsnd, msgrcv, IPC_CREAT, message types
 * Compile: gcc -o msgq aba_yeled.c
 * Run:     ./prog
 */
/// includes needed for the program
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#define MSG_SIZE 100

//https://man7.org/linux/man-pages/man3/msgrcv.3p.html

int const ALLOWED_TYPES[] = {1, 2, 3};
//we HAVE to use define for msgbuf size
// cus c doesnt like const inside of structs
// cus they arent compile time constants for him
struct my_msgbuf {
    long mtype;       // Message type HAS TO BE LONG
    char mtext[MSG_SIZE];  // Message data
    // THIS CAN VARIE IN TYPE AND SIZE
};


int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Basic message queue — parent-child\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    pid_t pid;
    struct my_msgbuf buf;

    // Generate unique key using ftok
    key = ftok("/tmp", 65); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Create message queue and return identifier
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {  // Child Process: Receiver
        // Initialize buffer
        memset(&buf, 0, sizeof(buf));

        // Receive message of type 1
        if (msgrcv(msgid, &buf, sizeof(buf.mtext), ALLOWED_TYPES[0], 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }

        printf("[Child PID %d] Received message (type %ld): \"%s\"\n", getpid(), buf.mtype, buf.mtext);
        exit(EXIT_SUCCESS);
    } else {         // Parent Process: Sender
        // Prepare message
        buf.mtype = 1;
        strcpy(buf.mtext, "Hello from Parent!");

        // Send message
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }

        printf("[Parent PID %d] Sent message (type %ld): \"%s\" to queue %d\n", getpid(), buf.mtype, buf.mtext, msgid);

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

        // Remove message queue
        //VERY IMPORTANT TO DO THIS
        if (msgctl(msgid, IPC_RMID, NULL) == -1) {
            perror("msgctl");
            exit(EXIT_FAILURE);
        }
    }

    return 0;
}

/*
 * aba_yeled.c — Basic message queue — parent-child communication
 *
 * Key concepts: msgget, msgsnd, msgrcv, IPC_CREAT, message types
 * Compile: gcc -o msgq aba_yeled.c
 * Run:     ./prog
 */
/// includes needed for the program
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#define MSG_SIZE 100

//https://man7.org/linux/man-pages/man3/msgrcv.3p.html

int const ALLOWED_TYPES[] = {1, 2, 3};
//we HAVE to use define for msgbuf size
// cus c doesnt like const inside of structs
// cus they arent compile time constants for him
struct my_msgbuf {
    long mtype;       // Message type HAS TO BE LONG
    char mtext[MSG_SIZE];  // Message data
    // THIS CAN VARIE IN TYPE AND SIZE
};

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Basic message queue — parent-child\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    pid_t pid;
    struct my_msgbuf buf;

// Generate unique key using ftok
    key = ftok("/tmp", 65); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

// Create message queue and return identifier
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

if (pid == 0) {  // Child Process: Receiver
        // Initialize buffer
        memset(&buf, 0, sizeof(buf));

// Receive message of type 1
        if (msgrcv(msgid, &buf, sizeof(buf.mtext), ALLOWED_TYPES[0], 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }

printf("[Child PID %d] Received message (type %ld): \"%s\"\n", getpid(), buf.mtype, buf.mtext);
        exit(EXIT_SUCCESS);
    } else {         // Parent Process: Sender
        // Prepare message
        buf.mtype = 1;
        strcpy(buf.mtext, "Hello from Parent!");

// Send message
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }

printf("[Parent PID %d] Sent message (type %ld): \"%s\" to queue %d\n", getpid(), buf.mtype, buf.mtext, msgid);

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

// Remove message queue
        //VERY IMPORTANT TO DO THIS
        if (msgctl(msgid, IPC_RMID, NULL) == -1) {
            perror("msgctl");
            exit(EXIT_FAILURE);
        }
    }

return 0;
}

Editing — changes are local only

Expected Outputclick Run to execute live

========================================
  Basic message queue — parent-child
========================================

Child received message: Hello from Parent!

========================================
  Basic message queue — parent-child
========================================

Parent sent message: Hello from Parent!

8

Extended Message Queue

Expanded message queue example with typed messages and structured data.

05-msg-que-basic/02_aba_yeled.c95 lines

/*
 * 02_aba_yeled.c — Extended message queue with typed messages
 *
 * Key concepts: mtype field for selective message receiving
 * Compile: gcc -o msgq2 02_aba_yeled.c
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

struct my_msgbuf {
    long mtype;
    char mtext[100];
};
int const ALLOWED_TYPES[] = {1, 2, 3};

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Extended message queue with typed me\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    pid_t pid;
    struct my_msgbuf buf;

    // Generate unique key
    key = ftok("/tmp", 65); // 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Create message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {  // Child Process: Receiver for type 2
        memset(&buf, 0, sizeof(buf));

        // Receive message of type 2
        if (msgrcv(msgid, &buf, sizeof(buf.mtext), ALLOWED_TYPES[1], 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }

        printf("Child received message of type 2: %s\n", buf.mtext);
        exit(EXIT_SUCCESS);
    } else {         // Parent Process: Sender
        // Send message of type 1
        buf.mtype = 1;
        strcpy(buf.mtext, "Message Type 1");
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("msgsnd type 1");
            exit(EXIT_FAILURE);
        }
        printf("Parent sent message of type 1: %s\n", buf.mtext);

        // Send message of type 2
        buf.mtype = 2;
        strcpy(buf.mtext, "Message Type 2");
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("msgsnd type 2");
            exit(EXIT_FAILURE);
        }
        printf("Parent sent message of type 2: %s\n", buf.mtext);

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

        // Remove message queue
        if (msgctl(msgid, IPC_RMID, NULL) == -1) {
            perror("msgctl");
            exit(EXIT_FAILURE);
        }
    }

    return 0;
}

/*
 * 02_aba_yeled.c — Extended message queue with typed messages
 *
 * Key concepts: mtype field for selective message receiving
 * Compile: gcc -o msgq2 02_aba_yeled.c
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

struct my_msgbuf {
    long mtype;
    char mtext[100];
};
int const ALLOWED_TYPES[] = {1, 2, 3};

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Extended message queue with typed me\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    pid_t pid;
    struct my_msgbuf buf;

// Generate unique key
    key = ftok("/tmp", 65); // 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

// Create message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

if (pid == 0) {  // Child Process: Receiver for type 2
        memset(&buf, 0, sizeof(buf));

// Receive message of type 2
        if (msgrcv(msgid, &buf, sizeof(buf.mtext), ALLOWED_TYPES[1], 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }

printf("Child received message of type 2: %s\n", buf.mtext);
        exit(EXIT_SUCCESS);
    } else {         // Parent Process: Sender
        // Send message of type 1
        buf.mtype = 1;
        strcpy(buf.mtext, "Message Type 1");
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("msgsnd type 1");
            exit(EXIT_FAILURE);
        }
        printf("Parent sent message of type 1: %s\n", buf.mtext);

// Send message of type 2
        buf.mtype = 2;
        strcpy(buf.mtext, "Message Type 2");
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("msgsnd type 2");
            exit(EXIT_FAILURE);
        }
        printf("Parent sent message of type 2: %s\n", buf.mtext);

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

// Remove message queue
        if (msgctl(msgid, IPC_RMID, NULL) == -1) {
            perror("msgctl");
            exit(EXIT_FAILURE);
        }
    }

return 0;
}

Editing — changes are local only

Expected Outputclick Run to execute live

========================================
  Extended message queue with typed me
========================================

Child received message of type 2: Message Type 2

========================================
  Extended message queue with typed me
========================================

Parent sent message of type 1: Message Type 1
Parent sent message of type 2: Message Type 2

9

Bidirectional Message Queue

Two-way communication on a single message queue using different message types for each direction.

05-msg-que-basic/03_bidirection.c104 lines

/*
 * 03_bidirection.c — Bidirectional message queue communication
 *
 * Key concepts: Two-way IPC over a single message queue using mtype
 * Compile: gcc -o bidir 03_bidirection.c
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#define QUEUE_KEY_PATH "/tmp"
#define PROJECT_ID 65

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

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Bidirectional message queue communic\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    pid_t pid;
    struct my_msgbuf buf;

    // Generate unique key
    key = ftok(QUEUE_KEY_PATH, PROJECT_ID);
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Create message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {  // Child Process
        // Receive message from parent (type 1)
        memset(&buf, 0, sizeof(buf));
        if (msgrcv(msgid, &buf, sizeof(buf.mtext), 1, 0) == -1) {
            perror("Child msgrcv type 1");
            exit(EXIT_FAILURE);
        }
        printf("Child received from parent: %s\n", buf.mtext);

        // Send response to parent (type 2)
        buf.mtype = 2;
        strcpy(buf.mtext, "Hello from Child!");
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("Child msgsnd type 2");
            exit(EXIT_FAILURE);
        }
        printf("Child sent to parent: %s\n", buf.mtext);

        exit(EXIT_SUCCESS);
    } else {         // Parent Process
        // Send message to child (type 1)
        buf.mtype = 1;
        strcpy(buf.mtext, "Hello from Parent!");
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("Parent msgsnd type 1");
            exit(EXIT_FAILURE);
        }
        printf("Parent sent to child: %s\n", buf.mtext);

        // Receive response from child (type 2)
        memset(&buf, 0, sizeof(buf));
        if (msgrcv(msgid, &buf, sizeof(buf.mtext), 2, 0) == -1) {
            perror("Parent msgrcv type 2");
            exit(EXIT_FAILURE);
        }
        printf("Parent received from child: %s\n", buf.mtext);

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

        // Remove message queue
        if (msgctl(msgid, IPC_RMID, NULL) == -1) {
            perror("msgctl");
            exit(EXIT_FAILURE);
        }
    }

    return 0;
}

/*
 * 03_bidirection.c — Bidirectional message queue communication
 *
 * Key concepts: Two-way IPC over a single message queue using mtype
 * Compile: gcc -o bidir 03_bidirection.c
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#define QUEUE_KEY_PATH "/tmp"
#define PROJECT_ID 65

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

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Bidirectional message queue communic\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    pid_t pid;
    struct my_msgbuf buf;

// Generate unique key
    key = ftok(QUEUE_KEY_PATH, PROJECT_ID);
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

// Create message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

if (pid == 0) {  // Child Process
        // Receive message from parent (type 1)
        memset(&buf, 0, sizeof(buf));
        if (msgrcv(msgid, &buf, sizeof(buf.mtext), 1, 0) == -1) {
            perror("Child msgrcv type 1");
            exit(EXIT_FAILURE);
        }
        printf("Child received from parent: %s\n", buf.mtext);

// Send response to parent (type 2)
        buf.mtype = 2;
        strcpy(buf.mtext, "Hello from Child!");
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("Child msgsnd type 2");
            exit(EXIT_FAILURE);
        }
        printf("Child sent to parent: %s\n", buf.mtext);

exit(EXIT_SUCCESS);
    } else {         // Parent Process
        // Send message to child (type 1)
        buf.mtype = 1;
        strcpy(buf.mtext, "Hello from Parent!");
        if (msgsnd(msgid, &buf, sizeof(buf.mtext), 0) == -1) {
            perror("Parent msgsnd type 1");
            exit(EXIT_FAILURE);
        }
        printf("Parent sent to child: %s\n", buf.mtext);

// Receive response from child (type 2)
        memset(&buf, 0, sizeof(buf));
        if (msgrcv(msgid, &buf, sizeof(buf.mtext), 2, 0) == -1) {
            perror("Parent msgrcv type 2");
            exit(EXIT_FAILURE);
        }
        printf("Parent received from child: %s\n", buf.mtext);

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

// Remove message queue
        if (msgctl(msgid, IPC_RMID, NULL) == -1) {
            perror("msgctl");
            exit(EXIT_FAILURE);
        }
    }

return 0;
}

Editing — changes are local only

Expected Outputclick Run to execute live

========================================
  Bidirectional message queue communic
========================================

Child received from parent: Hello from Parent!
Child sent to parent: Hello from Child!

========================================
  Bidirectional message queue communic
========================================

Parent sent to child: Hello from Parent!
Parent received from child: Hello from Child!

10

IPC Cleanup with ipcrm

Cleaning up System V IPC resources (message queues, shared memory, semaphores) with msgctl and ipcrm.

06-ipcm-ipcrm-removing.c67 lines

/*
 * 06-ipcm-ipcrm-removing.c — Cleaning up IPC resources — ipcs and ipcrm
 *
 * Key concepts: msgctl IPC_RMID, cleaning up message queues, ipcs command
 * Compile: gcc -o cleanup 06-ipcm-ipcrm-removing.c
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>


// THIS PROGRAM DOESNT!!! DELETE THE MESSAGE QUEUE
// so we will have to do it manually

//ipcs -q
//example output:
/*
------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages    
0x12345    123456     user       644        0            0           
*/

//removing:
//ipcrm -q 123456

// run again:
//ipcs -q



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

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Cleaning up IPC resources — ipcs a\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    struct my_msgbuf buf;

    // Generate unique key
      key = ftok("/tmp", 65); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Create message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    printf("Message Queue created with msgid: %d\n", msgid);

    // Program ends without deleting the message queue
    return 0;
}

Expected Outputclick Run to execute live

========================================
  Cleaning up IPC resources — ipcs a
========================================

Message Queue created with msgid: 3

11

Message Queue Sender

A standalone sender program that pushes messages onto a System V message queue.

07-msg-que-two-progs/sender.c73 lines

/*
 * sender.c — Message queue sender (separate program)
 *
 * Key concepts: msgsnd, cross-program IPC via shared queue key
 * Compile: gcc -o sender sender.c
 * Run:     ./prog
 */
// sender.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>


int const MSG_TYPE_EXIT =  3;
struct my_msgbuf {
    long mtype; // Message type
    char mtext[256]; // Message data
};

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Message queue sender (separate progr\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    struct my_msgbuf buf;

    // Generate the same unique key
       key = ftok("/tmp", 65); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Access the message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    printf("Sender: Enter messages to send. Type 'exit' to quit.\n");

    while (1) {
        printf("Sender: ");
        fflush(stdout);
        fgets(buf.mtext, sizeof(buf.mtext), stdin);
        buf.mtext[strcspn(buf.mtext, "\n")] = '\0'; // Remove newline

        if (strcmp(buf.mtext, "exit") == 0) {
            buf.mtype = MSG_TYPE_EXIT;
        } else {
            buf.mtype = 1; // Default message type
        }

        // Send the message
        if (msgsnd(msgid, &buf, strlen(buf.mtext) + 1, 0) == -1) {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }

        if (buf.mtype == MSG_TYPE_EXIT) {
            printf("Sender: Exit message sent. Exiting.\n");
            break;
        }
    }

    return 0;
}

12

Message Queue Receiver

A standalone receiver that pulls messages from the queue — run alongside the sender.

07-msg-que-two-progs/receiver.c70 lines

/*
 * receiver.c — Message queue receiver (separate program)
 *
 * Key concepts: msgrcv, blocking receive, message types
 * Compile: gcc -o receiver receiver.c
 * Run:     ./prog
 */
// receiver.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
int const MSG_TYPE_EXIT =  3;

struct my_msgbuf {
    long mtype; // Message type
    char mtext[256]; // Message data
};

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Message queue receiver (separate pro\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    struct my_msgbuf buf;

    // Generate unique key using ftok
       key = ftok("/tmp", 65); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Create or access the message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    printf("Receiver: Waiting for messages...\n");

    while (1) {
        // Receive any message
        if (msgrcv(msgid, &buf, sizeof(buf.mtext), 0, 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }

        // Check for exit message
        if (buf.mtype == MSG_TYPE_EXIT) {
            printf("Receiver: Exit message received. Exiting.\n");
            break;
        }

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

    // Cleanup: Remove the message queue
    if (msgctl(msgid, IPC_RMID, NULL) == -1) {
        perror("msgctl");
        exit(EXIT_FAILURE);
    }

    return 0;
}

13

Calculator Sender

Sends arithmetic expressions through a message queue to a calculator receiver process.

08-calc-que/calc_sender.c152 lines

/*
 * calc_sender.c — Calculator via message queue — sender side
 *
 * Key concepts: Sends arithmetic expressions over message queue
 * Compile: gcc -o calc_send calc_sender.c
 * Run:     ./prog
 */
// calc_sender.c

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

// Define message types using const int for better type safety and clarity
const int MSG_TYPE_CALC_REQUEST = 1;
const int MSG_TYPE_CALC_RESPONSE = 2;
const int MSG_TYPE_EXIT = 3;

// Structure for calculation requests
struct calc_request {
    char operation;     // '+', '-', '*', '/'
    double operand1;
    double operand2;
};

// Structure for calculation responses
struct calc_response {
    double result;
    char status;        // '0' for success, '1' for error (e.g., division by zero)
};

// Structure for message buffer
struct my_msgbuf {
    long mtype;                     // Message type
    union {
        struct calc_request req;    // Calculation request
        struct calc_response res;   // Calculation response
    } data;
};

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Calculator via message queue — sen\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    struct my_msgbuf buf;

    // Generate a unique key using ftok
       key = ftok("/tmp", 65); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Access the message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    printf("Calculator Sender: Enter operations in the format <op> <num1> <num2>\n");
    printf("Example: + 5 3\n");
    printf("Type 'e' to terminate the receiver.\n");

    while (1) {
        char operation;
        double num1, num2;

        printf("Enter operation (+, -, *, /) then two numbers, or 'e' to exit: ");
        fflush(stdout);

        // Read the operation
        int ret = scanf(" %c", &operation);
        if (ret != 1) {
            printf("Invalid input. Please try again.\n");
            // Clear input buffer
            while (getchar() != '\n');
            continue;
        }

        // Check for exit condition
        if (operation == 'e' || operation == 'E') { // 'e' or 'E' to exit
            // Clear the rest of the line
            while (getchar() != '\n');

            // Prepare exit message
            buf.mtype = MSG_TYPE_EXIT;
            memset(&buf.data, 0, sizeof(buf.data)); // Clear data

            // Send exit message with no data
            if (msgsnd(msgid, &buf, 0, 0) == -1) { // Size 0 since no data
                perror("msgsnd");
                exit(EXIT_FAILURE);
            }

            printf("Calculator Sender: Exit message sent. Exiting.\n");
            break;
        }

        // Read operands
        ret = scanf("%lf %lf", &num1, &num2);
        if (ret != 2) {
            printf("Invalid operands. Please try again.\n");
            // Clear input buffer
            while (getchar() != '\n');
            continue;
        }

        // Prepare calculation request
        struct calc_request req;
        req.operation = operation;
        req.operand1 = num1;
        req.operand2 = num2;

        // Prepare message buffer
        buf.mtype = MSG_TYPE_CALC_REQUEST;
        buf.data.req = req;

        // Send the calculation request
        if (msgsnd(msgid, &buf, sizeof(req), 0) == -1) {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }

        printf("Calculator Sender: Calculation request sent.\n");

        // Wait for the calculation response
        if (msgrcv(msgid, &buf, sizeof(buf.data), MSG_TYPE_CALC_RESPONSE, 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }

        // Deserialize the response
        struct calc_response res = buf.data.res;

        // Display the result or error
        if (res.status == '0') {
            printf("Calculator Sender: Result = %.2lf\n", res.result);
        }
        else {
            printf("Calculator Sender: Error in calculation.\n");
        }
    }

    return 0;
}

/*
 * calc_sender.c — Calculator via message queue — sender side
 *
 * Key concepts: Sends arithmetic expressions over message queue
 * Compile: gcc -o calc_send calc_sender.c
 * Run:     ./prog
 */
// calc_sender.c

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

// Define message types using const int for better type safety and clarity
const int MSG_TYPE_CALC_REQUEST = 1;
const int MSG_TYPE_CALC_RESPONSE = 2;
const int MSG_TYPE_EXIT = 3;

// Structure for calculation requests
struct calc_request {
    char operation;     // '+', '-', '*', '/'
    double operand1;
    double operand2;
};

// Structure for calculation responses
struct calc_response {
    double result;
    char status;        // '0' for success, '1' for error (e.g., division by zero)
};

// Structure for message buffer
struct my_msgbuf {
    long mtype;                     // Message type
    union {
        struct calc_request req;    // Calculation request
        struct calc_response res;   // Calculation response
    } data;
};

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Calculator via message queue — sen\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    struct my_msgbuf buf;

// Generate a unique key using ftok
       key = ftok("/tmp", 65); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

// Access the message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

printf("Calculator Sender: Enter operations in the format <op> <num1> <num2>\n");
    printf("Example: + 5 3\n");
    printf("Type 'e' to terminate the receiver.\n");

while (1) {
        char operation;
        double num1, num2;

printf("Enter operation (+, -, *, /) then two numbers, or 'e' to exit: ");
        fflush(stdout);

// Read the operation
        int ret = scanf(" %c", &operation);
        if (ret != 1) {
            printf("Invalid input. Please try again.\n");
            // Clear input buffer
            while (getchar() != '\n');
            continue;
        }

// Check for exit condition
        if (operation == 'e' || operation == 'E') { // 'e' or 'E' to exit
            // Clear the rest of the line
            while (getchar() != '\n');

// Prepare exit message
            buf.mtype = MSG_TYPE_EXIT;
            memset(&buf.data, 0, sizeof(buf.data)); // Clear data

// Send exit message with no data
            if (msgsnd(msgid, &buf, 0, 0) == -1) { // Size 0 since no data
                perror("msgsnd");
                exit(EXIT_FAILURE);
            }

printf("Calculator Sender: Exit message sent. Exiting.\n");
            break;
        }

// Read operands
        ret = scanf("%lf %lf", &num1, &num2);
        if (ret != 2) {
            printf("Invalid operands. Please try again.\n");
            // Clear input buffer
            while (getchar() != '\n');
            continue;
        }

// Prepare calculation request
        struct calc_request req;
        req.operation = operation;
        req.operand1 = num1;
        req.operand2 = num2;

// Prepare message buffer
        buf.mtype = MSG_TYPE_CALC_REQUEST;
        buf.data.req = req;

// Send the calculation request
        if (msgsnd(msgid, &buf, sizeof(req), 0) == -1) {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }

printf("Calculator Sender: Calculation request sent.\n");

// Wait for the calculation response
        if (msgrcv(msgid, &buf, sizeof(buf.data), MSG_TYPE_CALC_RESPONSE, 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }

// Deserialize the response
        struct calc_response res = buf.data.res;

// Display the result or error
        if (res.status == '0') {
            printf("Calculator Sender: Result = %.2lf\n", res.result);
        }
        else {
            printf("Calculator Sender: Error in calculation.\n");
        }
    }

return 0;
}

Editing — changes are local only

14

Calculator Receiver

Receives expressions from the message queue, evaluates them, and sends results back.

08-calc-que/calc_receiver.c140 lines

/*
 * calc_receiver.c — Calculator via message queue — receiver/evaluator
 *
 * Key concepts: Receives expressions, computes result, sends back
 * Compile: gcc -o calc_recv calc_receiver.c
 * Run:     ./prog
 */
// calc_receiver.c

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

// Define message types using const int for better type safety and clarity
const int MSG_TYPE_CALC_REQUEST = 1;
const int MSG_TYPE_CALC_RESPONSE = 2;
const int MSG_TYPE_EXIT = 3;

// Structure for calculation requests
struct calc_request {
    char operation;     // '+', '-', '*', '/'
    double operand1;
    double operand2;
};

// Structure for calculation responses
struct calc_response {
    double result;
    char status;        // '0' for success, '1' for error (e.g., division by zero)
};

// Structure for message buffer
struct my_msgbuf {
    long mtype;                     // Message type
    union {
        struct calc_request req;    // Calculation request
        struct calc_response res;   // Calculation response
    } data;
};

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Calculator via message queue — rec\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    struct my_msgbuf buf;

    // Generate unique key using ftok
      key = ftok("/tmp", 65); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Create or access the message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    printf("Calculator Receiver: Waiting for calculation requests...\n");

    while (1) {
        // Receive any message type (mtype = 0)
        if (msgrcv(msgid, &buf, sizeof(buf.data), 0, 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }

        // Handle different message types
        if (buf.mtype == MSG_TYPE_EXIT) {
            printf("Calculator Receiver: Exit message received. Exiting.\n");
            break;
        }
        else if (buf.mtype == MSG_TYPE_CALC_REQUEST) {
            // Process calculation request
            struct calc_request req = buf.data.req;
            struct calc_response res;
            res.status = '0'; // Assume success

            printf("Calculator Receiver: Received operation '%c' with operands %.2lf and %.2lf\n",
                   req.operation, req.operand1, req.operand2);

            // Perform calculation
            switch (req.operation) {
                case '+':
                    res.result = req.operand1 + req.operand2;
                    break;
                case '-':
                    res.result = req.operand1 - req.operand2;
                    break;
                case '*':
                    res.result = req.operand1 * req.operand2;
                    break;
                case '/':
                    if (req.operand2 != 0) {
                        res.result = req.operand1 / req.operand2;
                    } else {
                        res.status = '1'; // Error: Division by zero
                        res.result = 0.0;
                    }
                    break;
                default:
                    res.status = '1'; // Error: Unknown operation
                    res.result = 0.0;
            }

            // Prepare response message
            struct my_msgbuf res_buf;
            res_buf.mtype = MSG_TYPE_CALC_RESPONSE;
            res_buf.data.res = res;

            // Send response
            if (msgsnd(msgid, &res_buf, sizeof(res), 0) == -1) {
                perror("msgsnd");
                exit(EXIT_FAILURE);
            }

            printf("Calculator Receiver: Sent calculation result.\n");
        }
        else {
            printf("Calculator Receiver: Unknown message type received: %ld\n", buf.mtype);
        }
    }

    // Cleanup: Remove the message queue
    if (msgctl(msgid, IPC_RMID, NULL) == -1) {
        perror("msgctl");
        exit(EXIT_FAILURE);
    }

    return 0;
}

/*
 * calc_receiver.c — Calculator via message queue — receiver/evaluator
 *
 * Key concepts: Receives expressions, computes result, sends back
 * Compile: gcc -o calc_recv calc_receiver.c
 * Run:     ./prog
 */
// calc_receiver.c

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

// Define message types using const int for better type safety and clarity
const int MSG_TYPE_CALC_REQUEST = 1;
const int MSG_TYPE_CALC_RESPONSE = 2;
const int MSG_TYPE_EXIT = 3;

// Structure for calculation requests
struct calc_request {
    char operation;     // '+', '-', '*', '/'
    double operand1;
    double operand2;
};

// Structure for calculation responses
struct calc_response {
    double result;
    char status;        // '0' for success, '1' for error (e.g., division by zero)
};

// Structure for message buffer
struct my_msgbuf {
    long mtype;                     // Message type
    union {
        struct calc_request req;    // Calculation request
        struct calc_response res;   // Calculation response
    } data;
};

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Calculator via message queue — rec\n");
    printf("══════════════════════════════════════\n\n");
    key_t key;
    int msgid;
    struct my_msgbuf buf;

// Generate unique key using ftok
      key = ftok("/tmp", 65); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

// Create or access the message queue
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

printf("Calculator Receiver: Waiting for calculation requests...\n");

while (1) {
        // Receive any message type (mtype = 0)
        if (msgrcv(msgid, &buf, sizeof(buf.data), 0, 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }

// Handle different message types
        if (buf.mtype == MSG_TYPE_EXIT) {
            printf("Calculator Receiver: Exit message received. Exiting.\n");
            break;
        }
        else if (buf.mtype == MSG_TYPE_CALC_REQUEST) {
            // Process calculation request
            struct calc_request req = buf.data.req;
            struct calc_response res;
            res.status = '0'; // Assume success

printf("Calculator Receiver: Received operation '%c' with operands %.2lf and %.2lf\n",
                   req.operation, req.operand1, req.operand2);

// Perform calculation
            switch (req.operation) {
                case '+':
                    res.result = req.operand1 + req.operand2;
                    break;
                case '-':
                    res.result = req.operand1 - req.operand2;
                    break;
                case '*':
                    res.result = req.operand1 * req.operand2;
                    break;
                case '/':
                    if (req.operand2 != 0) {
                        res.result = req.operand1 / req.operand2;
                    } else {
                        res.status = '1'; // Error: Division by zero
                        res.result = 0.0;
                    }
                    break;
                default:
                    res.status = '1'; // Error: Unknown operation
                    res.result = 0.0;
            }

// Prepare response message
            struct my_msgbuf res_buf;
            res_buf.mtype = MSG_TYPE_CALC_RESPONSE;
            res_buf.data.res = res;

// Send response
            if (msgsnd(msgid, &res_buf, sizeof(res), 0) == -1) {
                perror("msgsnd");
                exit(EXIT_FAILURE);
            }

printf("Calculator Receiver: Sent calculation result.\n");
        }
        else {
            printf("Calculator Receiver: Unknown message type received: %ld\n", buf.mtype);
        }
    }

// Cleanup: Remove the message queue
    if (msgctl(msgid, IPC_RMID, NULL) == -1) {
        perror("msgctl");
        exit(EXIT_FAILURE);
    }

return 0;
}

Editing — changes are local only

Named Pipes & Message Queues

FIFO Reader

FIFO Writer

Multiple FIFO Writers

Multi-Writer Reader

Two-Way FIFO: Process A

Two-Way FIFO: Process B

Basic Message Queue

Extended Message Queue

Bidirectional Message Queue

IPC Cleanup with ipcrm

Message Queue Sender

Message Queue Receiver

Calculator Sender

Calculator Receiver

Open Full Terminal