Processes synchronization with message queues and signals

Question

I have to create three processes:

1. Reading expression like 1+3+5+12
2. Checking if expression has correct syntax
3. Adding numbers and displaying them

Data between processes is shared using pipes mechanism. Processes synchronization uses message queues and signals.I also should be able to manually send signals to each process through console.

The problem I am running into this is that all processes seem to run randomly. Why is that, what's wrong here? It should work...

This is the whole code that compiles correctly:

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

#define SIZEBUFF 256

// Signal handling for each process
void h_sig1(int signo);
void h_sig2(int signo);
void h_sig3(int signo);
void h_S4(int signo);

// Processes functions
void process1(void);
void process2(void);
void process3(void);

// helper functions
bool isInteger(double val);

static pid_t P1, P2, P3; // PIDs for each process

int P; // parent PID
int pfd12[2], pfd23[2]; // Pipes between processes 1-2 and 2-3
int providePIDY1[2], providePIDY2[2]; // provide all PIDs to 1/2 process

// message in message queue
typedef struct 
{
    long type;
    int sigNum;
} message;

int queue_ID;

int main(void)
{
    P = getpid();

    // Message queue created
    if ((queue_ID = msgget(IPC_PRIVATE,IPC_CREAT|0666)) < 0)
    {
        printf("msgget\n");
        return 1;
    }

    if((P1 = fork()) == 0)
    {
        P1 = getpid();
        process1();
    }
    else if((P2 = fork()) == 0)
    {
        P2 = getpid();
        process2();
    }
    else if((P3 = fork()) == 0)
    {
        P3 = getpid();
        process3();
    }
    else
    { // Sending signals from parent through operator

        // Sending PIDs to process 1
        close(providePIDY1[0]);
        write(providePIDY1[1], &P, sizeof(int));
        write(providePIDY1[1], &P1, sizeof(int));
        write(providePIDY1[1], &P2, sizeof(int));
        write(providePIDY1[1], &P3, sizeof(int));
        close(providePIDY1[1]);

        // Sending PIDs to process 2
        close(providePIDY2[0]);
        write(providePIDY2[1], &P, sizeof(int));
        write(providePIDY2[1], &P1, sizeof(int));
        write(providePIDY2[1], &P2, sizeof(int));
        write(providePIDY2[1], &P3, sizeof(int));
        close(providePIDY2[1]);

        printf("\nProgram options:\n");
        printf("Send signal - 's'(send)\n");
        printf("Display processes PIDs 'p'(pids)\n");
        printf("Quit program - 'q'(quit)\n");

        char choice, choice2, choice3;

        while(1)
        {
            choice = getchar();

            if(choice == 's')
            {        
                printf("Which process is receiving the signal - 1, 2, or 3?: ");
                choice2 = getchar();
                choice2 = getchar();
                printf("\n");

                if((choice2 < 1) && (choice2 > 3))
                {
                    printf("No such process!");
                    continue;
                }

                printf("What signal to send?:\n");
                printf("1-S1(end execution)\n2-S2(pause execution)\n3-S3(renew execution)?\n ");
                printf("Choice: ");
                choice3 = getchar();
                choice3 = getchar();
                switch(choice2)
                {
                    case '1':  //nie można przechwycić sygnałów SIGKILL oraz SIGSTOP (zabicia oraz zatrzymania)
                        if(choice3 == '1') { kill(0,SIGCONT); kill(P1,SIGUSR1); }
                        if(choice3 == '2') kill(P1,SIGTSTP);
                        if(choice3 == '3') { kill(0,SIGCONT); kill(P3,SIGALRM); }
                        break;
                    case '2': 
                          if(choice3 == '1') { kill(0,SIGCONT); kill(P2,SIGUSR1); }
                          if(choice3 == '2') kill(P2,SIGTSTP); 
                          if(choice3 == '3') { kill(0,SIGCONT); kill(P3,SIGALRM); }
                        break;
                    case '3': 
                          if(choice3 == '1') { kill(0,SIGCONT); kill(P3,SIGUSR1); }
                          if(choice3 == '2') kill(P3,SIGTSTP);
                          if(choice3 == '3') { kill(0,SIGCONT); kill(P3,SIGALRM); }
                        break;
                    default: printf("No such operation!!! \n\n");
                }
            }

            if(choice == 'p')
            {
                // do something
            }

            if(choice == 'q')
            {
                // do something
            }
       }

    }
}

