ios_2_skoro_hotovy_projekt

// xbobro01 Ivan Bobrov 1BIT for IOS
#include "proj2.h"

int load_res() {
    int ret = 0;
    j_enter_sem = sem_open(J_ENTER_SEM, O_CREAT, 0666, CLOSED);
    if (j_enter_sem == SEM_FAILED) {
        fprintf(stderr, "%s/n", "Failed to open semphore");
        ret = 1;
    }
    j_immreg_sem = sem_open(J_IMMREG_SEM, O_CREAT, 0666, CLOSED);
    if (j_immreg_sem == SEM_FAILED) {
        fprintf(stderr, "%s/n", "Failed to open semphore");
        ret = 1;
    }
    j_immexitwait_sem = sem_open(J_IMMEXITWAIT_SEM, O_CREAT, 0666, OPENED);
    if (j_immexitwait_sem == SEM_FAILED) {
        fprintf(stderr, "%s/n", "Failed to open semphore");
        ret = 1;
    }
    imm_enter_sem = sem_open(IMM_ENTER_SEM, O_CREAT, 0666, OPENED);
    if (imm_enter_sem == SEM_FAILED) {
        fprintf(stderr, "%s/n", "Failed to open semphore");
        ret = 1;
    }
    imm_reg_sem = sem_open(IMM_REG_SEM, O_CREAT, 0666, CLOSED);
    if (imm_reg_sem == SEM_FAILED) {
        fprintf(stderr, "%s/n", "Failed to open semphore");
        ret = 1;
    }
    imm_confwait_sem = sem_open(IMM_CONFWAIT_SEM, O_CREAT, 0666, CLOSED);
    if (imm_confwait_sem == SEM_FAILED) {
        fprintf(stderr, "%s/n", "Failed to open semphore");
        ret = 1;
    }
    imm_exitwait_sem = sem_open(IMM_EXITWAIT_SEM, O_CREAT, 0666, CLOSED);
    if (imm_exitwait_sem == SEM_FAILED) {
        fprintf(stderr, "%s/n", "Failed to open semphore");
        ret = 1;
    }
    write_text_sem = sem_open(WRITE_TEXT_SEM, O_CREAT, 0666, CLOSED);
    if (write_text_sem == SEM_FAILED) {
        fprintf(stderr, "%s/n", "Failed to open semphore");
        ret = 1;
    }

    int protection = PROT_READ | PROT_WRITE;
    int visibility = MAP_SHARED | MAP_ANONYMOUS;
    mem = mmap(NULL, sizeof(struct Actual_inf), protection, visibility,-1, 0);
    if (mem == MAP_FAILED) {
        fprintf(stderr, "%s/n", "Memory map creation failed");
        ret = 1;
    }
    mem->PROCESS_ID = 0;
    mem->IMM_COUNT = 0;
    mem->IMM_W_CERT = 0;
    mem->NB = 0;
    mem->NC = 0;
    mem->NE = 0;

    return(ret);
}

int clean_res() {
    int ret = 0;
    if(sem_close(j_enter_sem) == -1) {
        fprintf(stderr, "%s %s\n", "Cannot close semaphore", J_ENTER_SEM);
        ret = 1;
    }
    if(sem_close(j_immreg_sem) == -1) {
        fprintf(stderr, "%s %s\n", "Cannot close semaphore", J_IMMREG_SEM);
        ret = 1;
    }
    if(sem_close(j_immexitwait_sem) == -1) {
        fprintf(stderr, "%s %s\n", "Cannot close semaphore", J_IMMREG_SEM);
        ret = 1;
    }
    if(sem_close(imm_enter_sem) == -1) {
        fprintf(stderr, "%s %s\n", "Cannot close semaphore", IMM_ENTER_SEM);
        ret = 1;
    }
    if(sem_close(imm_reg_sem) == -1) {
        fprintf(stderr, "%s %s\n", "Cannot close semaphore", IMM_REG_SEM);
        ret = 1;
    }
    if(sem_close(imm_confwait_sem) == -1) {
        fprintf(stderr, "%s %s\n", "Cannot close semaphore", IMM_CONFWAIT_SEM);
        ret = 1;
    }
    if(sem_close(imm_exitwait_sem) == -1) {
        fprintf(stderr, "%s %s\n", "Cannot close semaphore", IMM_EXITWAIT_SEM);
        ret = 1;
    }
    if(sem_close(write_text_sem) == -1) {
        fprintf(stderr, "%s %s\n", "Cannot close semaphore", WRITE_TEXT_SEM);
        ret = 1;
    }

    if (sem_unlink(J_ENTER_SEM) == -1) {
        fprintf(stderr,"Cannot unlink semaphore 1!\n");
        ret = 1;
    }
    if (sem_unlink(J_IMMREG_SEM) == -1) {
        fprintf(stderr,"Cannot unlink semaphore 1!\n");
        ret = 1;
    }
    if (sem_unlink(J_IMMEXITWAIT_SEM) == -1) {
        fprintf(stderr,"Cannot unlink semaphore 1!\n");
        ret = 1;
    }
    if (sem_unlink(IMM_ENTER_SEM) == -1) {
        fprintf(stderr,"Cannot unlink semaphore 1!\n");
        ret = 1;
    }
    if (sem_unlink(IMM_REG_SEM) == -1) {
        fprintf(stderr,"Cannot unlink semaphore 1!\n");
        ret = 1;
    }
    if (sem_unlink(IMM_CONFWAIT_SEM) == -1) {
        fprintf(stderr,"Cannot unlink semaphore 1!\n");
        ret = 1;
    }
    if (sem_unlink(IMM_EXITWAIT_SEM) == -1) {
        fprintf(stderr,"Cannot unlink semaphore 1!\n");
        ret = 1;
    }
    if (sem_unlink(WRITE_TEXT_SEM) == -1) {
        fprintf(stderr,"Cannot unlink semaphore 1!\n");
        ret = 1;
    }

    if(munmap(mem, sizeof(struct Actual_inf)) == -1) {
        fprintf(stderr, "%s\n", "munmap failed");
        ret = 1;
    }

    return ret;
}

