FIFO внедряет систему процессов

Question

Я пытаюсь изучать процессы на C, и я думаю, что понял логику pipe, но не могу понять fifo, даже если много о ней читал. Недавно я создал программу, использующую канал, который берет строку из стандартного ввода, записывает ее в pipe1, проверяет, является ли она буквенно-цифровой, и если да, pipe3 читает и показывает ее. Если строка содержит только цифры, pipe2 читает ее и заменяет цифры на _, затем pipe4 читает новую строку и показывает ее. Я помещаю это здесь, потому что я хочу сделать что-то подобное, используя fifo:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<string.h>
#include<sys/wait.h>
#include<ctype.h>

int main()
{
int p1[2];
int p2[2];
int p3[2];
int p4[2];

char input_str[100];
pid_t fork1;
pid_t fork2;

if (pipe(p1)==-1)
{
    fprintf(stderr, "Pipe Failed" );
    return 1;
}
if (pipe(p2)==-1)
{
    fprintf(stderr, "Pipe Failed" );
    return 1;
}
if (pipe(p3)==-1)
{
    fprintf(stderr, "Pipe Failed" );
    return 1;
}
if (pipe(p4)==-1)
{
    fprintf(stderr, "Pipe Failed" );
    return 1;
}


scanf("%s", input_str);

int isAlpha = 0; 
int onlyDigits = 0; 
for (int i=0; input_str[i]!= '\0'; i++) 
{

    if (isalpha(input_str[i]) != 0) {
        isAlpha = 1;
        onlyDigits = 0;
    }
    else if (isdigit(input_str[i]) != 0) {
        isAlpha = 1;
        onlyDigits = 1;
    }
    else { 
        isAlpha = 0;
        onlyDigits = 0;
    }
}


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


else if (fork1 > 0)
{
    close(p1[0]); 
    write(p1[1], input_str, strlen(input_str)+1);
}


else
{
    close(p1[1]);
    char string_from_p1[100];
    read(p1[0], string_from_p1, 100);
    close(p1[0]);
    fork2 = fork();
    if (onlyDigits) {
        for (int i=0; string_from_p1[i]!= '\0'; i++) {
            if (isdigit(string_from_p1[i]) != 0)
                string_from_p1[i] = '_';
        }
        write(p2[1], string_from_p1, strlen(string_from_p1)+1);
    }
    else if (isAlpha) {
        write(p3[1], string_from_p1, strlen(string_from_p1)+1);
    }
    if (fork2 < 0) {
            fprintf(stderr, "fork Failed" );
            return 1;
    }
    else if (fork2 > 0) {
        char string_from_p2[100];
        char string_from_p3[100];
        char string_from_p4[100];
        if (onlyDigits) {
            close(p2[1]);
            read(p2[0], string_from_p2, 100);
            close(p2[0]);
            write(p4[1], string_from_p2, strlen(string_from_p2)+1);
            close(p4[1]);
            read(p4[0], string_from_p4, 100);
            printf("String from pipe4: %s\n", string_from_p4);
        }
        else if (isAlpha) {
            close(p3[1]);
            read(p3[0], string_from_p3, 100);
            printf("String from pipe3: %s\n", string_from_p3);
        }
    }
exit(0);
}
}

Не уверен, насколько это правильно, но программа FIFO будет иметь только 3 процесса, сначала она читает из стандартных строк ввода длиной не более 30 символов, записывает в первом выходе (process2) цифры и во втором выходе (process3) буквы , тогда в process2 отображается только результат (найденные цифры), а в process3 маленькие буквы превращаются в заглавные и отображаются результаты.

Может кто-нибудь, пожалуйста, помогите мне?

Answer 1

В качестве отправной точки вы можете попробовать что-то вроде этого (большинство функций еще нужно реализовать, см. Комментарии):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <ctype.h>

void read_and_write(const char *digits_fifo, const char *chars_fifo);
pid_t spawn_digits_child(const char *digits_fifo);
pid_t spawn_chars_child(const char *chars_fifo);
void digits_child(const char *digits_fifo);
void chars_child(const char *chars_fifo);
void wait_until_children_finish(pid_t pid1, pid_t pid2);

#define MAX_INPUT 30

int main() {
    char *digits_fifo = "/tmp/digits_fifo";
    char *chars_fifo = "/tmp/chars_fifo";

    mkfifo(digits_fifo, 0666);
    mkfifo(chars_fifo, 0666);

    //fork digits process
    pid_t pid_digits = spawn_digits_child(digits_fifo);

    //fork chars process
    pid_t pid_chars = spawn_chars_child(chars_fifo);

    //parent
    read_and_write(digits_fifo, chars_fifo);
    wait_until_children_finish(pid_digits, pid_chars);
    exit(0);
}

pid_t spawn_digits_child(const char *digits_fifo) {
    pid_t pid1;
    if ((pid1 = fork()) < 0) {
        fprintf(stderr, "fork error digits process\n");
        exit(-1);
    } else if (pid1 == 0) {
        digits_child(digits_fifo);
        exit(0);
    }
    return pid1;
}

pid_t spawn_chars_child(const char *chars_fifo) {
    //do sth similar then in spawn_digits_child but for chars child process
}

void wait_until_children_finish(pid_t pid1, pid_t pid2) {
    //use waitpid to wait for child process termination
}

void read_and_write(const char *digits_fifo, const char *chars_fifo) {
    //read input string 
    //open the two named pipes with O_WRONLY
    //check with isdigit respective isalpha and send to the corresponding named pipe
    //don't forget to close file handles
}

void chars_child(const char *chars_fifo) {
    //open named piped with O_RDONLY
    //e.g. int chars_fd = open(chars_fifo, O_RDONLY);
    //read from pipe
    //do uppercase string
    //output it with printf
}

void digits_child(const char *digits_fifo) {
    //open named piped with O_RDONLY
    //e.g. int chars_fd = open(digits_fifo, O_RDONLY);
    //read from pipe
    //output it with printf
}