void process1(void)
{
    // Receiving PIDs
    close(providePIDY1[1]);
    read(providePIDY1[0], &P, sizeof(int));
    read(providePIDY1[0], &P1, sizeof(int));
    read(providePIDY1[0], &P2, sizeof(int));
    read(providePIDY1[0], &P3, sizeof(int));
    close(providePIDY1[0]);

    struct sigaction act1;

    act1.sa_handler = h_sig1;
    sigemptyset(&act1.sa_mask);
    act1.sa_flags = 0;
    sigaction(SIGUSR1, &act1, 0);
    sigaction(SIGTSTP, &act1, 0);
    sigaction(SIGALRM, &act1, 0);

    struct sigaction act;
    act.sa_handler = h_S4;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, 0);

    // do something
}

void process2(void)
{
    close(providePIDY2[1]);
    read(providePIDY2[0], &P, sizeof(int));
    read(providePIDY2[0], &P1, sizeof(int));
    read(providePIDY2[0], &P2, sizeof(int));
    read(providePIDY2[0], &P3, sizeof(int));
    close(providePIDY2[0]);

    struct sigaction act2;
    act2.sa_handler = h_sig2;
    sigemptyset(&act2.sa_mask);
    act2.sa_flags = 0;
    sigaction(SIGUSR1, &act2, 0);
    sigaction(SIGTSTP, &act2, 0);
    sigaction(SIGALRM, &act2, 0);

    struct sigaction act;
    act.sa_handler = h_S4;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, 0);

    // do something
}

void process3(void)
{
    struct sigaction act3;

    act3.sa_handler = h_sig3;
    sigemptyset(&act3.sa_mask);
    act3.sa_flags = 0;
    sigaction(SIGUSR1, &act3, 0);
    sigaction(SIGTSTP, &act3, 0);
    sigaction(SIGALRM, &act3, 0);

    struct sigaction act;
    act.sa_handler = h_S4;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, 0);

    // do something
}

void h_sig1(int signo)
{
    message msg;

    msg.type = P2;
    msg.sigNum = signo;

    kill(P2, SIGINT);

    // send type of receiving signal to message queue
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    msg.type = P3;
    kill(P3, SIGINT);
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    if(signo == SIGUSR1)
    {    
    }

    if(signo == SIGTSTP)
    {
    }    

    if(signo == SIGALRM)
    {
    }    
}

void h_sig2(int signo)
{
    message msg;

    msg.type = P1;
    msg.sigNum = signo;

    kill(P1, SIGINT);

    // send type of receiving signal to message queue
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    msg.type = P3;
    kill(P3, SIGINT);
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    if(signo == SIGUSR1)
    {    
    }

    if(signo == SIGTSTP)
    {
    }    

    if(signo == SIGALRM)
    {
    }    
}

void h_sig3(int signo)
{
    message msg;

    msg.type = P1;
    msg.sigNum = signo;

    kill(P1, SIGINT);

    // send type of receiving signal to message queue
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    msg.type = P2;
    kill(P2, SIGINT);
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    if(signo == SIGUSR1)
    {    
    }

    if(signo == SIGTSTP)
    {
    }    

    if(signo == SIGALRM)
    {
    }    
}

void h_S4(int signo)
{
    int res;
    message msg;

    printf("\nProcess with PID=%d received signal S4", getpid());

    if(signo == SIGINT)
    {
        res = msgrcv(queue_ID, &msg, sizeof(msg.sigNum), msg.type, 0);

        if(res >= 0)
        {            
            if(msg.sigNum == SIGUSR1)
            {

            }
            if(msg.sigNum == SIGTSTP)
            {

            }
            if(msg.sigNum == SIGALRM)
            {
            }
        }
    }
}

Long version, to compile:

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

#define SIZEBUFF 200

// Signal handling for each process
void h_sig1(int signo);
void h_sig2(int signo);
void h_sig3(int signo);

void h_S4(int signo); // signal handling for the 4th signal

// Processes functions
void process1(void);
void process2(void);
void process3(void);

// helper functions
bool isInteger(double val);

static pid_t P1, P2, P3; // PIDs for each process

int P; // parent PID
int pfd12[2], pfd23[2]; // Pipes between processes 1-2 and 2-3
int providePIDY1[2], providePIDY2[2]; // provide all PIDs to 1/2 process