void random_sleep(int ms) {
    if (ms == 0) {
        usleep(0);
    } else {
        int sleep_time_microsec = (rand() % ms) * 1000;
        usleep(sleep_time_microsec);
    }
}

int params_check(struct Params *params, char *endptr_ig, char *endptr_jg, char *endptr_it, char *endptr_jt) {
    if (strcmp("", endptr_ig)
        || strcmp("", endptr_jg)
        || strcmp("", endptr_it)
        || strcmp("", endptr_jt)
        )
    {
        fprintf(stderr, "%s\n", "Wrong argument type");
        return 1;
    } else if (params->PI < 1
        || (params->IG < 0 && params->IG > 2000)
        || (params->JG < 0 && params->JG > 2000)
        || (params->IT < 0 && params->IT > 2000)
        || (params->JT < 0 && params->JT > 2000)
        )
    {
        fprintf(stderr, "%s\n", "Argument out of range");
        return 1;
    }
    return 0;
}

void immigrant_process(FILE *file, struct Params *params) {
    sem_post(write_text_sem); // TODO: fix this shit
    sem_wait(write_text_sem);
    mem->IMM_COUNT++;
    sem_post(write_text_sem);
    int self_id = mem->IMM_COUNT;

    sem_wait(write_text_sem);
    fprintf(file, "%-10d: %s %-10d: %-20s\n", ++(mem->PROCESS_ID), IMM_NAME, self_id, "starts"); //1
    sem_post(write_text_sem);

    sem_wait(imm_enter_sem); // 2a
    sem_post(j_enter_sem); // let judge process start, when first imm entered
    sem_post(imm_enter_sem);

    sem_wait(write_text_sem);
    fprintf(file, "%-10d: %s %-10d: %-20s: %-5d: %-5d: %-5d\n", //2b
    ++(mem->PROCESS_ID), IMM_NAME, self_id, "enters", ++(mem->NE), mem->NC, ++(mem->NB));
    sem_post(write_text_sem);


    sem_wait(write_text_sem);
    fprintf(file, "%-10d: %s %-10d: %-20s: %-5d: %-5d: %-5d\n", // 3
    ++(mem->PROCESS_ID), IMM_NAME, self_id, "checks", mem->NE, ++(mem->NC), mem->NB);
    sem_post(write_text_sem);

    sem_post(imm_reg_sem);

    sem_wait(imm_confwait_sem);

    sem_wait(write_text_sem);
    fprintf(file, "%-10d: %s %-10d: %-20s: %-5d: %-5d: %-5d\n",
    ++(mem->PROCESS_ID), IMM_NAME, self_id, "wants certificate", mem->NE, mem->NC, mem->NB);
    sem_post(write_text_sem);

    random_sleep(params->IT);

    sem_wait(write_text_sem);
    fprintf(file, "%-10d: %s %-10d: %-20s: %-5d: %-5d: %-5d\n",
    ++(mem->PROCESS_ID), IMM_NAME, self_id, "got certificate", mem->NE, mem->NC, mem->NB);
    sem_post(write_text_sem);
    sem_wait(imm_exitwait_sem);

    sem_wait(write_text_sem);
    fprintf(file, "%-10d: %s %-10d: %-20s: %-5d: %-5d: %-5d\n",
    ++(mem->PROCESS_ID), IMM_NAME, self_id, "leaves", mem->NE, mem->NC, --(mem->NB));
    sem_post(write_text_sem);

    if (mem->NB == 0) {
        sem_post(j_immexitwait_sem);
    }

    exit(0);
}

