OS 8

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

pid_t processes[9];
int processIndex = 0, countUSR1 = 0, isTERM = 0;

long unsigned getMicroSeconds() {
    struct timeval tp;
    gettimeofday(&tp, NULL);
    return tp.tv_usec;
}

void sendSignals(int index, int signal, int sigCount) {
    for (int i = 1; i <= sigCount; i++) {
        kill(processes[index], signal);
        printf("Process %d (pid %d || ppid %d) sent USR1 to process %d at time %lu\n", processIndex, getpid(), getppid(), index, getMicroSeconds());
        sleep(2);
    }
    kill(processes[index], SIGTERM);
}

void sendSignalsToGroup(int *indexes, int signal, int sigCount) {
    setpgid(processes[indexes[0]],processes[indexes[0]]);
    setpgid(processes[indexes[1]], processes[indexes[0]]);
    pid_t pgid = getpgid(processes[indexes[0]]);
    for (int i = 1; i <= sigCount; i++) {
        killpg(pgid, signal);
        printf("Process %d (pid %d || ppid %d) sent USR1 to process %d & %d at time %lu\n", processIndex, getpid(), getppid(), indexes[0], indexes[1], getMicroSeconds());
        sleep(2);
    }
    killpg(pgid, SIGTERM);
}

void usrHandler(int i) {
    sleep(1);
    countUSR1++;
    printf("Process %d (pid %d || ppid %d) got USR1 at time %lu\n", processIndex, getpid(), getppid(), getMicroSeconds());
}

void termHandler(int i) {
    sleep(1);
    isTERM = 1;
}

void processActions(int processIndex, int sigCount) {
    signal(SIGUSR1, usrHandler);
    signal(SIGTERM, termHandler);
    sleep(1);

    switch (processIndex) {
        case 1: { int *indexes = malloc(2 * sizeof(int));
                indexes[0] = 2;
                indexes[1] = 3;
                sendSignalsToGroup(indexes, SIGUSR1, sigCount);
                free(indexes);
                break;
            }

        case 2: { int *indexes = malloc(2 * sizeof(int));
                indexes[0] = 4;
                indexes[1] = 5;
                sendSignalsToGroup(indexes, SIGUSR1, sigCount);
                free(indexes);
                break;
            }

        case 5: sendSignals(6, SIGUSR1, sigCount);
                break;

        case 6: { int *indexes = malloc(2 * sizeof(int));
                indexes[0] = 7;
                indexes[1] = 8;
                sendSignalsToGroup(indexes, SIGUSR1, sigCount);
                free(indexes);
                break;
            }

        case 8: sendSignals(1, SIGUSR1, sigCount);
                break;
    }

    int status = 0;
    while (wait(&status) > 0) ;
    while (!isTERM);
    printf("--Process %d (pid %d || ppid %d) terminating after %d signal USR1 at time %lu--\n", processIndex, getpid(), getppid(), countUSR1, getMicroSeconds());
    exit(0);
}

// 1->2,3 / 2->4,5 / 5->6 / 6->7,8

void createProcesses(int mypipe[2]) {
    int status;
    processes[0] = getpid();
    processes[1] = fork();
    if (processes[1] > 0) {
        write(mypipe[1], &processes[1], sizeof(pid_t));
        // 0
        return;
    }
    else {
        processes[2] = fork();
        if (processes[2] > 0) {
            processIndex = 1;
            processes[3] = fork();
            if (processes[3] == 0) {
                processIndex = 3;
                // 3
                return;
            }
            // 1
            else return;
        }
        else {
        processIndex = 2;
        processes[4] = fork();
        if (processes[4] == 0) {
            processIndex = 4;
            // 4
            return;
        }
        processes[5] = fork();
        if (processes[5] > 0) {
            // 2
            return;
        }
        processIndex = 5;
        processes[6] = fork();
        if (processes[6] > 0) {
            // 5
            return;
        }
        processIndex = 6;
        processes[7] = fork();
        if (processes[7] == 0) {
            processIndex = 7;
            // 7
            return;
        }
        processes[8] = fork();
        if (processes[8] == 0) {
            processIndex = 8;
            read(mypipe[0], &processes[1], sizeof(pid_t));
        }
        // 6 & 8
        return;
        }
    }
}

int main(int argc, char *argv[]) {
    if (argc < 2) return -1;
    int mypipe[2];
    pipe(mypipe);
    createProcesses(mypipe);
    sleep(1);
    close(mypipe[0]);
    close(mypipe[1]);
   /* printf("Process #%d || Pid %d || All pids %d %d %d %d %d %d %d %d\n",
    processIndex, getpid(), processes[1], processes[2], processes[3],
    processes[4], processes[5], processes[6], processes[7], processes[8]);*/
    if (processIndex != 0) processActions(processIndex, atoi(argv[1]));
    int status;
    while (wait(&status) > 0) ;
    return 0;
}