// message in message queue
typedef struct 
{
    long type;
    int sigNum;
} message;

int queue_ID;

int main(void)
{
    P = getpid();

    if (pipe(pfd12) == -1)
    {
        perror("pipe failed");
        exit(1);
    }
    if (pipe(pfd23) == -1)
    {
        perror("pipe failed");
        exit(1);
    }

    // Message queue created
    if ((queue_ID = msgget(IPC_PRIVATE,IPC_CREAT|0666)) < 0)
    {
        printf("msgget\n");
        return 1;
    }

    if (pipe(providePIDY1) == -1)
    {
        perror("pipe failed");
        exit(1);
    }
    if (pipe(providePIDY2) == -1)
    {
        perror("pipe failed");
        exit(1);
    }

    if((P1 = fork()) == 0)
    {
        P1 = getpid();
        process1();
    }
    else if(P1 < 0)
    {
        perror("fork failed");
        exit(2);
    }
    else if((P2 = fork()) == 0)
    {
        P2 = getpid();
        process2();
    }
    else if(P2 < 0)
    {
        perror("fork failed");
        exit(2);
    }
    else if((P3 = fork()) == 0)
    {
        P3 = getpid();
        process3();
    }
    else if(P3 < 0)
    {
        perror("fork failed");
        exit(2);
    }
    else
    { // Sending signals from parent through operator

        // Sending PIDs to process 1
        close(providePIDY1[0]);
        write(providePIDY1[1], &P, sizeof(int));
        write(providePIDY1[1], &P1, sizeof(int));
        write(providePIDY1[1], &P2, sizeof(int));
        write(providePIDY1[1], &P3, sizeof(int));
        close(providePIDY1[1]);

        // Sending PIDs to process 2
        close(providePIDY2[0]);
        write(providePIDY2[1], &P, sizeof(int));
        write(providePIDY2[1], &P1, sizeof(int));
        write(providePIDY2[1], &P2, sizeof(int));
        write(providePIDY2[1], &P3, sizeof(int));
        close(providePIDY2[1]);

        printf("\nProgram options:\n");
        printf("Send signal - 's'(send)\n");
        printf("Display processes PIDs 'p'(pids)\n");
        printf("Quit program - 'q'(quit)\n");

        char choice, choice2, choice3;

        while(1)
        {
            choice = getchar();

            if(choice == 's')
            {        
                printf("Which process is receiving the signal - 1, 2, or 3?: ");
                choice2 = getchar();
                choice2 = getchar();
                printf("\n");

                if((choice2 < 1) && (choice2 > 3))
                {
                    printf("No such process!");
                    continue;
                }

                printf("What signal to send?:\n");
                printf("1-S1(end execution)\n2-S2(pause execution)\n3-S3(renew execution)?\n ");
                printf("Choice: ");
                choice3 = getchar();
                choice3 = getchar();
                switch(choice2)
                {
                    case '1':  //nie można przechwycić sygnałów SIGKILL oraz SIGSTOP (zabicia oraz zatrzymania)
                        if(choice3 == '1') { kill(0,SIGCONT); kill(P1,SIGUSR1); }
                        if(choice3 == '2') kill(P1,SIGTSTP);
                        if(choice3 == '3') { kill(0,SIGCONT); kill(P3,SIGALRM); }
                        break;
                    case '2': 
                          if(choice3 == '1') { kill(0,SIGCONT); kill(P2,SIGUSR1); }
                          if(choice3 == '2') kill(P2,SIGTSTP); 
                          if(choice3 == '3') { kill(0,SIGCONT); kill(P3,SIGALRM); }
                        break;
                    case '3': 
                          if(choice3 == '1') { kill(0,SIGCONT); kill(P3,SIGUSR1); }
                          if(choice3 == '2') kill(P3,SIGTSTP);
                          if(choice3 == '3') { kill(0,SIGCONT); kill(P3,SIGALRM); }
                        break;
                    default: printf("No such operation!!! \n\n");
                }
            }

            if(choice == 'p')
            {
                printf("\n<Processes PIDs:>\n");
                printf("P(initial process)=%d\n",P);
                printf("P1(process 1)=%d\n",P1);
                printf("P2(process 2)=%d\n",P2);
                printf("P3(process 3)=%d\n\n",P3);
            }

            if(choice == 'q')
            {
                printf("\n<Quitting program>\n");
                msgctl(queue_ID, IPC_RMID, 0);
                kill(0, SIGKILL);
            }
       }

    }
}