void judge_process(FILE *file, struct Params *params) {
    sem_wait(j_enter_sem);
    while(mem->IMM_W_CERT < params->PI) {
        random_sleep(params->JG);

        sem_wait(write_text_sem);
        fprintf(file, "%-10d: %-14s: %-20s\n", ++(mem->PROCESS_ID), J_NAME, "wants to enter");
        sem_post(write_text_sem);

        sem_wait(write_text_sem);
        fprintf(file, "%-10d: %-14s: %-20s: %-5d: %-5d: %-5d\n",
        ++(mem->PROCESS_ID), J_NAME, "enters", mem->NE, mem->NC, mem->NB);
        sem_post(write_text_sem);


        if (mem->NE != mem->NC) {
            sem_wait(write_text_sem);
            fprintf(file, "%-10d: %-14s: %-20s: %-5d: %-5d: %-5d\n",
            ++(mem->PROCESS_ID), J_NAME, "waits for imm", mem->NE, mem->NC, mem->NB);
            sem_post(write_text_sem);

            sem_wait(imm_reg_sem);
        }

        sem_wait(write_text_sem);
        fprintf(file, "%-10d: %-14s: %-20s: %-5d: %-5d: %-5d\n", // 3
        ++(mem->PROCESS_ID), J_NAME, "starts confirmation", mem->NE, mem->NC, mem->NB);
        sem_post(write_text_sem);

        random_sleep(params->JT);

        sem_wait(write_text_sem);
        mem->IMM_W_CERT += mem->NC;
        mem->NE = 0;
        mem->NC = 0;
        sem_post(write_text_sem);

        sem_wait(write_text_sem);
        fprintf(file, "%-10d: %-14s: %-20s: %-5d: %-5d: %-5d\n",
        ++(mem->PROCESS_ID), J_NAME, "ends confirmation", mem->NE, mem->NC, mem->NB);
        sem_post(write_text_sem);

        for (int i = 0; i < mem->NB; ++i) {
            sem_post(imm_confwait_sem);
        }

        random_sleep(params->JT);

        fprintf(file, "%-10d: %-14s: %-20s: %-5d: %-5d: %-5d\n",
        ++(mem->PROCESS_ID), J_NAME, "leaves", mem->NE, mem->NC, mem->NB);
        sem_post(write_text_sem);


        for (int i = 0; i < mem->NB; ++i) {
            sem_post(imm_exitwait_sem);
        }
        sem_wait(j_immexitwait_sem);
        sem_post(j_enter_sem);
    }

    sem_wait(write_text_sem);
    fprintf(file, "%-10d: %-14s: %-20s\n", ++(mem->PROCESS_ID), J_NAME, "finishes");
    sem_post(write_text_sem);

    exit(0);
}

int main(int argv, char **argc) {
    // argument validation
    if (argv != num_of_args) {
        fprintf(stderr, "%s\n", "You should enter 5 arguments");

        return 1;
    }

    struct Params params;
    char *endptr_ig, *endptr_jg, *endptr_it, *endptr_jt;
    params.PI = strtol(argc[1], NULL, int_base);
    params.IG = strtol(argc[2], &endptr_ig, int_base);
    params.JG = strtol(argc[3], &endptr_jg, int_base);
    params.IT = strtol(argc[4], &endptr_it, int_base);
    params.JT = strtol(argc[5], &endptr_jt, int_base);

    // validate params
    if(params_check(&params, endptr_ig, endptr_jg, endptr_it, endptr_jt)) {
        return 1;
    }

    // try to open file proj2.out
    FILE *file = fopen(FILE_NAME, FILE_MODE);
    if (file == NULL) {
        fclose(file);
        fprintf(stderr, "%s\n", "Failed to open file proj2.out");
        return 1;
    }
    setbuf(file, NULL);

    // try to load additional resources
    if (load_res()) {
        return 1;
    }

    pid_t immigrant;
    pid_t f_immigrant;
    pid_t judge;

    // create judge process
    judge = fork();
    if (judge == 0) {
        judge_process(file, &params); // code for judge
    }
    else if (judge > 0) { // if judge was already created
        f_immigrant = fork();
        if (f_immigrant == 0) {
            for (int i = 0; i < params.PI; ++i) {
                immigrant = fork();
                random_sleep(params.IG);
                if (immigrant == 0) {
                    immigrant_process(file, &params); // code for immigrant
                }
            }
            waitpid(immigrant, NULL, 0);
            exit(0);
        }
        else if (f_immigrant < 0){
            fprintf(stderr, "%s\n", "Could not create immigrant child process");
        }
    }
    else {
        fprintf(stderr, "%s\n", "Could not create judge child process");
    }

    waitpid(f_immigrant, NULL, 0);
    waitpid(judge, NULL, 0);
    if(clean_res()) {
        return 1;
    }
    fclose(file);
    return 0;
}