#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <stdio.h>

enum { BITS = 8 };

volatile sig_atomic_t flag = 0;
volatile sig_atomic_t bit = -1;

void
handler1(int s)
{
    bit = 0;
}

void
handler2(int s)
{
    bit = 1;
}

void
handler3(int s)
{
    flag = 1;
}

void
handler4(int s)
{
    _exit(0);
}

int
main(int argc, char *argv[])
{
    sigset_t s1;
    sigemptyset(&s1);
    sigaddset(&s1, SIGUSR1);
    sigaddset(&s1, SIGUSR2);
    sigaddset(&s1, SIGALRM);
    sigaddset(&s1, SIGIO);
    sigprocmask(SIG_BLOCK, &s1, NULL);
    unsigned char byte;
    pid_t pid1, pid2;
    int fds[2];
    if (pipe(fds) == -1) {
        return 1;
    }
    pid1 = fork();
    if (pid1 == -1) {
        return 1;
    } else if (!pid1) {    // son 1 process
        close(fds[1]);
        sigset_t s2;
        sigemptyset(&s2);
        sigaction(SIGUSR1, &(struct sigaction){ .sa_handler = handler1, .sa_flags = SA_RESTART }, NULL);
        sigaction(SIGUSR2, &(struct sigaction){ .sa_handler = handler2, .sa_flags = SA_RESTART }, NULL);
        sigaction(SIGIO, &(struct sigaction){ .sa_handler = handler4, .sa_flags = SA_RESTART }, NULL);
        if (read(fds[0], &pid2, sizeof(pid2)) != sizeof(pid2)) {
            _exit(1);
        }
        close(fds[0]);
        int bitcnt = 1;
        int output = 0;

        while (1) {
            while (bit == -1) {
                sigsuspend(&s2);
            }
            output += bit;
            if (bitcnt == 8) {
                putchar(output);
                fflush(stdout);
                bitcnt = 0;
                output = 0;
            }
            output <<= 1;
            bit = -1;
            bitcnt++;
            kill(pid2, SIGALRM);
        }
        _exit(0);
    }

    pid2 = fork();
    if (pid2 == -1) {
        return 1;
    } else if (!pid2) {     // son 2 process
        sigset_t s2;
        sigemptyset(&s2);
        sigaction(SIGALRM, &(struct sigaction){ .sa_handler = handler3, .sa_flags = SA_RESTART }, NULL);
        close(fds[0]);
        pid2 = getpid();
        if (write(fds[1], &pid2, sizeof(pid2)) != sizeof(pid2)) {
            _exit(1);
        }
        close(fds[1]);
        int fd = open(argv[1], O_RDONLY);
        if (fd == -1) {
            _exit(1);
        }
        while (read(fd, &byte, sizeof(byte)) == sizeof(byte)) {
            for (int i = 0; i < BITS; ++i) {
                if (byte & 0x80) {
                    kill(pid1, SIGUSR2);
                } else {
                    kill(pid1, SIGUSR1);
                }
                while (!flag) {
                    sigsuspend(&s2);
                }
                flag = 0;
                byte <<= 1;
            }
        }
        close(fd);
        kill(pid1, SIGIO);
        _exit(0);
    }

    close(fds[0]);
    close(fds[1]);
    waitpid(pid1, NULL, 0);
    waitpid(pid2, NULL, 0);

    return 0;
}