void process1(void)
{
    int dataSize;
    char buff[SIZEBUFF];

    // Receiving PIDs
    close(providePIDY1[1]);
    read(providePIDY1[0], &P, sizeof(int));
    read(providePIDY1[0], &P1, sizeof(int));
    read(providePIDY1[0], &P2, sizeof(int));
    read(providePIDY1[0], &P3, sizeof(int));
    close(providePIDY1[0]);

    printf("\n<Process 1 execution in progress>\n");

    /*SIGACTION*/

    struct sigaction act1;

    act1.sa_handler = h_sig1;
    sigemptyset(&act1.sa_mask);
    act1.sa_flags = 0;
    sigaction(SIGUSR1, &act1, 0);
    sigaction(SIGTSTP, &act1, 0);
    sigaction(SIGALRM, &act1, 0);

    struct sigaction act;
    act.sa_handler = h_S4;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, 0);


    close(pfd12[0]);
    while(1)
    {
        printf("Provide expr: ");
        scanf("%s", buff);
        if(strcmp(buff, "0") == 0)
            break;

        dataSize = strlen(buff) + 1; // plus NULL
        if(dataSize > 0)
            write(pfd12[1], &dataSize, sizeof(int));
        write(pfd12[1], &buff, sizeof(char)*dataSize);
    }

    dataSize = 0; // info that there's no more data
    write(pfd12[1], &dataSize, sizeof(int));

    close(pfd12[1]);

    printf("\n---Process 1 finished execution---\n");

    exit(0);
}

void process2(void)
{
    int dataSize;
    char buff[SIZEBUFF];
    char *token, *end;
    int number;
    const char delim[2] = "+";

    //Odebranie pidow
    close(providePIDY2[1]);
    read(providePIDY2[0], &P, sizeof(int));
    read(providePIDY2[0], &P1, sizeof(int));
    read(providePIDY2[0], &P2, sizeof(int));
    read(providePIDY2[0], &P3, sizeof(int));
    close(providePIDY2[0]);

    printf("\n<Process 2 execution in progress>\n");

    /*SIGACTION*/
    struct sigaction act2;
    act2.sa_handler = h_sig2;
    sigemptyset(&act2.sa_mask);
    act2.sa_flags = 0;
    sigaction(SIGUSR1, &act2, 0);
    sigaction(SIGTSTP, &act2, 0);
    sigaction(SIGALRM, &act2, 0);

    struct sigaction act;
    act.sa_handler = h_S4;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, 0);

    close(pfd12[1]);

    read(pfd12[0], &dataSize, sizeof(int));
    if(dataSize > 0)
    {
        sleep(3);

        read(pfd12[0], buff, dataSize);
        token = strtok(buff, delim);
        while( token != NULL )
        {
            number = strtol(token, &end, 0);
            if(!isInteger(number))
                break;
        }
    }

    close(pfd12[0]);

    // Sending result to process 3
    close(pfd23[0]);
    write(pfd23[1], &buff, sizeof(int));
    close(pfd23[1]);

    printf("\n---Process 2 finished execution---\n");
}

void process3(void)
{
    int sum = 0;
    char buff[SIZEBUFF];
    char* token, *end;
    int number;
    const char delim[2] = "+";

    /*SIGACTION*/
    struct sigaction act3;

    act3.sa_handler = h_sig3;
    sigemptyset(&act3.sa_mask);
    act3.sa_flags = 0;
    sigaction(SIGUSR1, &act3, 0);
    sigaction(SIGTSTP, &act3, 0);
    sigaction(SIGALRM, &act3, 0);

    struct sigaction act;
    act.sa_handler = h_S4;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, 0);

    printf("\n<Process 3 execution in progress>");
    close(pfd23[1]);

    read(pfd23[0], &buff, sizeof(int));

    token = strtok(buff, delim);

    while( token != NULL )
    {
        number = strtol(token, &end, 0);
        sum += number;
    }

    printf("Sum = %d\n", sum);

    close(pfd23[0]);

    printf("\n---Process 3 finished execution ---\n");

    printf("\n---Program finished execution---\n");
    kill(getppid(),SIGKILL);

}

/*******************************************************************************************************/
/****************************************SIGNAL HANDLING (S1-S3)***********************************************/
/*******************************************************************************************************/
void h_sig1(int signo)
{
    message msg;

    msg.type = P2;
    msg.sigNum = signo;

    kill(P2, SIGINT);

    // send type of receiving signal to message queue
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    msg.type = P3;
    kill(P3, SIGINT);
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    if(signo == SIGUSR1)
    {    
        printf("\nProcess 1 received signal S1\n");
        printf("Terminating parent process!\n");
        kill(getppid(), SIGKILL);
        printf("Terminating process 1!\n");
        kill(getpid(), SIGKILL);
    }

    if(signo == SIGTSTP)
    {
        printf("\nProcess 1 received signal S2\n");
        printf("Pausing process 1!\n");
        kill(getpid(), SIGSTOP);
    }    

    if(signo == SIGALRM)
    {
        printf("\nProcess 1 received signal S3\n");
        printf("Renewing execution of process 1!\n");
        kill(getpid(), SIGCONT);
    }    
}

void h_sig2(int signo)
{
    message msg;

    msg.type = P1;
    msg.sigNum = signo;

    kill(P1, SIGINT);

    // send type of receiving signal to message queue
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    msg.type = P3;
    kill(P3, SIGINT);
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    if(signo == SIGUSR1)
    {    
        printf("\nProcess 2 received signal S1\n");
        printf("Terminating parent process!\n");
        kill(getppid(), SIGKILL);
        printf("Terminating process 2!\n");
        kill(getpid(), SIGKILL);
    }

    if(signo == SIGTSTP)
    {
        printf("\nProcess 2 received signal S2\n");
        printf("Pausing process 2!\n");
        kill(getpid(), SIGSTOP);
    }    

    if(signo == SIGALRM)
    {
        printf("\nProcess 2 received signal S3\n");
        printf("Renewing execution of process 2!\n");
        kill(getpid(), SIGCONT);
    }    
}

void h_sig3(int signo)
{
    message msg;

    msg.type = P1;
    msg.sigNum = signo;

    kill(P1, SIGINT);

    // send type of receiving signal to message queue
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    msg.type = P2;
    kill(P2, SIGINT);
    msgsnd(queue_ID, &msg, sizeof(msg.sigNum), 0);

    if(signo == SIGUSR1)
    {    
        printf("\nProcess 3 received signal S1\n");
        printf("Terminating parent process!\n");
        kill(getppid(), SIGKILL);
        printf("Terminating process 3!\n");
        kill(getpid(), SIGKILL);
    }

    if(signo == SIGTSTP)
    {
        printf("\nProcess 3 received signal S2\n");
        printf("Pausing process 3!\n");
        kill(getpid(), SIGSTOP);
    }    

    if(signo == SIGALRM)
    {
        printf("\nProcess 3 received signal S3\n");
        printf("Renewing execution of process 3!\n");
        kill(getpid(), SIGCONT);
    }    
}

/*******************************************************************************************************/
/****************************************Handling S4 signal***********************************/
/*******************************************************************************************************/

void h_S4(int signo)
{
    int res;
    message msg;

    printf("\nProcess with PID=%d received signal S4", getpid());

    if(signo == SIGINT)
    {
        res = msgrcv(queue_ID, &msg, sizeof(msg.sigNum), msg.type, 0);

        if(res >= 0)
        {            
            if(msg.sigNum == SIGUSR1)
            {
                    printf("Terminating process\n");
                    kill(getpid(),SIGKILL);

            }
            if(msg.sigNum == SIGTSTP)
            {
                    printf("Pausing process\n");
                    kill(getpid(),SIGSTOP);

            }
            if(msg.sigNum == SIGALRM)
            {
                    printf("Renewing process\n");
                    kill(getpid(),SIGCONT);

            }
        }
    }
}

bool isInteger(double val)
{
    int truncated = (int)val;
    return (val == truncated);
}

Answer 1

Source code analysis

There are consistency problems:

static pid_t P1, P2, P3; // PIDs for each process

int P; // parent PID

Why is P and int instead of a pid_t ? Why is it global instead of static ? Why is it P instead of P0 ? Should the whole lot be an array?

static pid_t P[4];

(There would be benefits to using an array!)

There is repetition that should be in a function invoked multiple times:

// Sending PIDs to process 1
close(providePIDY1[0]);
write(providePIDY1[1], &P, sizeof(int));
write(providePIDY1[1], &P1, sizeof(int));
write(providePIDY1[1], &P2, sizeof(int));
write(providePIDY1[1], &P3, sizeof(int));
close(providePIDY1[1]);

// Sending PIDs to process 2
close(providePIDY2[0]);
write(providePIDY2[1], &P, sizeof(int));
write(providePIDY2[1], &P1, sizeof(int));
write(providePIDY2[1], &P2, sizeof(int));
write(providePIDY2[1], &P3, sizeof(int));
close(providePIDY2[1]);

Note that there's also repetition because the P values aren't an array. There's also a possible portability liability; pid_t does not have to be the same size as int .

There are problems with checking inputs:

choice = getchar();

if(choice == 's')

Since choice is a char , you can get erroneous handling of EOF — if you bothered to test for it. You also leave a newline (at least) in the input, and don't skip leading spaces in the input. You'd likely do better with reading a line of data ( fgets() or POSIX readline() ) and then using if (sscanf(buffer, " %c", &choice) != 1) { …handle error… } to get the character.

Your next input block is curious:

printf("Which process is receiving the signal - 1, 2, or 3?: ");
choice2 = getchar();
choice2 = getchar();
printf("\n");

if((choice2 < 1) && (choice2 > 3))

The first input reads the newline (assuming there were no trailing spaces, etc), and the second gets a '1' , '2' , or '3' . However, you test whether the input value is both less than 1 and greater than 3, and there's no known value in the universe for which both conditions are true ( NaN values are unknown values). You really wanted something like:

if (choice2 < '1' || choice2 > '3')

After you've determined which signal to send (more or less), you have another block of repeated code because you used P1 etc instead of an array P .

There are chunks of repeated code in your child processes, such as the code that reads the process numbers. These should be in a function, too. The signal handling setup should probably be in a function too, though I've not spent a lot of time checking for the differences and similarities between the different process functions.

Major problem

You say the code is supposed to be processing arithmetic expressions. You have the main program loop reading choices about signal handling, but you seem to have process1() also trying to read expressions. This is bad news; it is indeterminate which of the processes will get to read any given input.

Back to the small stuff

You have:

dataSize = strlen(buff) + 1; // plus NULL
if(dataSize > 0)
    write(pfd12[1], &dataSize, sizeof(int));
write(pfd12[1], &buff, sizeof(char)*dataSize);

The test is a little pointless; the minimum value that strlen() can return is 0 , so the minimum value in dataSize is 1 , so the condition will always be true. (Theoretically, I suppose, you could enter so much data that the size_t returned by strlen() overflows the int dataSize , but you've not allocated enough space for that to be an actual problem — your code will have had other problems before that.)

In process2() , this code is curious:

    token = strtok(buff, delim);
    while( token != NULL )
    {
        number = strtol(token, &end, 0);
        if(!isInteger(number))
            break;
    }

There are no circumstances under which the int number; is going to be a non-integer when you scan the string with strtol() . You have a risk of overflow ( sizeof(int) != sizeof(long) on 64-bit Unix systems, for example). You have a risk of not being able to interpret the remnants of floating point value (because the . is not a valid part of an integer). You'll need to rework that code.

There's a lot of repetition in the signal handling code; it should be refactored so that you need fewer functions. It'll be easier to understand in the long run. Copy'n'paste'n'edit is a very bad way of programming when the result is near clones of the code in a single program.

I'm not clear what the differences are between the two versions you show; I've not scrutinized them. You should look at how to create an MCVE ( How to create a Minimal, Complete, and Verifiable Example? ) or SSCCE ( Short, Self-Contained, Correct Example ) — two names and links for the same basic idea. I'm not sure that either lot of code qualifies as an MCVE; both versions is overkill. Just supply the compilable code.

---

After compilation

I've compiled the second chunk of code (saved in a file called procsync.c ) on my Mac running Mac OS X 10.10.3 with GCC 5.1.0, and using the command line:

$ gcc -O3 -g -std=c11 -Wall -Wextra -Wmissing-prototypes -Wstrict-prototypes \
>     -Wold-style-definition -Werror procsync.c -o procsync
$

To my considerable surprise, the code compiled under those very stringent options with no complaints — that is something I very seldom see in code on SO.

Congratulations!

(But there are still the other issues to worry about.)